Updated the NVIDIA changes to correctly handle using NVML API call. Updated FPS calculations to use frame times when calculating all stats and then converting to FPS at the end. Produces more accurate results. Added an additional application to TargetBlockList.

Author: markgalvan-intel

IntelPresentMon/AppCef/Web/BlockLists/TargetBlockList.txt

@@ -297,6 +297,7 @@ wsl2distromanager.exe
 wudfhost.exe
 wwahost.exe
 xboxgamebarwidgets.exe
+xboxgamebarspotify.exe
 xboxapp.exe
 xboxpcapp.exe
 xdesproc.exe

IntelPresentMon/ControlLib/NvidiaPowerTelemetryAdapter.cpp

@@ -68,8 +68,8 @@ namespace pwr::nv
                 for (const auto& sensor : thermals.sensor)
                 {
                     // TODO: consider prioritizing sensor.controller == NVAPI_THERMAL_CONTROLLER_GPU_INTERNAL when multiple GPU thermals are present
-                    if (sensor.target == NVAPI_THERMAL_TARGET_GPU)
-                    {
+                    if ((sensor.target == NVAPI_THERMAL_TARGET_GPU) &&
+                        (sensor.controller == NVAPI_THERMAL_CONTROLLER_GPU_INTERNAL)) {
                         info.gpu_temperature_c = (double)sensor.currentTemp;
                         SetTelemetryCapBit(GpuTelemetryCapBits::gpu_temperature);
                     }
@@ -175,13 +175,15 @@ namespace pwr::nv
             }
 
             {// temperature
-                if (!GetPowerTelemetryCapBits().test(static_cast<size_t>(GpuTelemetryCapBits::gpu_temperature)))
+                if (!GetPowerTelemetryCapBits().test(static_cast<size_t>(GpuTelemetryCapBits::gpu_temperature))||
+                    (useNvmlTemperature))
                 {
                     unsigned int temp = 0;
                     if (nvml->Ok(nvml->DeviceGetTemperature(*hNvml, nvmlTemperatureSensors_t::NVML_TEMPERATURE_GPU, &temp)))
                     {
                         info.gpu_temperature_c = (double)temp;
                         SetTelemetryCapBit(GpuTelemetryCapBits::gpu_temperature);
+                        useNvmlTemperature = true;
                     }
                     // TODO: consider logging failure (lower logging level perhaps)
                 }

IntelPresentMon/ControlLib/NvidiaPowerTelemetryAdapter.h

@@ -35,5 +35,6 @@ namespace pwr::nv
 		std::string name = "Unknown Adapter Name";
 		mutable std::mutex historyMutex;
 		TelemetryHistory<PresentMonPowerTelemetryInfo> history{ PowerTelemetryAdapter::defaultHistorySize };
+		bool useNvmlTemperature = false;
 	};
 }

IntelPresentMon/PresentMonMiddleware/source/ConcreteMiddleware.cpp

@@ -1043,11 +1043,41 @@ void ReportMetrics(
 
         case PM_METRIC_PRESENTED_FPS:
         {
-            std::vector<double> cpu_fps(swapChain.CPUDuration.size());
+            std::vector<double> frameTimes(swapChain.CPUDuration.size());
             for (size_t i = 0; i < swapChain.CPUDuration.size(); ++i) {
-                cpu_fps[i] = 1000.0 / (swapChain.CPUDuration[i] + swapChain.CPUFramePacingStall[i]);
+                frameTimes[i] = swapChain.CPUDuration[i] + swapChain.CPUFramePacingStall[i];
             }
-            CalculateMetric(output, cpu_fps, element.stat);
+            switch (element.stat)
+            {
+            case PM_STAT_PERCENTILE_99:
+                CalculateMetric(output, frameTimes, PM_STAT_PERCENTILE_01);
+                break;
+            case PM_STAT_PERCENTILE_95:
+                CalculateMetric(output, frameTimes, PM_STAT_PERCENTILE_05);
+                break;
+            case PM_STAT_PERCENTILE_90:
+                CalculateMetric(output, frameTimes, PM_STAT_PERCENTILE_10);
+                break;
+            case PM_STAT_PERCENTILE_10:
+                CalculateMetric(output, frameTimes, PM_STAT_PERCENTILE_90);
+                break;
+            case PM_STAT_PERCENTILE_05:
+                CalculateMetric(output, frameTimes, PM_STAT_PERCENTILE_95);
+                break;
+            case PM_STAT_PERCENTILE_01:
+                CalculateMetric(output, frameTimes, PM_STAT_PERCENTILE_99);
+                break;
+            case PM_STAT_MAX:
+                CalculateMetric(output, frameTimes, PM_STAT_MIN);
+                break;
+            case PM_STAT_MIN:
+                CalculateMetric(output, frameTimes, PM_STAT_MAX);
+                break;
+            default:
+                CalculateMetric(output, frameTimes, element.stat);
+            }
+            // Convert to FPS
+            output = 1000.0 / output;
         }
             break;
         case PM_METRIC_DISPLAYED_FPS: