Refactoring: Memory management

.gitmodules

@@ -31,6 +31,9 @@
 [submodule "src/3rdparty/mingw-std-threads"]
 	path = src/3rdparty/mingw-std-threads
 	url = https://github.com/meganz/mingw-std-threads.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

@@ -140,6 +140,7 @@ CHECK_INCLUDE_FILES(locale.h LMMS_HAVE_LOCALE_H)
 
 LIST(APPEND CMAKE_PREFIX_PATH "${CMAKE_INSTALL_PREFIX}")
 
+
 FIND_PACKAGE(Qt5 COMPONENTS Core Gui Widgets Xml REQUIRED)
 FIND_PACKAGE(Qt5 COMPONENTS LinguistTools QUIET)
 
@@ -150,6 +151,8 @@ INCLUDE_DIRECTORIES(
 	${Qt5Xml_INCLUDE_DIRS}
 )
 
+INCLUDE_DIRECTORIES("${CMAKE_SOURCE_DIR}/src/3rdparty/mingw-std-threads")
+
 SET(QT_LIBRARIES
 	Qt5::Core
 	Qt5::Gui
@@ -561,6 +564,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,15 @@
+INCLUDE_DIRECTORIES("${CMAKE_CURRENT_SOURCE_DIR}")
+INCLUDE_DIRECTORIES("${CMAKE_CURRENT_BINARY_DIR}")
+INCLUDE_DIRECTORIES("${CMAKE_SOURCE_DIR}/include")
+INCLUDE_DIRECTORIES("${CMAKE_BINARY_DIR}")
+
+SET(CMAKE_CXX_STANDARD 11)
+
+SET(CMAKE_AUTOMOC ON)
+
+ADD_EXECUTABLE(benchmarks
+	EXCLUDE_FROM_ALL
+	benchmark.cpp
+	$<TARGET_OBJECTS:lmmsobjs>
+)
+TARGET_LINK_LIBRARIES(benchmarks ${QT_LIBRARIES} ${LMMS_REQUIRED_LIBS})

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"
+
+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("MmAllocator", MmAllocator<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("MmAllocator", MmAllocator<T>{}, n, 4);
+		benchmark_allocator_threaded("MemoryPool", MemoryPool<T>{n}, n, 4);
+	}
+}

cmake/modules/BuildPlugin.cmake

@@ -5,10 +5,14 @@
 
 INCLUDE(GenQrc)
 
-MACRO(BUILD_PLUGIN PLUGIN_NAME)
-	CMAKE_PARSE_ARGUMENTS(PLUGIN "" "LINK;EXPORT_BASE_NAME" "MOCFILES;EMBEDDED_RESOURCES;UICFILES" ${ARGN})
+FUNCTION(BUILD_PLUGIN PLUGIN_NAME)
+	CMAKE_PARSE_ARGUMENTS(PLUGIN "" "DESTINATION;LINK;EXPORT_BASE_NAME" "MOCFILES;EMBEDDED_RESOURCES;UICFILES" ${ARGN})
 	SET(PLUGIN_SOURCES ${PLUGIN_UNPARSED_ARGUMENTS})
 
+	IF(NOT PLUGIN_DESTINATION)
+		SET(PLUGIN_DESTINATION "${PLUGIN_DIR}")
+	ENDIF()
+
 	INCLUDE_DIRECTORIES("${CMAKE_CURRENT_BINARY_DIR}" "${CMAKE_BINARY_DIR}" "${CMAKE_SOURCE_DIR}/include")
 
 	ADD_DEFINITIONS(-DPLUGIN_NAME=${PLUGIN_NAME})
@@ -56,22 +60,13 @@ MACRO(BUILD_PLUGIN PLUGIN_NAME)
 
 	ADD_LIBRARY(${PLUGIN_NAME} ${PLUGIN_LINK} ${PLUGIN_SOURCES} ${plugin_MOC_out} ${RCC_OUT})
 
-	TARGET_LINK_LIBRARIES(${PLUGIN_NAME} Qt5::Widgets Qt5::Xml)
-
-	IF(LMMS_BUILD_WIN32)
-		TARGET_LINK_LIBRARIES(${PLUGIN_NAME} lmms)
-	ENDIF(LMMS_BUILD_WIN32)
+	TARGET_LINK_LIBRARIES(${PLUGIN_NAME} Qt5::Widgets Qt5::Xml lmms)
 
