Merge pull request #326 from GameTechDev/bug/flush-before-capture

flush stale frames that pile up before starting new capture

Author: markgalvan-intel

IntelPresentMon/Core/source/pmon/PresentMon.cpp

@@ -10,6 +10,27 @@
 
 namespace p2c::pmon
 {
+	using namespace ::pmapi;
+
+	class FrameEventFlusher
+	{
+	public:
+		FrameEventFlusher(Session& sesh)
+		{
+			// register minimal query used for flushing frame events
+			std::array queryElements{ PM_QUERY_ELEMENT{ PM_METRIC_PRESENT_MODE, PM_STAT_MID_POINT } };
+			query_ = sesh.RegisterFrameQuery(queryElements);
+			blobs_ = query_.MakeBlobContainer(50);
+		}
+		void Flush(ProcessTracker& tracker)
+		{
+			query_.ForEachConsume(tracker, blobs_, [](auto) {});
+		}
+	private:
+		FrameQuery query_;
+		BlobContainer blobs_;
+	};
+
 	PresentMon::PresentMon(std::optional<std::string> namedPipeName, std::optional<std::string> sharedMemoryName, double window_in, double offset_in, uint32_t telemetrySamplePeriodMs_in)
 	{
 		const auto RemoveDoubleQuotes = [](std::string s) {
@@ -39,6 +60,9 @@ namespace p2c::pmon
 		SetWindow(window_in);
 		SetOffset(offset_in);
 		SetGpuTelemetryPeriod(telemetrySamplePeriodMs_in);
+
+		// create flusher used to clear out piled-up old frame events before capture
+		pFlusher = std::make_unique<FrameEventFlusher>(*pSession);
 	}
 	PresentMon::~PresentMon() = default;
 	void PresentMon::StartTracking(uint32_t pid_)
@@ -126,6 +150,10 @@ namespace p2c::pmon
 	std::shared_ptr<RawFrameDataWriter> PresentMon::MakeRawFrameDataWriter(std::wstring path,
 		std::optional<std::wstring> statsPath, uint32_t pid, std::wstring procName)
 	{
+		// flush any buffered present events before starting capture
+		pFlusher->Flush(processTracker);
+
+		// make the frame data writer
 		return std::make_shared<RawFrameDataWriter>(std::move(path), processTracker, std::move(procName),
 			selectedAdapter.value_or(1), *pSession, std::move(statsPath), *pIntrospectionRoot);
 	}

IntelPresentMon/Core/source/pmon/PresentMon.h

@@ -19,6 +19,7 @@ namespace pmapi
 namespace p2c::pmon
 {
 	class RawFrameDataWriter;
+	class FrameEventFlusher;
 
 	class PresentMon
 	{
@@ -49,6 +50,7 @@ namespace p2c::pmon
 		double offset = -1.;
 		uint32_t telemetrySamplePeriod = 0;
 		std::unique_ptr<pmapi::Session> pSession;
+		std::unique_ptr<FrameEventFlusher> pFlusher;
 		std::shared_ptr<pmapi::intro::Root> pIntrospectionRoot;
 		pmapi::ProcessTracker processTracker;
 		std::optional<uint32_t> selectedAdapter;

IntelPresentMon/PresentMonAPIWrapper/FrameQuery.cpp

@@ -46,6 +46,20 @@ namespace pmapi
         Consume(tracker, blobs.GetFirst(), blobs.AcquireNumBlobsInRef_());
     }
 
+    size_t FrameQuery::ForEachConsume(ProcessTracker& tracker, BlobContainer& blobs, std::function<void(const uint8_t*)> frameHandler)
+    {
+        size_t nFramesProcessed = 0;
+        do {
+            Consume(tracker, blobs);
+            const auto nPopulated = blobs.GetNumBlobsPopulated();
+            for (uint32_t i = 0; i < nPopulated; i++) {
+                frameHandler(blobs[i]);
+            }
+            nFramesProcessed += nPopulated;
+        } while (blobs.AllBlobsPopulated());
+        return nFramesProcessed;
+    }
+
     BlobContainer FrameQuery::MakeBlobContainer(uint32_t nBlobs) const
     {
         assert(!Empty());

IntelPresentMon/PresentMonAPIWrapper/FrameQuery.h

@@ -3,6 +3,7 @@
 #include "BlobContainer.h"
 #include "ProcessTracker.h"
 #include <span>
+#include <functional>
 
 namespace pmapi
 {
@@ -31,6 +32,9 @@ namespace pmapi
         // pBlobs: pointer to memory where frame query data is to be stored for consumed frames
         // NOTE: it is preferred to use above version of this function that takes in BlobContainer&
         void Consume(const ProcessTracker& tracker, uint8_t* pBlobs, uint32_t& numBlobsInOut);
+        // consume frame events and invoke frameHandler for each frame consumed, setting active blob each time
+        // will continue to call consume until all frames have been consumed from the queue
+        size_t ForEachConsume(ProcessTracker& tracker, BlobContainer& blobs, std::function<void(const uint8_t*)> frameHandler);
         // create a blob container whose size is suited to fit this query
         // nBlobs: number of frames worth of data that the container can contain
         BlobContainer MakeBlobContainer(uint32_t nBlobs) const;