Tests

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.cpp

@@ -38,7 +38,7 @@ OpenGLComposite::OpenGLComposite(HWND hWnd, HDC hDC, HGLRC hRC) :
 	InitializeCriticalSection(&pMutex);
 	mRuntimeStore = std::make_unique<RuntimeStore>();
 	mRuntimeEventDispatcher = std::make_unique<RuntimeEventDispatcher>();
-	mRuntimeSnapshotProvider = std::make_unique<RuntimeSnapshotProvider>(mRuntimeStore->GetRenderSnapshotBuilder());
+	mRuntimeSnapshotProvider = std::make_unique<RuntimeSnapshotProvider>(mRuntimeStore->GetRenderSnapshotBuilder(), *mRuntimeEventDispatcher);
 	mRuntimeCoordinator = std::make_unique<RuntimeCoordinator>(*mRuntimeStore, *mRuntimeEventDispatcher);
 	mRenderEngine = std::make_unique<RenderEngine>(
 		*mRuntimeSnapshotProvider,
@@ -49,7 +49,7 @@ OpenGLComposite::OpenGLComposite(HWND hWnd, HDC hDC, HGLRC hRC) :
 		[this]() { renderEffect(); },
 		[this]() { ProcessScreenshotRequest(); },
 		[this]() { paintGL(false); });
-	mVideoBackend = std::make_unique<VideoBackend>(*mRenderEngine, mRuntimeStore->GetHealthTelemetry());
+	mVideoBackend = std::make_unique<VideoBackend>(*mRenderEngine, mRuntimeStore->GetHealthTelemetry(), *mRuntimeEventDispatcher);
 	mShaderBuildQueue = std::make_unique<ShaderBuildQueue>(*mRuntimeSnapshotProvider, *mRuntimeEventDispatcher);
 	mRuntimeServices = std::make_unique<RuntimeServices>(*mRuntimeEventDispatcher);
 	mRuntimeUpdateController = std::make_unique<RuntimeUpdateController>(
@@ -300,7 +300,7 @@ bool OpenGLComposite::RequestScreenshot(std::string& error)
 
 void OpenGLComposite::renderEffect()
 {
-	if (mRuntimeUpdateController)
+	if (mRuntimeUpdateController && ProcessRuntimeServiceResults())
 		mRuntimeUpdateController->ProcessRuntimeWork();
 	std::vector<RuntimeServices::AppliedOscUpdate> appliedOscUpdates;
 	std::vector<RuntimeServices::CompletedOscCommit> completedOscCommits;
@@ -369,6 +369,25 @@ void OpenGLComposite::renderEffect()
 		historyCap);
 }
 
+bool OpenGLComposite::ProcessRuntimeServiceResults()
+{
+	if (!mRuntimeServices || !mRuntimeUpdateController)
+		return true;
+
+	bool shaderBuildRequested = false;
+	std::vector<RuntimeCoordinatorServiceResult> serviceResults;
+	mRuntimeServices->ConsumeRuntimeCoordinatorResults(serviceResults);
+	for (const RuntimeCoordinatorServiceResult& serviceResult : serviceResults)
+	{
+		shaderBuildRequested = shaderBuildRequested || serviceResult.result.shaderBuildRequested;
+		mRuntimeUpdateController->ApplyRuntimeCoordinatorResult(serviceResult.result);
+		if (serviceResult.failed)
+			return false;
+	}
+
+	return !shaderBuildRequested;
+}
+
 void OpenGLComposite::ProcessScreenshotRequest()
 {
 	if (!mScreenshotRequested.exchange(false))

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.h

@@ -87,6 +87,7 @@ private:
 
 	bool InitOpenGLState();
 	void renderEffect();
+	bool ProcessRuntimeServiceResults();
 	void ProcessScreenshotRequest();
 	std::filesystem::path BuildScreenshotPath() const;
 };

apps/LoopThroughWithOpenGLCompositing/gl/RuntimeUpdateController.cpp

@@ -8,7 +8,6 @@
 #include "VideoBackend.h"
 
 #include <variant>
-#include <vector>
 
 namespace
 {
@@ -107,20 +106,6 @@ bool RuntimeUpdateController::ApplyRuntimeCoordinatorResult(const RuntimeCoordin
 
 bool RuntimeUpdateController::ProcessRuntimeWork()
 {
-	bool shaderBuildRequested = false;
-	std::vector<RuntimeCoordinatorServiceResult> serviceResults;
-	mRuntimeServices.ConsumeRuntimeCoordinatorResults(serviceResults);
-	for (const RuntimeCoordinatorServiceResult& serviceResult : serviceResults)
-	{
-		shaderBuildRequested = shaderBuildRequested || serviceResult.result.shaderBuildRequested;
-		ApplyRuntimeCoordinatorResult(serviceResult.result);
-		if (serviceResult.failed)
-			return false;
-	}
-
-	if (shaderBuildRequested)
-		return true;
-
 	DispatchRuntimeEvents();
 
 	return ConsumeReadyShaderBuild(0, true, true);
@@ -324,5 +309,33 @@ RuntimeEventDispatchResult RuntimeUpdateController::DispatchRuntimeEvents(std::s
 		queueMetrics.capacity,
 		static_cast<uint64_t>(queueMetrics.droppedCount),
 		queueMetrics.oldestEventAgeMilliseconds);
+	PublishRuntimeEventHealthObservations(result);
 	return result;
 }
+
+void RuntimeUpdateController::PublishRuntimeEventHealthObservations(const RuntimeEventDispatchResult& result)
+{
+	const RuntimeEventQueueMetrics queueMetrics = mRuntimeEventDispatcher.GetQueueMetrics();
+	if (queueMetrics.depth != mLastReportedRuntimeEventQueueDepth ||
+		queueMetrics.droppedCount != mLastReportedRuntimeEventDroppedCount)
+	{
+		QueueDepthChangedEvent queueDepth;
+		queueDepth.queueName = "runtime-events";
+		queueDepth.depth = queueMetrics.depth;
+		queueDepth.capacity = queueMetrics.capacity;
+		queueDepth.droppedCount = queueMetrics.droppedCount;
+		mRuntimeEventDispatcher.PublishPayload(queueDepth, "HealthTelemetry");
+		mLastReportedRuntimeEventQueueDepth = queueMetrics.depth;
+		mLastReportedRuntimeEventDroppedCount = queueMetrics.droppedCount;
+	}
+
+	if (result.handlerInvocations == 0 && result.handlerFailures == 0)
+		return;
+
+	TimingSampleRecordedEvent timing;
+	timing.subsystem = "RuntimeEventDispatcher";
+	timing.metric = "dispatchDuration";
+	timing.value = result.dispatchDurationMilliseconds;
+	timing.unit = "ms";
+	mRuntimeEventDispatcher.PublishPayload(timing, "HealthTelemetry");
+}

apps/LoopThroughWithOpenGLCompositing/gl/RuntimeUpdateController.h

@@ -50,6 +50,7 @@ private:
 		const std::string& message);
 	bool ShouldSuppressCoordinatorFollowUp(const RuntimeEvent& event, std::size_t& pendingSuppressions);
 	RuntimeEventDispatchResult DispatchRuntimeEvents(std::size_t maxEvents = 0);
+	void PublishRuntimeEventHealthObservations(const RuntimeEventDispatchResult& result);
 
 	RuntimeStore& mRuntimeStore;
 	RuntimeCoordinator& mRuntimeCoordinator;
@@ -61,4 +62,6 @@ private:
 	std::size_t mPendingCoordinatorShaderBuildEvents = 0;
 	std::size_t mPendingCoordinatorCompileStatusEvents = 0;
 	std::size_t mPendingCoordinatorRenderResetEvents = 0;
+	std::size_t mLastReportedRuntimeEventQueueDepth = static_cast<std::size_t>(-1);
+	std::size_t mLastReportedRuntimeEventDroppedCount = static_cast<std::size_t>(-1);
 };