Added benchmark for CallbackList append/remove callbacks

doc/benchmark.md

@@ -1,5 +1,9 @@
 # Benchmarks
 
+Hardware: Intel(R) Xeon(R) CPU E3-1225 V2 @ 3.20GHz  
+Software: Windows 10, MSVC 2017, MinGW GCC 7.2.0  
+Time unit: milliseconds (unless explicitly specified)
+
 ## EventQueue enqueue and process -- single threading
 
 <table>
@@ -41,7 +45,7 @@
 </tr>
 <table>
 
-Given `eventpp::EventQueue<int, void (int), Policies>`, which `Policies` is either single threading or multi threading, the benchmark adds `Listener count` listeners to the queue, each listener is an empty lambda. Then the benchmark starts timing. It loops `Iterations` times. In each loop, the benchmark puts `Queue size` events, then process the event queue.  
+Given `eventpp::EventQueue<size_t, void (size_t), Policies>`, which `Policies` is either single threading or multi threading, the benchmark adds `Listener count` listeners to the queue, each listener is an empty lambda. Then the benchmark starts timing. It loops `Iterations` times. In each loop, the benchmark puts `Queue size` events, then process the event queue.  
 There are `Event types` kinds of event type. `Event count` is `Iterations * Queue size`.  
 The EventQueue is processed in one thread. The Single/Multi threading in the table means the policies used.
 
@@ -109,12 +113,14 @@ The EventQueue is processed in one thread. The Single/Multi threading in the tab
 There are `Enqueue threads` threads enqueuing events to the queue, and `Process threads` threads processing the events. The total event count is `Event count`.  
 The multi threading version shows slower than previous single threading version, since the mutex locks cost time.
 
+## CallbackList append/remove callbacks
+
+The benchmark loops 100K times, in each loop it appends 1000 empty callbacks to a CallbackList, then remove all that 1000 callbacks. So there are totally 100M append/remove operations.  
+The total benchmarked time is about 21000 milliseconds. That's to say in 1 milliseconds there can be 5000 append/remove operations.
+
 ## CallbackList invoking VS native function invoking
 
-Hardware: Intel(R) Xeon(R) CPU E3-1225 V2 @ 3.20GHz  
-Software: Windows 10, MSVC 2017, MinGW GCC 7.2.0  
 Iterations: 100,000,000  
-Time unit: milliseconds
 
 <table>
 <tr>

include/eventpp/callbacklist.h

@@ -16,12 +16,13 @@
 
 #include "eventpolicies.h"
 
+#include <atomic>
+#include <condition_variable>
 #include <functional>
 #include <memory>
 #include <mutex>
-#include <atomic>
-#include <condition_variable>
 #include <utility>
