Pdh.cs

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;

namespace CoreTempGPU
{
    /// <summary>PDH (Performance Data Helper) GPU counters — the universal Windows source.</summary>
    internal static class Pdh
    {
        private const int ERROR_SUCCESS = 0;
        private const uint PDH_FMT_DOUBLE = 0x00000200;
        private const uint PDH_FMT_NOCAP100 = 0x00008000;

        [DllImport("pdh.dll", CharSet = CharSet.Unicode)]
        private static extern int PdhOpenQueryW(IntPtr dataSource, IntPtr userData, out IntPtr query);

        [DllImport("pdh.dll", CharSet = CharSet.Unicode)]
        private static extern int PdhCloseQuery(IntPtr query);

        [DllImport("pdh.dll", CharSet = CharSet.Unicode)]
        private static extern int PdhAddEnglishCounterW(IntPtr query, string counterPath, IntPtr userData, out IntPtr counter);

        [DllImport("pdh.dll", CharSet = CharSet.Unicode)]
        private static extern int PdhRemoveCounter(IntPtr counter);

        [DllImport("pdh.dll", CharSet = CharSet.Unicode)]
        private static extern int PdhCollectQueryData(IntPtr query);

        [DllImport("pdh.dll", CharSet = CharSet.Unicode)]
        private static extern int PdhGetFormattedCounterValue(IntPtr counter, uint format, out uint type, out CounterValue value);

        [StructLayout(LayoutKind.Sequential)]
        private struct CounterValue
        {
            public int CStatus;
            public double data;
        }

        /// <summary>One live PDH counter bound to a query.</summary>
        public sealed class Counter : IDisposable
        {
            private readonly IntPtr _query;
            private IntPtr _handle;
            public readonly string Path;

            public bool Valid { get; private set; }

            public Counter(IntPtr query, string path)
            {
                _query = query;
                Path = path;
            }

            public bool Add()
            {
                int rc = PdhAddEnglishCounterW(_query, Path, IntPtr.Zero, out _handle);
                Valid = (rc == ERROR_SUCCESS);
                return Valid;
            }

            /// <summary>Read the current value. Returns false when no data is available.</summary>
            public bool TryRead(out double value)
            {
                value = 0;
                if (!Valid) return false;
                CounterValue v;
                uint type;
                int rc = PdhGetFormattedCounterValue(_handle, PDH_FMT_DOUBLE | PDH_FMT_NOCAP100, out type, out v);
                if (rc != ERROR_SUCCESS || v.CStatus != ERROR_SUCCESS) return false;
                value = v.data;
                return true;
            }

            public void Dispose()
            {
                if (_handle != IntPtr.Zero) PdhRemoveCounter(_handle);
                _handle = IntPtr.Zero;
            }
        }

        /// <summary>Starts a query and registers the given counters. Disposal closes the query.</summary>
        public static QueryHandle OpenQuery(IEnumerable<string> paths)
        {
            IntPtr q;
            if (PdhOpenQueryW(IntPtr.Zero, IntPtr.Zero, out q) != ERROR_SUCCESS) return null;
            try
            {
                var query = new QueryHandle(q);
                foreach (var p in paths) query.Add(p);
                return query;
            }
            catch
            {
                PdhCloseQuery(q);
                throw;
            }
        }

        public sealed class QueryHandle : IDisposable
        {
            private IntPtr _query;
            public readonly List<Counter> Counters = new List<Counter>();

            public QueryHandle(IntPtr query) { _query = query; }

            public Counter Add(string path)
            {
                var c = new Counter(_query, path);
                c.Add();
                Counters.Add(c);
                return c;
            }

            /// <summary>Collect once. Call twice with a gap between for rate counters to yield data.</summary>
            public void Collect()
            {
                if (_query != IntPtr.Zero) PdhCollectQueryData(_query);
            }

            public void Dispose()
            {
                foreach (var c in Counters) c.Dispose();
                Counters.Clear();
                if (_query != IntPtr.Zero) PdhCloseQuery(_query);
                _query = IntPtr.Zero;
            }
        }

        /// <summary>
        /// DXGI adapter enumeration is intentionally omitted — incomplete COM vtables
        /// crash the Core Temp host process. Adapter names come from NVML when available.
        /// </summary>
        public static long GetPrimaryDisplayLuid()
        {
            return 0;
        }

        public static List<Tuple<long, string>> EnumerateAdapters()
        {
            return new List<Tuple<long, string>>();
        }
    }
}