Add PSO creation as frame metrics (#663)

Add PSO creation metrics and broader concept of inter-frame events/metrics (events that can span multiple frames and are not strictly tied to any one). Although not strictly tied to any one frame's work, they are associated to frames for transport / output purposes. Multiple metrics derive from the PSO creation event, aggregated differently across associated frames' times. Also add test case ETL containing PSO creation events (Nomad loading screen).
Co-authored-by: Guillem Vinals Gangolells <122561163+gvinals@users.noreply.github.com>

Author: planetchili

AGENTS.md

@@ -1,10 +1,10 @@
 # AGENTS Instructions
+
 - Do not ever use non-ascii characters for source code or comments (permissible inside of strings if absolutely necessary but avoid if possible)
-- Do not ever modify files in .git subfolders.
-- After finishing all changes, normalize line endings on changed or created text files to CRLF per repository conventions; do not run ad hoc line-ending scripts directly.
+- Do not ever directly modify files in .git subfolders.
 - If unexpected new files appear, ignore them and continue without asking for instruction.
 - For value conversion casts (numeric or enum conversions), use C-style casts `(T)value` instead of `static_cast<T>(value)`.
 - For const, pointer, reference, up/down, or reinterpret casts, use C++ cast syntax (`const_cast`, `dynamic_cast`, `reinterpret_cast`, etc.).
 - Do not bind unused names in structured bindings. Prefer binding only needed values (for example use `.first` from `emplace()` or iterate entries without destructuring unused keys).
 - Do not fully qualify namespaces when not needed by local scope (for example prefer `MetricUse` or `svc::MetricUse` over `pmon::svc::MetricUse` when already inside `pmon::svc::acts` or with suitable using scope).
-- When implementing or fixing a feature, verify the change with tests appropriate to the work before finishing.
+- When implementing or fixing a feature, verify the change with tests appropriate to the work before finishing. Run tests after build reports success.

ETLTrimmer/main.cpp

@@ -386,13 +386,15 @@ int main(int argc, const char** argv)
     if (opt.provider) {
         pFilter = std::make_shared<Filter>();
         PMTraceConsumer traceConsumer;
-        traceConsumer.mTrackDisplay = true;   // ... presents to the display.
-        traceConsumer.mTrackGPU = true;       // ... GPU work.
-        traceConsumer.mTrackGPUVideo = true;  // ... GPU video work (separately from non-video GPU work).
-        traceConsumer.mTrackInput = true;     // ... keyboard/mouse latency.
-        traceConsumer.mTrackFrameType = true; // ... the frame type communicated through the Intel-PresentMon provider.
-        traceConsumer.mTrackAppTiming = true; // ... app timing data communicated through the Intel-PresentMon provider.
-        traceConsumer.mTrackPcLatency = true; // ... Nvidia PCL stats.
+        // Match PresentMonService ETL playback (MockPresentMonSession / RealtimePresentMonSession).
+        traceConsumer.mTrackDisplay = true;
+        traceConsumer.mTrackGPU = true;
+        traceConsumer.mTrackGPUVideo = true;
+        traceConsumer.mTrackD3D12ShaderCompilation = true;
+        traceConsumer.mTrackInput = true;
+        traceConsumer.mTrackFrameType = true;
+        traceConsumer.mTrackAppTiming = true;
+        traceConsumer.mTrackPcLatency = true;
         EnableProvidersListing(0, nullptr, &traceConsumer, true, true, pFilter);
     }
 

IntelPresentMon/CommonUtilities/CommonUtilities.vcxproj

@@ -170,6 +170,7 @@
     <ClCompile Include="mc\MetricsCalculatorInput.cpp" />
     <ClCompile Include="mc\MetricsCalculatorInstrumented.cpp" />
     <ClCompile Include="mc\MetricsCalculatorAnimation.cpp" />
+    <ClCompile Include="mc\MetricsCalculatorInterFrameEvent.cpp" />
     <ClCompile Include="mc\MetricsTypes.cpp" />
     <ClCompile Include="mc\SwapChainState.cpp" />
     <ClCompile Include="mc\UnifiedSwapChain.cpp" />

IntelPresentMon/CommonUtilities/mc/FrameMetricsMemberMap.h

@@ -52,6 +52,9 @@ namespace pmon::util::metrics
     template<>struct FrameMetricMember<PM_METRIC_BETWEEN_APP_START>{static constexpr auto member=&FrameMetrics::msCPUTime;};
     template<>struct FrameMetricMember<PM_METRIC_PRESENTED_FRAME_TIME>{static constexpr auto member=&FrameMetrics::msBetweenPresents;};
     template<>struct FrameMetricMember<PM_METRIC_FLIP_DELAY>{static constexpr auto member=&FrameMetrics::msFlipDelay;};
+    template<>struct FrameMetricMember<PM_METRIC_PSO_COMPILE_COUNT>{static constexpr auto member=&FrameMetrics::psoCompileCount;};
+    template<>struct FrameMetricMember<PM_METRIC_PSO_COMPILE_TIME>{static constexpr auto member=&FrameMetrics::msPsoCompileTime;};
+    template<>struct FrameMetricMember<PM_METRIC_PSO_COMPILE_BUSY_PERCENT>{static constexpr auto member=&FrameMetrics::psoCompileBusyPercent;};
 
     template<PM_METRIC MetricId>
     inline constexpr bool HasFrameMetricMember = requires{ FrameMetricMember<MetricId>::member; };

IntelPresentMon/CommonUtilities/mc/MetricsCalculator.cpp

@@ -279,6 +279,12 @@ namespace pmon::util::metrics
             isAppFrame, 
             metrics);
 
