Esempio n. 1
0
        public override float NextValue()
        {
            // Update GPU processor load
            NvPStates states = new NvPStates
            {
                Version = NVAPI.GPU_PSTATES_VER,
                PStates = new NvPState[NVAPI.MAX_PSTATES_PER_GPU]
            };

            if (NVAPI.NvAPI_GPU_GetPStates != null && NVAPI.NvAPI_GPU_GetPStates(gpuHandle, ref states) == NvStatus.OK)
            {
                if (states.PStates[0].Present)
                {
                    return(states.PStates[2].Percentage);
                }
            }
            else
            {
                NvUsages usages = new NvUsages
                {
                    Version = NVAPI.GPU_USAGES_VER,
                    Usage   = new uint[NVAPI.MAX_USAGES_PER_GPU]
                };

                if (NVAPI.NvAPI_GPU_GetUsages != null && NVAPI.NvAPI_GPU_GetUsages(gpuHandle, ref usages) == NvStatus.OK)
                {
                    return(usages.Usage[10]);
                }
            }

            return(0);
        }
Esempio n. 2
0
 private void UpdatePerformaneStates()
 {
     _performanceStates         = new NvPStates();
     _performanceStates.Version = NVAPI.GPU_PSTATES_VER;
     _performanceStates.PStates = new NvPState[NVAPI.MAX_PSTATES_PER_GPU];
     NVAPI.NvAPI_GPU_GetPStates(_handle, ref _performanceStates);
 }
Esempio n. 3
0
        public NvPStates?ObtainPStates()
        {
            var states = new NvPStates {
                Version = NvApi.GpuPstatesVer,
                PStates = new NvPState[NvApi.MaxPstatesPerGpu]
            };

            if (NvApi.GetDynamicPStatesInfoEx == null || NvApi.GetDynamicPStatesInfoEx(Gpu.AdapterHandle, ref states) != NvStatus.Ok)
            {
                return(null);
            }

            return(states);
        }
Esempio n. 4
0
        public override void Update()
        {
            NvGPUThermalSettings settings = GetThermalSettings();
              foreach (Sensor sensor in temperatures)
            sensor.Value = settings.Sensor[sensor.Index].CurrentTemp;

              if (fan != null) {
            int value = 0;
            NVAPI.NvAPI_GPU_GetTachReading(handle, out value);
            fan.Value = value;
              }

              uint[] values = GetClocks();
              if (values != null) {
            clocks[1].Value = 0.001f * values[8];
            if (values[30] != 0) {
              clocks[0].Value = 0.0005f * values[30];
              clocks[2].Value = 0.001f * values[30];
            } else {
              clocks[0].Value = 0.001f * values[0];
              clocks[2].Value = 0.001f * values[14];
            }
              }

              NvPStates states = new NvPStates();
              states.Version = NVAPI.GPU_PSTATES_VER;
              states.PStates = new NvPState[NVAPI.MAX_PSTATES_PER_GPU];
              if (NVAPI.NvAPI_GPU_GetPStates != null &&
            NVAPI.NvAPI_GPU_GetPStates(handle, ref states) == NvStatus.OK) {
            for (int i = 0; i < 3; i++)
              if (states.PStates[i].Present) {
            loads[i].Value = states.PStates[i].Percentage;
            ActivateSensor(loads[i]);
              }
              } else {
            NvUsages usages = new NvUsages();
            usages.Version = NVAPI.GPU_USAGES_VER;
            usages.Usage = new uint[NVAPI.MAX_USAGES_PER_GPU];
            if (NVAPI.NvAPI_GPU_GetUsages != null &&
              NVAPI.NvAPI_GPU_GetUsages(handle, ref usages) == NvStatus.OK) {
              loads[0].Value = usages.Usage[2];
              loads[1].Value = usages.Usage[6];
              loads[2].Value = usages.Usage[10];
              for (int i = 0; i < 3; i++)
            ActivateSensor(loads[i]);
            }
              }

              NvGPUCoolerSettings coolerSettings = GetCoolerSettings();
              if (coolerSettings.Count > 0) {
            control.Value = coolerSettings.Cooler[0].CurrentLevel;
            ActivateSensor(control);
              }

              NvMemoryInfo memoryInfo = new NvMemoryInfo();
              memoryInfo.Version = NVAPI.GPU_MEMORY_INFO_VER;
              memoryInfo.Values = new uint[NVAPI.MAX_MEMORY_VALUES_PER_GPU];
              if (NVAPI.NvAPI_GPU_GetMemoryInfo != null && displayHandle.HasValue &&
            NVAPI.NvAPI_GPU_GetMemoryInfo(displayHandle.Value, ref memoryInfo) ==
            NvStatus.OK) {
            uint totalMemory = memoryInfo.Values[0];
            uint freeMemory = memoryInfo.Values[4];
            float usedMemory = Math.Max(totalMemory - freeMemory, 0);
            memoryFree.Value = (float)freeMemory/ 1024;
            memoryAvail.Value = (float)totalMemory/ 1024;
            memoryUsed.Value = usedMemory/ 1024;
            memoryLoad.Value = 100f * usedMemory / totalMemory;
            ActivateSensor(memoryAvail);
            ActivateSensor(memoryUsed);
            ActivateSensor(memoryFree);
            ActivateSensor(memoryLoad);
              }
        }
