phase 2 progress

apps/LoopThroughWithOpenGLCompositing/runtime/events/RuntimeEventDispatcher.h

@@ -1,7 +1,9 @@
 #pragma once
 
+#include "RuntimeEventCoalescingQueue.h"
 #include "RuntimeEventQueue.h"
 
+#include <algorithm>
 #include <atomic>
 #include <functional>
 #include <map>
@@ -22,7 +24,8 @@ public:
 	using Handler = std::function<void(const RuntimeEvent&)>;
 
 	explicit RuntimeEventDispatcher(std::size_t queueCapacity = 1024) :
-		mQueue(queueCapacity)
+		mQueue(queueCapacity),
+		mCoalescingQueue(queueCapacity)
 	{
 	}
 
@@ -34,6 +37,9 @@ public:
 		if (event.sequence == 0)
 			event.sequence = mNextSequence.fetch_add(1);
 
+		if (ShouldCoalesce(event))
+			return mCoalescingQueue.Push(std::move(event));
+
 		return mQueue.Push(std::move(event));
 	}
 
@@ -59,6 +65,7 @@ public:
 	{
 		const auto startedAt = std::chrono::steady_clock::now();
 		RuntimeEventDispatchResult result;
+		FlushCoalescedToFifo(maxEvents);
 		std::vector<RuntimeEvent> events = mQueue.Drain(maxEvents);
 		result.dispatchedEvents = events.size();
 
@@ -92,15 +99,56 @@ public:
 
 	RuntimeEventQueueMetrics GetQueueMetrics(std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now()) const
 	{
-		return mQueue.GetMetrics(now);
+		RuntimeEventQueueMetrics metrics = mQueue.GetMetrics(now);
+		const RuntimeEventCoalescingQueueMetrics coalescingMetrics = mCoalescingQueue.GetMetrics(now);
+		if (metrics.depth == 0)
+			metrics.oldestEventAgeMilliseconds = coalescingMetrics.oldestEventAgeMilliseconds;
+		else if (coalescingMetrics.depth > 0)
+			metrics.oldestEventAgeMilliseconds = (std::max)(metrics.oldestEventAgeMilliseconds, coalescingMetrics.oldestEventAgeMilliseconds);
+		metrics.depth += coalescingMetrics.depth;
+		metrics.capacity += coalescingMetrics.capacity;
+		metrics.droppedCount += coalescingMetrics.droppedCount;
+		metrics.coalescedCount = coalescingMetrics.coalescedCount;
+		return metrics;
 	}
 
 	std::size_t QueueDepth() const
 	{
-		return mQueue.Depth();
+		return mQueue.Depth() + mCoalescingQueue.Depth();
 	}
 
 private:
+	static bool ShouldCoalesce(const RuntimeEvent& event)
+	{
+		switch (event.type)
+		{
+		case RuntimeEventType::OscValueReceived:
+		case RuntimeEventType::OscCommitRequested:
+		case RuntimeEventType::RuntimeStateBroadcastRequested:
+		case RuntimeEventType::FileChangeDetected:
+		case RuntimeEventType::RuntimeReloadRequested:
+		case RuntimeEventType::ShaderBuildRequested:
+		case RuntimeEventType::RenderSnapshotPublishRequested:
+		case RuntimeEventType::TimingSampleRecorded:
+		case RuntimeEventType::QueueDepthChanged:
+			return true;
+		default:
+			return false;
+		}
+	}
+
+	void FlushCoalescedToFifo(std::size_t maxEvents)
+	{
+		const std::size_t fifoDepth = mQueue.Depth();
+		if (maxEvents != 0 && fifoDepth >= maxEvents)
+			return;
+
+		const std::size_t flushLimit = maxEvents == 0 ? 0 : maxEvents - fifoDepth;
+		std::vector<RuntimeEvent> events = mCoalescingQueue.Drain(flushLimit);
+		for (RuntimeEvent& event : events)
+			mQueue.Push(std::move(event));
+	}
+
 	std::vector<Handler> HandlersFor(RuntimeEventType type) const
 	{
 		std::lock_guard<std::mutex> lock(mHandlerMutex);
@@ -114,6 +162,7 @@ private:
 	}
 
 	RuntimeEventQueue mQueue;
+	RuntimeEventCoalescingQueue mCoalescingQueue;
 	std::atomic<uint64_t> mNextSequence{ 1 };
 	mutable std::mutex mHandlerMutex;
 	std::map<RuntimeEventType, std::vector<Handler>> mHandlers;