Refactoring: Memory management

.gitmodules

@@ -25,6 +25,9 @@
 [submodule "src/3rdparty/weakjack/weakjack"]
 	path = src/3rdparty/weakjack/weakjack
 	url = https://github.com/x42/weakjack.git
+[submodule "src/3rdparty/libcds"]
+	path = src/3rdparty/libcds
+	url = https://github.com/khizmax/libcds.git
 [submodule "doc/wiki"]
 	path = doc/wiki
 	url = https://github.com/lmms/lmms.wiki.git

CMakeLists.txt

@@ -698,6 +698,7 @@ include(CompileCache)
 ADD_SUBDIRECTORY(cmake)
 ADD_SUBDIRECTORY(src)
 ADD_SUBDIRECTORY(plugins)
+ADD_SUBDIRECTORY(benchmarks)
 ADD_SUBDIRECTORY(tests)
 ADD_SUBDIRECTORY(data)
 ADD_SUBDIRECTORY(doc)

LICENSE.MIT.txt

@@ -0,0 +1,18 @@
+The MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

benchmarks/CMakeLists.txt

@@ -0,0 +1,13 @@
+SET(CMAKE_AUTOMOC ON)
+
+ADD_EXECUTABLE(benchmarks
+	EXCLUDE_FROM_ALL
+	benchmark.cpp
+)
+
+# TODO replace usages of include_directories in src/CMakeLists.txt with target_include_directories
+# and remove this line (also in tests/CMakeLists.txt)
+target_include_directories(benchmarks PRIVATE $<TARGET_PROPERTY:lmmsobjs,INCLUDE_DIRECTORIES>)
+
+target_static_libraries(benchmarks PRIVATE lmmsobjs)
+target_compile_features(benchmarks PRIVATE cxx_std_17)

benchmarks/benchmark.cpp

@@ -0,0 +1,130 @@
+#include <thread>
+
+#include <QtCore/QCoreApplication>
+#include <QtCore/QDebug>
+
+#include "libcds.h"
+#include <cds/container/vyukov_mpmc_cycle_queue.h>
+
+#include "Engine.h"
+#include "PerfLog.h"
+
+#include "LocklessList.h"
+#include "MemoryPool.h"
+
+#include "NotePlayHandle.h"
+
+using namespace lmms;
+
+template<typename T>
+using LocklessQueue = cds::container::VyukovMPMCCycleQueue<T>;
+
+template<typename Alloc>
+void benchmark_allocator(QString name, Alloc&& alloc, size_t n, size_t I)
+{
+	using T = typename Alloc::value_type;
+	constexpr size_t S = sizeof(T);
+
+	std::vector<T*> ptrs{n};
+	PerfLogTimer timer(QString("Allocate: %1 x %2 x %3 bytes, %4")
+					   .arg(I).arg(n).arg(S).arg(name));
+
+	for (size_t i=0; i < I; i++)
+	{
+		for (size_t j=0; j < n; j++) {
+			ptrs[j] = alloc.allocate(1);
+		}
+		for (size_t j=0; j < n; j++) {
+			alloc.deallocate(ptrs[j], 1);
+		}
+	}
+}
+
+
+template<typename Alloc>
+void benchmark_allocator_threaded(QString name, Alloc&& alloc, size_t n, size_t t)
+{
+	using T = typename Alloc::value_type;
+	constexpr size_t S = sizeof(T);
+
+	LocklessQueue<T*> ptrs{n};
+
+	PerfLogTimer timer(QString("Allocate multi-threaded: %1 x %2 bytes using %3 threads, %4")
+					   .arg(n).arg(S).arg(t).arg(name));
+
+	std::vector<std::thread> threads; threads.reserve(t*2);
+
+	std::atomic_uint_fast64_t allocated{0};
+	std::atomic_uint_fast64_t deallocated{0};
+
+	for (size_t i=0; i < t; i++) {
+		threads.emplace_back([&]() {
+			while(allocated++ < n) {
+				auto ptr = alloc.allocate(1);
+				ptrs.push(ptr);
+			}
+		});
+	}
+	for (size_t i=0; i < t; i++) {
+		threads.emplace_back([&]() {
+			while(deallocated++ < n) {
+				T* ptr;
+				while (! ptrs.pop(ptr));
+				alloc.deallocate(ptr, 1);
+			}
+		});
+	}
+
+	for (std::thread& thread : threads) {
+		thread.join();
+	}
+}
+
+int main(int argc, char* argv[])
+{
+	new QCoreApplication(argc, argv);
+
+	using Stack = LocklessList<size_t>;
+	{
+		size_t n = 100 * 1000 * 1000;
+		Stack stack{n};
+		PerfLogTimer timer("LocklessList: Insert 100m entries, single-threaded, pre-allocated");
+		for (size_t i=0; i < n; i++) {
+			stack.push(i);
+		}
+	}
+	{
+		size_t n = 50 * 1000 * 1000;
+		size_t t = 5;
+		Stack stack{n};
+		std::vector<std::thread> threads; threads.reserve(t);
+		PerfLogTimer timer("LocklessList: Push 50m entries, multi-threaded, pre-allocated");
+
+		for (int i=0; i < 5; i++) {
+			threads.emplace_back([&]() {
+				for (size_t j=0; j < n / t; j++) {
+					stack.push(j);
+				}
+			});
+		}
+
+		for (int i=0; i < 5; i++) {
+			threads.at(i).join();
+		}
+	}
+
+	{
+		size_t n = 10 * 1000 * 1000;
+		constexpr size_t S = 256;
+		using T = std::array<char, S>;
+		benchmark_allocator("std::allocator", std::allocator<T>{}, n, 1);
+		benchmark_allocator("MemoryPool", MemoryPool<T>{n}, n, 1);
+	}
+	{
+		size_t n = 10 * 1000 * 1000;
+		constexpr size_t S = 256;
+		using T = std::array<char, S>;
+		benchmark_allocator_threaded("std::allocator", std::allocator<T>{}, n, 4);
+		benchmark_allocator_threaded("MemoryPool", MemoryPool<T>{n}, n, 4);
+	}
+}