-	INSTALL(TARGETS ${PLUGIN_NAME} DESTINATION "${PLUGIN_DIR}")
+	INSTALL(TARGETS ${PLUGIN_NAME} DESTINATION "${PLUGIN_DESTINATION}")
 
-	IF(LMMS_BUILD_APPLE)
-		IF ("${PLUGIN_LINK}" STREQUAL "SHARED")
-			SET_TARGET_PROPERTIES(${PLUGIN_NAME} PROPERTIES LINK_FLAGS "-undefined dynamic_lookup")
-		ELSE()
-			SET_TARGET_PROPERTIES(${PLUGIN_NAME} PROPERTIES LINK_FLAGS "-bundle_loader \"${CMAKE_BINARY_DIR}/lmms\"")
-		ENDIF()
-		ADD_DEPENDENCIES(${PLUGIN_NAME} lmms)
-	ENDIF(LMMS_BUILD_APPLE)
+	IF(LMMS_BUILD_APPLE AND "${PLUGIN_LINK}" STREQUAL "SHARED")
+		SET_TARGET_PROPERTIES(${PLUGIN_NAME} PROPERTIES LINK_FLAGS "-undefined dynamic_lookup")
+	ENDIF()
 	IF(LMMS_BUILD_WIN32 AND STRIP)
 		SET_TARGET_PROPERTIES(${PLUGIN_NAME} PROPERTIES PREFIX "")
 		ADD_CUSTOM_COMMAND(TARGET ${PLUGIN_NAME} POST_BUILD COMMAND ${STRIP} "$<TARGET_FILE:${PLUGIN_NAME}>")
@@ -89,5 +84,4 @@ MACRO(BUILD_PLUGIN PLUGIN_NAME)
 	TARGET_INCLUDE_DIRECTORIES(${PLUGIN_NAME}
 		PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
 	)
-ENDMACRO(BUILD_PLUGIN)
-
+ENDFUNCTION(BUILD_PLUGIN)

cmake/modules/CheckSubmodules.cmake

@@ -42,8 +42,8 @@ SET(ENV{LC_ALL} "C")
 SET(ENV{LANG} "en_US")
 
 # Assume alpha-numeric paths
-STRING(REGEX MATCHALL "path = [-0-9A-Za-z/]+" SUBMODULE_LIST ${SUBMODULE_DATA})
-STRING(REGEX MATCHALL "url = [.:%-0-9A-Za-z/]+" SUBMODULE_URL_LIST ${SUBMODULE_DATA})
+STRING(REGEX MATCHALL "path = [-0-9A-Za-z/_]+" SUBMODULE_LIST ${SUBMODULE_DATA})
+STRING(REGEX MATCHALL "url = [.:%-0-9A-Za-z/_]+" SUBMODULE_URL_LIST ${SUBMODULE_DATA})
 
 FOREACH(_part ${SUBMODULE_LIST})
 	STRING(REPLACE "path = " "" SUBMODULE_PATH ${_part})

cmake/modules/DetectMachine.cmake

@@ -1,3 +1,5 @@
+INCLUDE(CheckCXXSourceCompiles)
+
 IF(WIN32)
 	SET(LMMS_BUILD_WIN32 1)
 ELSEIF(APPLE)
@@ -86,3 +88,27 @@ IF(LMMS_BUILD_APPLE)
 	STRING(REGEX REPLACE "\\.[0-9]*$" "" APPLE_OS_VER "${APPLE_OS_VER}")
 	SET(CMAKE_MACOSX_RPATH 1)	
 ENDIF()