Esempio n. 5
0
        public void Update()
        {
            uint[] values = GetClocks();
            if (values != null)
            {
                _memoryClock = 0.001f * values[8];
                if (values[30] != 0)
                {
                    _coreClock   = 0.0005f * values[30];
                    _shaderClock = 0.001f * values[30];
                }
                else
                {
                    _coreClock   = 0.001f * values[0];
                    _shaderClock = 0.001f * values[14];
                }
            }

            /*
             * Console.Write("core:" + _coreClock.ToString());
             * Console.Write("mem:" + _memoryClock.ToString());
             * Console.Write("shader:" + _shaderClock.ToString());
             * Console.WriteLine();
             */


            NvMemoryInfo memoryInfo = new NvMemoryInfo();

            memoryInfo.Version = NVAPI.GPU_MEMORY_INFO_VER;
            memoryInfo.Values  = new uint[NVAPI.MAX_MEMORY_VALUES_PER_GPU];
            if (NVAPI.NvAPI_GPU_GetMemoryInfo != null && _displayHandle.HasValue &&
                NVAPI.NvAPI_GPU_GetMemoryInfo(_displayHandle.Value, ref memoryInfo) ==
                NvStatus.OK)
            {
                TotalMem   = memoryInfo.Values[0];
                TotalMemMb = TotalMem / 1024;
                FreeMem    = memoryInfo.Values[4];
                FreeMemMb  = FreeMem / 1024;
                UsedMem    = Math.Max(TotalMem - FreeMem, 0);
                UsedMemMb  = UsedMem / 1024;
                LoadMemPct = 100.0f * UsedMem / TotalMem;
            }


            NvPStates states = new NvPStates();

            states.Version = NVAPI.GPU_PSTATES_VER;
            states.PStates = new NvPState[NVAPI.MAX_PSTATES_PER_GPU];
            if (NVAPI.NvAPI_GPU_GetPStates != null && NVAPI.NvAPI_GPU_GetPStates(_handle, ref states) == NvStatus.OK)
            {
                /*
                 * 0: Core
                 * 1: MemoryController
                 * 2: VideoEngine
                 */
                for (int i = 0; i < 3; i++)
                {
                    if (states.PStates[i].Present)
                    {
                        LoadPct = states.PStates[i].Percentage;
                        break;
                        //Console.WriteLine(states.PStates[i].Percentage);
                    }
                }
            }

            NvGPUThermalSettings thermalSettings = GetThermalSettings();

            for (int i = 0; i < thermalSettings.Count; i++)
            {
                NvSensor sensor = thermalSettings.Sensor[i];
                if (sensor.Target == NvThermalTarget.GPU)
                {
                    Temperature = sensor.CurrentTemp;
                    //Console.WriteLine(temp);
                    break;
                }
            }
        }