+#include <vector>
 
 namespace eventpp {
 
@@ -197,7 +198,7 @@ class CallbackListBase<
 
 	Handle append(const Callback & callback)
 	{
-		NodePtr node(std::make_shared<Node>(callback, getNextCounter()));
+		NodePtr node(doAllocateNode(callback));
 
 		std::lock_guard<Mutex> lockGuard(mutex);
 
@@ -216,7 +217,7 @@ class CallbackListBase<
 
 	Handle prepend(const Callback & callback)
 	{
-		NodePtr node(std::make_shared<Node>(callback, getNextCounter()));
+		NodePtr node(doAllocateNode(callback));
 
 		std::lock_guard<Mutex> lockGuard(mutex);
 
@@ -237,7 +238,7 @@ class CallbackListBase<
 	{
 		NodePtr beforeNode = before.lock();
 		if(beforeNode) {
-			NodePtr node(std::make_shared<Node>(callback, getNextCounter()));
+			NodePtr node(doAllocateNode(callback));
 
 			std::lock_guard<Mutex> lockGuard(mutex);
 
@@ -254,7 +255,7 @@ class CallbackListBase<
 		std::lock_guard<Mutex> lockGuard(mutex);
 		auto node = handle.lock();
 		if(node) {
-			doRemoveNode(node);
+			doFreeNode(node);
 			return true;
 		}
 
@@ -336,7 +337,26 @@ class CallbackListBase<
 		return func(node->callback);
 	}
 
-	void doRemoveNode(NodePtr & node)
+	void doInsert(NodePtr & node, NodePtr & beforeNode)
+	{
+		node->previous = beforeNode->previous;
+		node->next = beforeNode;
+		if(beforeNode->previous) {
+			beforeNode->previous->next = node;
+		}
+		beforeNode->previous = node;
+
+		if(beforeNode == head) {
+			head = node;
+		}
+	}
+
+	NodePtr doAllocateNode(const Callback & callback)
+	{
+		return std::make_shared<Node>(callback, getNextCounter());
+	}
+
+	void doFreeNode(NodePtr & node)
 	{
 		if(node->next) {
 			node->next->previous = node->previous;
@@ -359,20 +379,6 @@ class CallbackListBase<
 		// because node may be still used in a loop.
 	}
 
-	void doInsert(NodePtr & node, NodePtr & beforeNode)
-	{
-		node->previous = beforeNode->previous;
-		node->next = beforeNode;
-		if(beforeNode->previous) {
-			beforeNode->previous->next = node;
-		}
-		beforeNode->previous = node;
-
-		if(beforeNode == head) {
-			head = node;
-		}
-	}
-
 	Counter getNextCounter()
 	{
 		Counter result = ++currentCounter;;

readme.md

@@ -16,6 +16,7 @@ eventpp is a C++ event library that provides tools that allow your application c
 - **Fast**
   - The EventQueue can process 10M events in 1 second (10K events per millisecond).
   - The CallbackList can invoke 100M callbacks in 1 second (100K callbacks per millisecond).
+  - The CallbackList can add/remove 5M callbacks in 1 second (5K callbacks per millisecond).
 - **Flexible and easy to use**
   - The listeners and events can be any type, no need to inherit from any base class.
   - Header only, no source file, no need to build. No dependencies on other libraries.

tests/benchmark.cpp

@@ -125,15 +125,15 @@ void doExecuteEventQueue(
 		size_t listenerCount = 0
 	)
 {
-	using EQ = eventpp::EventQueue<int, void (int), Policies>;
+	using EQ = eventpp::EventQueue<size_t, void (size_t), Policies>;
 	EQ eventQueue;
 
 	if(listenerCount == 0) {
 		listenerCount = eventCount;
 	}
 
 	for(size_t i = 0; i < listenerCount; ++i) {
-		eventQueue.appendListener(i % eventCount, [](int) {});
+		eventQueue.appendListener(i % eventCount, [](size_t) {});
 	}
 
 	const uint64_t time = measureElapsedTime([
@@ -171,15 +171,15 @@ void doMultiThreadingExecuteEventQueue(
 		size_t listenerCount = 0
 	)
 {
-	using EQ = eventpp::EventQueue<int, void (int), Policies>;
+	using EQ = eventpp::EventQueue<size_t, void (size_t), Policies>;
 	EQ eventQueue;
 
 	if(listenerCount == 0) {
 		listenerCount = eventCount;
 	}
 
 	for(size_t i = 0; i < listenerCount; ++i) {
-		eventQueue.appendListener(i % eventCount, [](int) { });
+		eventQueue.appendListener(i % eventCount, [](size_t) { });
 	}
 
 	std::atomic<bool> start(false);
@@ -194,7 +194,7 @@ void doMultiThreadingExecuteEventQueue(
 			}
 
 			for(size_t i = begin; i < end; ++i) {
-					eventQueue.enqueue(i % eventCount);
+				eventQueue.enqueue(i % eventCount);
 			}
 		});
 	}
@@ -611,5 +611,31 @@ TEST_CASE("benchmark, EventQueue")
 	doMultiThreadingExecuteEventQueue<PoliciesMultiThreading>(2, 2, 1000 * 1000 * 100, 100);
 }
 
+TEST_CASE("benchmark, CallbackList add/remove callbacks")
+{
+	using CL = eventpp::CallbackList<void ()>;
+	constexpr size_t callbackCount = 1000;
+	constexpr size_t iterateCount = 1000 * 100;
+	CL callbackList;
+	std::vector<CL::Handle> handleList(callbackCount);
+	const uint64_t time = measureElapsedTime(
+		[callbackCount, iterateCount, &callbackList, &handleList]() {
+		for(size_t iterate = 0; iterate < iterateCount; ++iterate) {
+			for(size_t i = 0; i < callbackCount; ++i) {
+				handleList[i] = callbackList.append([]() {});
+			}
+			for(size_t i = 0; i < callbackCount; ++i) {
+				callbackList.remove(handleList[i]);
+			}
+		}
+	});
+
+	std::cout
+		<< "CallbackList add/remove callbacks,"
+		<< " callbackCount: " << callbackCount
+		<< " iterateCount: " << iterateCount
+		<< " time: " << time
+		<< std::endl;
+}
 
 #endif