+
+# Detect MinGW
+IF(WIN32 AND CMAKE_COMPILER_IS_GNUCXX)
+	SET(MINGW TRUE)
+ENDIF()
+
+# Detect MINGW thread support
+IF(MINGW)
+	CHECK_CXX_SOURCE_COMPILES("
+	#include <mutex>
+	#include <thread>
+	int main(int argc, const char* argv[]) {
+		std::mutex m;
+		std::this_thread::yield();
+		return 0;
+	}
+	" HAS_STD_THREADS)
+	IF(NOT HAS_STD_THREADS)
+		SET(NEED_MINGW_THREADS_REPLACEMENT TRUE)
+	ELSE()
+		SET(NEED_MINGW_THREADS_REPLACEMENT FALSE)
+	ENDIF()
+	MESSAGE(NEED_MINGW_THREADS_REPLACEMENT ${NEED_MINGW_THREADS_REPLACEMENT})
+ENDIF()

cmake/toolchains/common/Ubuntu-MinGW-W64.cmake

@@ -5,13 +5,16 @@ set(CMAKE_C_COMPILER      ${TOOLCHAIN_PREFIX}-gcc)
 set(CMAKE_CXX_COMPILER    ${TOOLCHAIN_PREFIX}-g++)
 set(CMAKE_RC_COMPILER     ${TOOLCHAIN_PREFIX}-windres)
 
-set(CMAKE_FIND_ROOT_PATH  /usr/${TOOLCHAIN_PREFIX})
+set(MINGW_PREFIX          /usr/${TOOLCHAIN_PREFIX})
+
+set(CMAKE_FIND_ROOT_PATH  ${MINGW_PREFIX})
 SET(ENV{PKG_CONFIG}       /usr/bin/${TOOLCHAIN_PREFIX}-pkg-config)
 
 IF(WIN64)
 	SET(TOOLCHAIN_PREFIX32   ${CMAKE_SYSTEM_PROCESSOR32}-w64-mingw32)
 	SET(CMAKE_C_COMPILER32   ${TOOLCHAIN_PREFIX32}-gcc)
 	SET(CMAKE_CXX_COMPILER32 ${TOOLCHAIN_PREFIX32}-g++)
+	set(MINGW_PREFIX32       /usr/${TOOLCHAIN_PREFIX32})
 ENDIF()
 
 INCLUDE(${CMAKE_CURRENT_LIST_DIR}/WinCrossCompile.cmake)

include/AudioPort.h

@@ -30,7 +30,7 @@
 #include <QtCore/QMutex>
 #include <QtCore/QMutexLocker>
 
-#include "MemoryManager.h"
+#include "Memory.h"
 #include "PlayHandle.h"
 
 class EffectChain;

include/AutomatableModel.h

@@ -32,7 +32,7 @@
 #include "Model.h"
 #include "MidiTime.h"
 #include "ValueBuffer.h"
-#include "MemoryManager.h"
+#include "Memory.h"
 #include "ModelVisitor.h"
 
 // simple way to map a property of a view to a model

include/BasicFilters.h

@@ -41,7 +41,7 @@
 #include "lmms_basics.h"
 #include "lmms_constants.h"
 #include "interpolation.h"
-#include "MemoryManager.h"
+#include "Memory.h"
 
 template<ch_cnt_t CHANNELS=DEFAULT_CHANNELS> class BasicFilters;
 

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,25 +23,16 @@
  *
  */
 
-#ifndef BUFFER_MANAGER_H
-#define BUFFER_MANAGER_H
+#pragma once
 
 #include "lmms_export.h"
 #include "lmms_basics.h"
 
-class LMMS_EXPORT BufferManager
+/// Legacy interface for buffer re-use. Uses MemoryPool internally now.
+class LMMS_EXPORT BufferPool
 {
 public:
 	static void init( fpp_t framesPerPeriod );
 	static sampleFrame * acquire();
-	// audio-buffer-mgm
-	static void clear( sampleFrame * ab, const f_cnt_t frames,
-						const f_cnt_t offset = 0 );
-#ifndef LMMS_DISABLE_SURROUND
-	static void clear( surroundSampleFrame * ab, const f_cnt_t frames,
-						const f_cnt_t offset = 0 );
-#endif
 	static void release( sampleFrame * buf );
 };
-
-#endif

include/DataFile.h

@@ -30,7 +30,7 @@
 #include <QDomDocument>
 
 #include "lmms_export.h"
-#include "MemoryManager.h"
+#include "Memory.h"
 
 class QTextStream;
 

include/Delay.h

@@ -30,7 +30,7 @@
 #include "lmms_basics.h"
 #include "lmms_math.h"
 #include "interpolation.h"
-#include "MemoryManager.h"
+#include "Memory.h"
 
 // brief usage