Esempio n. 6
-3
        public override string GetReport()
        {
            StringBuilder r = new StringBuilder();

              r.AppendLine("Nvidia GPU");
              r.AppendLine();

              r.AppendFormat("Name: {0}{1}", name, Environment.NewLine);
              r.AppendFormat("Index: {0}{1}", adapterIndex, Environment.NewLine);

              if (displayHandle.HasValue && NVAPI.NvAPI_GetDisplayDriverVersion != null) {
            NvDisplayDriverVersion driverVersion = new NvDisplayDriverVersion();
            driverVersion.Version = NVAPI.DISPLAY_DRIVER_VERSION_VER;
            if (NVAPI.NvAPI_GetDisplayDriverVersion(displayHandle.Value,
              ref driverVersion) == NvStatus.OK) {
              r.Append("Driver Version: ");
              r.Append(driverVersion.DriverVersion / 100);
              r.Append(".");
              r.Append((driverVersion.DriverVersion % 100).ToString("00",
            CultureInfo.InvariantCulture));
              r.AppendLine();
              r.Append("Driver Branch: ");
              r.AppendLine(driverVersion.BuildBranch);
            }
              }
              r.AppendLine();

              if (NVAPI.NvAPI_GPU_GetPCIIdentifiers != null) {
            uint deviceId, subSystemId, revisionId, extDeviceId;

            NvStatus status = NVAPI.NvAPI_GPU_GetPCIIdentifiers(handle,
              out deviceId, out subSystemId, out revisionId, out extDeviceId);

            if (status == NvStatus.OK) {
              r.Append("DeviceID: 0x");
              r.AppendLine(deviceId.ToString("X", CultureInfo.InvariantCulture));
              r.Append("SubSystemID: 0x");
              r.AppendLine(subSystemId.ToString("X", CultureInfo.InvariantCulture));
              r.Append("RevisionID: 0x");
              r.AppendLine(revisionId.ToString("X", CultureInfo.InvariantCulture));
              r.Append("ExtDeviceID: 0x");
              r.AppendLine(extDeviceId.ToString("X", CultureInfo.InvariantCulture));
              r.AppendLine();
            }
              }

              if (NVAPI.NvAPI_GPU_GetThermalSettings != null) {
            NvGPUThermalSettings settings = new NvGPUThermalSettings();
            settings.Version = NVAPI.GPU_THERMAL_SETTINGS_VER;
            settings.Count = NVAPI.MAX_THERMAL_SENSORS_PER_GPU;
            settings.Sensor = new NvSensor[NVAPI.MAX_THERMAL_SENSORS_PER_GPU];

            NvStatus status = NVAPI.NvAPI_GPU_GetThermalSettings(handle,
              (int)NvThermalTarget.ALL, ref settings);

            r.AppendLine("Thermal Settings");
            r.AppendLine();
            if (status == NvStatus.OK) {
              for (int i = 0; i < settings.Count; i++) {
            r.AppendFormat(" Sensor[{0}].Controller: {1}{2}", i,
              settings.Sensor[i].Controller, Environment.NewLine);
            r.AppendFormat(" Sensor[{0}].DefaultMinTemp: {1}{2}", i,
              settings.Sensor[i].DefaultMinTemp, Environment.NewLine);
            r.AppendFormat(" Sensor[{0}].DefaultMaxTemp: {1}{2}", i,
              settings.Sensor[i].DefaultMaxTemp, Environment.NewLine);
            r.AppendFormat(" Sensor[{0}].CurrentTemp: {1}{2}", i,
              settings.Sensor[i].CurrentTemp, Environment.NewLine);
            r.AppendFormat(" Sensor[{0}].Target: {1}{2}", i,
              settings.Sensor[i].Target, Environment.NewLine);
              }
            } else {
              r.Append(" Status: ");
              r.AppendLine(status.ToString());
            }
            r.AppendLine();
              }

              if (NVAPI.NvAPI_GPU_GetAllClocks != null) {
            NvClocks allClocks = new NvClocks();
            allClocks.Version = NVAPI.GPU_CLOCKS_VER;
            allClocks.Clock = new uint[NVAPI.MAX_CLOCKS_PER_GPU];
            NvStatus status = NVAPI.NvAPI_GPU_GetAllClocks(handle, ref allClocks);

            r.AppendLine("Clocks");
            r.AppendLine();
            if (status == NvStatus.OK) {
              for (int i = 0; i < allClocks.Clock.Length; i++)
            if (allClocks.Clock[i] > 0) {
              r.AppendFormat(" Clock[{0}]: {1}{2}", i, allClocks.Clock[i],
                Environment.NewLine);
            }
            } else {
              r.Append(" Status: ");
              r.AppendLine(status.ToString());
            }
            r.AppendLine();
              }

              if (NVAPI.NvAPI_GPU_GetTachReading != null) {
            int tachValue;
            NvStatus status = NVAPI.NvAPI_GPU_GetTachReading(handle, out tachValue);

            r.AppendLine("Tachometer");
            r.AppendLine();
            if (status == NvStatus.OK) {
              r.AppendFormat(" Value: {0}{1}", tachValue, Environment.NewLine);
            } else {
              r.Append(" Status: ");
              r.AppendLine(status.ToString());
            }
            r.AppendLine();
              }

              if (NVAPI.NvAPI_GPU_GetPStates != null) {
            NvPStates states = new NvPStates();
            states.Version = NVAPI.GPU_PSTATES_VER;
            states.PStates = new NvPState[NVAPI.MAX_PSTATES_PER_GPU];
            NvStatus status = NVAPI.NvAPI_GPU_GetPStates(handle, ref states);

            r.AppendLine("P-States");
            r.AppendLine();
            if (status == NvStatus.OK) {
              for (int i = 0; i < states.PStates.Length; i++)
            if (states.PStates[i].Present)
              r.AppendFormat(" Percentage[{0}]: {1}{2}", i,
                states.PStates[i].Percentage, Environment.NewLine);
            } else {
              r.Append(" Status: ");
              r.AppendLine(status.ToString());
            }
            r.AppendLine();
              }

              if (NVAPI.NvAPI_GPU_GetUsages != null) {
            NvUsages usages = new NvUsages();
            usages.Version = NVAPI.GPU_USAGES_VER;
            usages.Usage = new uint[NVAPI.MAX_USAGES_PER_GPU];
            NvStatus status = NVAPI.NvAPI_GPU_GetUsages(handle, ref usages);

            r.AppendLine("Usages");
            r.AppendLine();
            if (status == NvStatus.OK) {
              for (int i = 0; i < usages.Usage.Length; i++)
            if (usages.Usage[i] > 0)
              r.AppendFormat(" Usage[{0}]: {1}{2}", i,
                usages.Usage[i], Environment.NewLine);
            } else {
              r.Append(" Status: ");
              r.AppendLine(status.ToString());
            }
            r.AppendLine();
              }

              if (NVAPI.NvAPI_GPU_GetCoolerSettings != null) {
            NvGPUCoolerSettings settings = new NvGPUCoolerSettings();
            settings.Version = NVAPI.GPU_COOLER_SETTINGS_VER;
            settings.Cooler = new NvCooler[NVAPI.MAX_COOLER_PER_GPU];
            NvStatus status =
              NVAPI.NvAPI_GPU_GetCoolerSettings(handle, 0, ref settings);

            r.AppendLine("Cooler Settings");
            r.AppendLine();
            if (status == NvStatus.OK) {
              for (int i = 0; i < settings.Count; i++) {
            r.AppendFormat(" Cooler[{0}].Type: {1}{2}", i,
              settings.Cooler[i].Type, Environment.NewLine);
            r.AppendFormat(" Cooler[{0}].Controller: {1}{2}", i,
              settings.Cooler[i].Controller, Environment.NewLine);
            r.AppendFormat(" Cooler[{0}].DefaultMin: {1}{2}", i,
              settings.Cooler[i].DefaultMin, Environment.NewLine);
            r.AppendFormat(" Cooler[{0}].DefaultMax: {1}{2}", i,
              settings.Cooler[i].DefaultMax, Environment.NewLine);
            r.AppendFormat(" Cooler[{0}].CurrentMin: {1}{2}", i,
              settings.Cooler[i].CurrentMin, Environment.NewLine);
            r.AppendFormat(" Cooler[{0}].CurrentMax: {1}{2}", i,
              settings.Cooler[i].CurrentMax, Environment.NewLine);
            r.AppendFormat(" Cooler[{0}].CurrentLevel: {1}{2}", i,
              settings.Cooler[i].CurrentLevel, Environment.NewLine);
            r.AppendFormat(" Cooler[{0}].DefaultPolicy: {1}{2}", i,
              settings.Cooler[i].DefaultPolicy, Environment.NewLine);
            r.AppendFormat(" Cooler[{0}].CurrentPolicy: {1}{2}", i,
              settings.Cooler[i].CurrentPolicy, Environment.NewLine);
            r.AppendFormat(" Cooler[{0}].Target: {1}{2}", i,
              settings.Cooler[i].Target, Environment.NewLine);
            r.AppendFormat(" Cooler[{0}].ControlType: {1}{2}", i,
              settings.Cooler[i].ControlType, Environment.NewLine);
            r.AppendFormat(" Cooler[{0}].Active: {1}{2}", i,
              settings.Cooler[i].Active, Environment.NewLine);
              }
            } else {
              r.Append(" Status: ");
              r.AppendLine(status.ToString());
            }
            r.AppendLine();
              }

              if (NVAPI.NvAPI_GPU_GetMemoryInfo != null && displayHandle.HasValue) {
            NvMemoryInfo memoryInfo = new NvMemoryInfo();
            memoryInfo.Version = NVAPI.GPU_MEMORY_INFO_VER;
            memoryInfo.Values = new uint[NVAPI.MAX_MEMORY_VALUES_PER_GPU];
            NvStatus status = NVAPI.NvAPI_GPU_GetMemoryInfo(displayHandle.Value,
              ref memoryInfo);

            r.AppendLine("Memory Info");
            r.AppendLine();
            if (status == NvStatus.OK) {
              for (int i = 0; i < memoryInfo.Values.Length; i++)
            r.AppendFormat(" Value[{0}]: {1}{2}", i,
                memoryInfo.Values[i], Environment.NewLine);
            } else {
              r.Append(" Status: ");
              r.AppendLine(status.ToString());
            }
            r.AppendLine();
              }

              return r.ToString();
        }