cmake/modules/CheckSubmodules.cmake

@@ -44,8 +44,8 @@ SET(ENV{LC_ALL} "C")
 SET(ENV{LANG} "en_US")
 
 # Submodule list pairs, unparsed (WARNING: Assumes alpha-numeric paths)
-STRING(REGEX MATCHALL "path = [-0-9A-Za-z/]+" SUBMODULE_LIST_RAW ${SUBMODULE_DATA})
-STRING(REGEX MATCHALL "url = [.:%-0-9A-Za-z/]+" SUBMODULE_URL_RAW ${SUBMODULE_DATA})
+STRING(REGEX MATCHALL "path = [-0-9A-Za-z/_]+" SUBMODULE_LIST_RAW ${SUBMODULE_DATA})
+STRING(REGEX MATCHALL "url = [.:%-0-9A-Za-z/_]+" SUBMODULE_URL_RAW ${SUBMODULE_DATA})
 
 # Submodule list pairs, parsed
 SET(SUBMODULE_LIST "")

include/BufferManager.h → include/BufferPool.h

@@ -1,5 +1,5 @@
 /*
- * BufferManager.h - A buffer caching/memory management system
+ * BufferPool.h
  *
  * Copyright (c) 2014 Vesa Kivimäki <contact/dot/diizy/at/nbl/dot/fi>
  * Copyright (c) 2006-2014 Tobias Doerffel <tobydox/at/users.sourceforge.net>
@@ -23,8 +23,7 @@
  *
  */
 
-#ifndef LMMS_BUFFER_MANAGER_H
-#define LMMS_BUFFER_MANAGER_H
+#pragma once
 
 #include "lmms_export.h"
 #include "lmms_basics.h"
@@ -34,7 +33,8 @@ namespace lmms
 
 class SampleFrame;
 
-class LMMS_EXPORT BufferManager
+/// Legacy interface for buffer re-use. Uses MemoryPool internally now.
+class LMMS_EXPORT BufferPool
 {
 public:
 	static void init( fpp_t fpp );
@@ -47,5 +47,3 @@ class LMMS_EXPORT BufferManager
 
 
 } // namespace lmms
-
-#endif // LMMS_BUFFER_MANAGER_H

include/LocklessList.h

@@ -25,7 +25,7 @@
 #ifndef LMMS_LOCKLESS_LIST_H
 #define LMMS_LOCKLESS_LIST_H
 
-#include "LocklessAllocator.h"
+#include "MemoryPool.h"
 
 #include <atomic>
 
@@ -44,7 +44,7 @@ class LocklessList
 
 	LocklessList( size_t size ) :
 		m_first(nullptr),
-		m_allocator(new LocklessAllocatorT<Element>(size))
+		m_allocator(new MemoryPool<Element>(size))
 	{
 	}
 
@@ -55,7 +55,7 @@ class LocklessList
 
 	void push( T value )
 	{
-		Element * e = m_allocator->alloc();
+		Element * e = m_allocator->allocate();
 		e->value = value;
 		e->next = m_first.load(std::memory_order_relaxed);
 
@@ -84,14 +84,13 @@ class LocklessList
 
 	void free( Element * e )
 	{
-		m_allocator->free( e );
+		m_allocator->destroy( e );
 	}
 
 
 private:
 	std::atomic<Element*> m_first;
-	LocklessAllocatorT<Element> * m_allocator;
-
+	MemoryPool<Element> * m_allocator;
 } ;