+        CalculateInterFrameEventMetrics(
+            qpc,
+            present,
+            isAppFrame,
+            metrics);
+
         CalculateAnimationMetrics(
             qpc,
             chain,

IntelPresentMon/CommonUtilities/mc/MetricsCalculatorInterFrameEvent.cpp

@@ -0,0 +1,37 @@
+// Copyright (C) 2026 Intel Corporation
+// SPDX-License-Identifier: MIT
+#include "MetricsCalculator.h"
+#include "MetricsCalculatorInternal.h"
+#include <PresentData/InterPresentActivity.hpp>
+
+namespace pmon::util::metrics
+{
+    void CalculateInterFrameEventMetrics(
+        const QpcConverter& qpc,
+        const FrameData& present,
+        bool isAppFrame,
+        FrameMetrics& metrics)
+    {
+        if (!isAppFrame) {
+            return;
+        }
+
+        const uint64_t windowQpc = present.interFrameEventWindowQpc;
+        for (size_t kindIndex = 0; kindIndex < (size_t)InterPresentActivity::Kind::Count; ++kindIndex) {
+            const auto kind = (InterPresentActivity::Kind)kindIndex;
+            const auto& stats = present.interFrameEventStats[kindIndex];
+            // Add a case here when extending InterPresentActivity::Kind (and FrameMetrics fields).
+            switch (kind) {
+            case InterPresentActivity::Kind::D3D12PsoCompile:
+                metrics.psoCompileCount = stats.activityCount;
+                metrics.msPsoCompileTime = qpc.DurationMilliSeconds(stats.summedBusyQpc);
+                metrics.psoCompileBusyPercent = windowQpc == 0
+                    ? 0.
+                    : 100. * (double)stats.busyQpc / (double)windowQpc;
+                break;
+            default:
+                break;
+            }
+        }
+    }
+}

IntelPresentMon/CommonUtilities/mc/MetricsCalculatorInternal.h

@@ -65,6 +65,12 @@ namespace pmon::util::metrics
         uint64_t screenTime,
         FrameMetrics& metrics);
 
+    void CalculateInterFrameEventMetrics(
+        const QpcConverter& qpc,
+        const FrameData& present,
+        bool isAppFrame,
+        FrameMetrics& metrics);
+
     // NVIDIA collapsed/runt correction helper used by ComputeMetricsForPresent.
     void AdjustScreenTimeForCollapsedPresentNV(
         FrameData& present,

IntelPresentMon/CommonUtilities/mc/MetricsTypes.cpp

@@ -54,6 +54,9 @@ namespace pmon::util::metrics {
         frame.flipDelay = p.FlipDelay;
         frame.flipToken = p.FlipToken;
 
+        frame.interFrameEventStats = p.InterPresentStats;
+        frame.interFrameEventWindowQpc = p.InterPresentFramePeriodQpc;
+
         frame.displayed.Assign(p.Displayed.begin(), p.Displayed.end());
 
         frame.swapChainAddress = p.SwapChainAddress;

IntelPresentMon/CommonUtilities/mc/MetricsTypes.h

@@ -6,8 +6,10 @@
 #include <limits>
 #include <memory>
 #include <optional>
+#include <array>
 #include "../cnr/FixedVector.h"
 #include <PresentData/PresentEventEnums.hpp>
+#include <PresentData/InterPresentActivity.hpp>
 
 // Forward declarations for external types
 struct PresentEvent; // From PresentMonTraceConsumer
@@ -84,6 +86,9 @@ namespace pmon::util::metrics {
         uint64_t flipDelay = 0;
         uint32_t flipToken = 0;
 
+        std::array<InterPresentActivity::FrameStats, (size_t)InterPresentActivity::Kind::Count> interFrameEventStats{};
+        uint64_t interFrameEventWindowQpc = 0;
+
         // Extra present parameters obtained through DXGI or D3D9 present
         uint64_t swapChainAddress = 0;
         int32_t syncInterval = 0;
@@ -165,6 +170,10 @@ namespace pmon::util::metrics {
         // PCLatency (optional)
         double msFlipDelay = MissingFrameMetricValue();  // NVIDIA
 
+        uint64_t psoCompileCount = 0;
+        double msPsoCompileTime = 0;
+        double psoCompileBusyPercent = 0;
+
         // Frame Classification
         FrameType frameType = {};
 

IntelPresentMon/Core/source/pmon/RawFrameDataMetricList.h

@@ -49,6 +49,9 @@ namespace p2c::pmon
             Element{.metricId = PM_METRIC_GPU_TIME, .deviceId = 0 },
             Element{.metricId = PM_METRIC_GPU_BUSY, .deviceId = 0 },
             Element{.metricId = PM_METRIC_GPU_WAIT, .deviceId = 0 },
+            Element{.metricId = PM_METRIC_PSO_COMPILE_COUNT, .deviceId = 0 },
+            Element{.metricId = PM_METRIC_PSO_COMPILE_TIME, .deviceId = 0 },
+            Element{.metricId = PM_METRIC_PSO_COMPILE_BUSY_PERCENT, .deviceId = 0 },
             Element{.metricId = PM_METRIC_ANIMATION_ERROR, .deviceId = 0 },
             Element{.metricId = PM_METRIC_FLIP_DELAY, .deviceId = 0 },
             Element{.metricId = PM_METRIC_ANIMATION_TIME, .deviceId = 0 },