public OverlayEntryProvider(ISensorService sensorService,
IAppConfiguration appConfiguration,
IEventAggregator eventAggregator,
IOnlineMetricService onlineMetricService,
ISystemInfo systemInfo, IRTSSService rTSSService,
ILogger <OverlayEntryProvider> logger)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
_sensorService = sensorService;
_appConfiguration = appConfiguration;
_eventAggregator = eventAggregator;
_onlineMetricService = onlineMetricService;
_systemInfo = systemInfo;
_rTSSService = rTSSService;
_logger = logger;
_onDictionaryUpdatedBuffered = _sensorService
.OnDictionaryUpdated
.Replay(1)
.AutoConnect(0);
_ = Task.Run(async() => await LoadOrSetDefault())
.ContinueWith(task => _taskCompletionSource.SetResult(true));
SubscribeToOptionPopupClosed();
_logger.LogDebug("{componentName} Ready", this.GetType().Name);
stopwatch.Stop();
_logger.LogInformation(this.GetType().Name + " {initializationTime}s initialization time", Math.Round(stopwatch.ElapsedMilliseconds * 1E-03, 1));
}
#pragma warning disable CS3001 // Argumenttyp ist nicht CLS-kompatibel
public Computer(ISensorConfig config, IRTSSService service)
#pragma warning restore CS3001 // Argumenttyp ist nicht CLS-kompatibel
{
this.settings = new Settings();
sensorConfig = config;
rTSSService = service;
}
public StateViewModel(IRecordDirectoryObserver recordObserver,
IEventAggregator eventAggregator,
IAppConfiguration appConfiguration,
ICaptureService captureService,
IOverlayService overlayService,
IUpdateCheck updateCheck,
IAppVersionProvider appVersionProvider,
IWebVersionProvider webVersionProvider,
LoginManager loginManager,
IRTSSService rTSSService,
ILogger <StateViewModel> logger)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
_recordObserver = recordObserver;
_eventAggregator = eventAggregator;
_appConfiguration = appConfiguration;
_captureService = captureService;
_overlayService = overlayService;
_updateCheck = updateCheck;
_appVersionProvider = appVersionProvider;
_logger = logger;
IsCaptureModeActive = false;
IsOverlayActive = _appConfiguration.IsOverlayActive && rTSSService.IsRTSSInstalled();
_captureService.IsCaptureModeActiveStream
.Subscribe(state => IsCaptureModeActive = state);
_captureService.IsLoggingActiveStream
.Subscribe(state => IsLoggingActive = state);
_overlayService.IsOverlayActiveStream
.Subscribe(state => IsOverlayActive = state);
IsLoggedIn = loginManager.State.Token != null;
_eventAggregator.GetEvent <PubSubEvent <AppMessages.LoginState> >().Subscribe(state =>
{
IsLoggedIn = state.IsLoggedIn;
RaisePropertyChanged(nameof(IsLoggedIn));
});
Task.Run(async() =>
{
var(updateAvailable, updateVersion) = await _updateCheck.IsUpdateAvailable();
Dispatcher.CurrentDispatcher.Invoke(() =>
{
IsUpdateAvailable = updateAvailable;
UpdateHyperlinkText = $"New version available on GitHub: v{updateVersion}";
RaisePropertyChanged(nameof(IsUpdateAvailable));
});
});
stopwatch.Stop();
_logger.LogInformation(this.GetType().Name + " {initializationTime}s initialization time", Math.Round(stopwatch.ElapsedMilliseconds * 1E-03, 1));
}
public RAMGroup(ISettings settings, ISensorConfig sensorConfig, IRTSSService rTSSService)
{
// No implementation for RAM on Unix systems
int p = (int)Environment.OSVersion.Platform;
if ((p == 4) || (p == 128))
{
hardware = new Hardware[0];
return;
}
hardware = new Hardware[] { new GenericRAM("Generic Memory", settings, sensorConfig, rTSSService) };
}
public OverlayService(IStatisticProvider statisticProvider,
ISensorService sensorService,
IOverlayEntryProvider overlayEntryProvider,
IAppConfiguration appConfiguration,
ILogger <OverlayService> logger,
IRecordManager recordManager,
IRTSSService rTSSService)
{
_statisticProvider = statisticProvider;
_overlayEntryProvider = overlayEntryProvider;
_appConfiguration = appConfiguration;
_logger = logger;
_recordManager = recordManager;
_rTSSService = rTSSService;
_numberOfRuns = _appConfiguration.SelectedHistoryRuns;
SecondMetric = _appConfiguration.SecondMetricOverlay;
ThirdMetric = _appConfiguration.ThirdMetricOverlay;
IsOverlayActiveStream = new BehaviorSubject <bool>(_appConfiguration.IsOverlayActive);
_runHistoryOutlierFlags = Enumerable.Repeat(false, _numberOfRuns).ToArray();
_logger.LogDebug("{componentName} Ready", this.GetType().Name);
IsOverlayActiveStream.AsObservable()
.Select(isActive =>
{
if (isActive)
{
_rTSSService.ResetOSD();
return(sensorService.OnDictionaryUpdated
.SelectMany(_ => _overlayEntryProvider.GetOverlayEntries()));
}
else
{
_rTSSService.ReleaseOSD();
return(Observable.Empty <IOverlayEntry[]>());
}
}).Switch()
.Subscribe(entries =>
{
_rTSSService.SetOverlayEntries(entries);
_rTSSService.CheckRTSSRunningAndRefresh();
});
_runHistory = Enumerable.Repeat("N/A", _numberOfRuns).ToList();
_rTSSService.SetRunHistory(_runHistory.ToArray());
_rTSSService.SetRunHistoryAggregation(string.Empty);
_rTSSService.SetRunHistoryOutlierFlags(_runHistoryOutlierFlags);
_rTSSService.SetIsCaptureTimerActive(false);
}
public StateViewModel(IRecordDirectoryObserver recordObserver,
IEventAggregator eventAggregator,
IAppConfiguration appConfiguration,
ICaptureService captureService,
IOverlayService overlayService,
IUpdateCheck updateCheck,
IAppVersionProvider appVersionProvider,
IWebVersionProvider webVersionProvider,
LoginManager loginManager,
IRTSSService rTSSService)
{
_recordObserver = recordObserver;
_eventAggregator = eventAggregator;
_appConfiguration = appConfiguration;
_captureService = captureService;
_overlayService = overlayService;
_updateCheck = updateCheck;
_appVersionProvider = appVersionProvider;
IsCaptureModeActive = false;
IsOverlayActive = _appConfiguration.IsOverlayActive && rTSSService.IsRTSSInstalled();
_captureService.IsCaptureModeActiveStream
.Subscribe(state => IsCaptureModeActive = state);
_captureService.IsLoggingActiveStream
.Subscribe(state => IsLoggingActive = state);
_overlayService.IsOverlayActiveStream
.Subscribe(state => IsOverlayActive = state);
IsLoggedIn = loginManager.State.Token != null;
_eventAggregator.GetEvent <PubSubEvent <AppMessages.LoginState> >().Subscribe(state => {
IsLoggedIn = state.IsLoggedIn;
RaisePropertyChanged(nameof(IsLoggedIn));
});
Task.Run(async() =>
{
var(updateAvailable, updateVersion) = await _updateCheck.IsUpdateAvailable();
Dispatcher.CurrentDispatcher.Invoke(() =>
{
IsUpdateAvailable = updateAvailable;
UpdateHyperlinkText = $"New version available on GitHub: v{updateVersion}";
RaisePropertyChanged(nameof(IsUpdateAvailable));
});
});
}
public OnlineMetricService(IStatisticProvider frametimeStatisticProvider,
IRTSSService rTSSService,
ICaptureService captureServive,
IEventAggregator eventAggregator,
ILogger <OnlineMetricService> logger)
{
_rTSSService = rTSSService;
_captureServive = captureServive;
_eventAggregator = eventAggregator;
_logger = logger;
_frametimeStatisticProvider = frametimeStatisticProvider;
SubscribeToUpdateSession();
ConnectOnlineMetricDataStream();
}
public RecordManager(ILogger <RecordManager> logger,
IAppConfiguration appConfiguration,
IRecordDirectoryObserver recordObserver,
IAppVersionProvider appVersionProvider,
ISensorService sensorService,
ISystemInfo systemInfo,
ProcessList processList,
IRTSSService rTSSService)
{
_logger = logger;
_appConfiguration = appConfiguration;
_recordObserver = recordObserver;
_appVersionProvider = appVersionProvider;
_sensorService = sensorService;
_systemInfo = systemInfo;
_processList = processList;
_rTSSService = rTSSService;
}
public OverlayViewModel(IOverlayService overlayService, IOverlayEntryProvider overlayEntryProvider,
IAppConfiguration appConfiguration, IEventAggregator eventAggregator, ISensorService sensorService, IRTSSService rTSSService)
{
_overlayService = overlayService;
_overlayEntryProvider = overlayEntryProvider;
_appConfiguration = appConfiguration;
_eventAggregator = eventAggregator;
_sensorService = sensorService;
_rTSSService = rTSSService;
var configSubject = new Subject <object>();
ConfigSwitchCommand = new DelegateCommand <object>(configSubject.OnNext);
configSubject
.Select(obj => Convert.ToInt32(obj)).DistinctUntilChanged()
.SelectMany(index =>
{
return(Observable.FromAsync(() => _overlayEntryProvider.SwitchConfigurationTo(index))
.SelectMany(_ => _sensorService.OnDictionaryUpdated.Take(1)));
})
.StartWith(Enumerable.Empty <IOverlayEntry>())
.SelectMany(_ => _overlayEntryProvider.GetOverlayEntries())
.ObserveOnDispatcher()
.Subscribe(entries =>
{
OverlayEntries.Clear();
OverlayEntries.AddRange(entries);
OnUseRunHistoryChanged();
});
SaveConfigCommand = new DelegateCommand(
() => _overlayEntryProvider.SaveOverlayEntriesToJson());
ResetDefaultsCommand = new DelegateCommand(
async() => await OnResetDefaults());
UpdateHpyerlinkText = "To use the overlay, install the latest" + Environment.NewLine +
"RivaTuner Statistics Server (RTSS)";
SetGlobalHookEventOverlayHotkey();
SetGlobalHookEventResetHistoryHotkey();
}
public CaptureManager(ICaptureService presentMonCaptureService,
ISensorService sensorService,
IOverlayService overlayService,
SoundManager soundManager,
IRecordManager recordManager,
ILogger <CaptureManager> logger,
IAppConfiguration appConfiguration,
IRTSSService rtssService,
ISensorConfig sensorConfig)
{
_presentMonCaptureService = presentMonCaptureService;
_sensorService = sensorService;
_overlayService = overlayService;
_soundManager = soundManager;
_recordManager = recordManager;
_logger = logger;
_appConfiguration = appConfiguration;
_rtssService = rtssService;
_sensorConfig = sensorConfig;
_presentMonCaptureService.IsCaptureModeActiveStream.OnNext(false);
}
public NvidiaGroup(ISettings settings, ISensorConfig sensorConfig, IRTSSService rTSSService)
{
if (!NVAPI.IsAvailable)
{
return;
}
report.AppendLine("NVAPI");
report.AppendLine();
if (NVAPI.NvAPI_GetInterfaceVersionString(out string version) == NvStatus.OK)
{
report.Append(" Version: ");
report.AppendLine(version);
}
NvPhysicalGpuHandle[] handles =
new NvPhysicalGpuHandle[NVAPI.MAX_PHYSICAL_GPUS];
int count;
if (NVAPI.NvAPI_EnumPhysicalGPUs == null)
{
report.AppendLine(" Error: NvAPI_EnumPhysicalGPUs not available");
report.AppendLine();
return;
}
else
{
NvStatus status = NVAPI.NvAPI_EnumPhysicalGPUs(handles, out count);
if (status != NvStatus.OK)
{
report.AppendLine(" Status: " + status);
report.AppendLine();
return;
}
}
var result = NVML.NvmlInit();
report.AppendLine();
report.AppendLine("NVML");
report.AppendLine();
report.AppendLine(" Status: " + result);
report.AppendLine();
IDictionary <NvPhysicalGpuHandle, NvDisplayHandle> displayHandles =
new Dictionary <NvPhysicalGpuHandle, NvDisplayHandle>();
if (NVAPI.NvAPI_EnumNvidiaDisplayHandle != null &&
NVAPI.NvAPI_GetPhysicalGPUsFromDisplay != null)
{
NvStatus status = NvStatus.OK;
int i = 0;
while (status == NvStatus.OK)
{
NvDisplayHandle displayHandle = new NvDisplayHandle();
status = NVAPI.NvAPI_EnumNvidiaDisplayHandle(i, ref displayHandle);
i++;
if (status == NvStatus.OK)
{
NvPhysicalGpuHandle[] handlesFromDisplay =
new NvPhysicalGpuHandle[NVAPI.MAX_PHYSICAL_GPUS];
if (NVAPI.NvAPI_GetPhysicalGPUsFromDisplay(displayHandle,
handlesFromDisplay, out uint countFromDisplay) == NvStatus.OK)
{
for (int j = 0; j < countFromDisplay; j++)
{
if (!displayHandles.ContainsKey(handlesFromDisplay[j]))
{
displayHandles.Add(handlesFromDisplay[j], displayHandle);
}
}
}
}
}
}
report.Append("Number of GPUs: ");
report.AppendLine(count.ToString(CultureInfo.InvariantCulture));
for (int i = 0; i < count; i++)
{
displayHandles.TryGetValue(handles[i], out NvDisplayHandle displayHandle);
hardware.Add(new NvidiaGPU(i, handles[i], displayHandle, settings, sensorConfig, rTSSService));
}
report.AppendLine();
}
public OverlayService(IStatisticProvider statisticProvider,
ISensorService sensorService,
IOverlayEntryProvider overlayEntryProvider,
IAppConfiguration appConfiguration,
ILogger <OverlayService> logger,
IRecordManager recordManager,
IRTSSService rTSSService,
IOverlayEntryCore overlayEntryCore)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
_statisticProvider = statisticProvider;
_overlayEntryProvider = overlayEntryProvider;
_appConfiguration = appConfiguration;
_logger = logger;
_recordManager = recordManager;
_sensorService = sensorService;
_rTSSService = rTSSService;
_overlayEntryCore = overlayEntryCore;
_numberOfRuns = _appConfiguration.SelectedHistoryRuns;
SecondMetric = _appConfiguration.RunHistorySecondMetric;
ThirdMetric = _appConfiguration.RunHistoryThirdMetric;
IsOverlayActiveStream = new BehaviorSubject <bool>(_appConfiguration.IsOverlayActive);
_runHistoryOutlierFlags = Enumerable.Repeat(false, _numberOfRuns).ToArray();
_logger.LogDebug("{componentName} Ready", this.GetType().Name);
Task.Run(async() => await InitializeOverlayEntryDict())
.ContinueWith(t =>
{
IsOverlayActiveStream
.AsObservable()
.Select(isActive =>
{
if (isActive)
{
_rTSSService.CheckRTSSRunning().Wait();
_rTSSService.OnOSDOn();
_rTSSService.ClearOSD();
return(_onDictionaryUpdated.
SelectMany(_ => _overlayEntryProvider.GetOverlayEntries()));
}
else
{
_rTSSService.ReleaseOSD();
return(Observable.Empty <IOverlayEntry[]>());
}
})
.Switch()
.Subscribe(async entries =>
{
_rTSSService.SetOverlayEntries(entries);
await _rTSSService.CheckRTSSRunningAndRefresh();
});
});
_sensorService.SensorSnapshotStream
.Sample(_sensorService.OsdUpdateStream.Select(timespan => Observable.Concat(Observable.Return(-1L), Observable.Interval(timespan))).Switch())
.Where((_, idx) => idx == 0 || IsOverlayActive)
.SubscribeOn(Scheduler.Default)
.Subscribe(sensorData =>
{
UpdateOverlayEntries(sensorData.Item2);
_onDictionaryUpdated.OnNext(_overlayEntryCore.OverlayEntryDict.Values.ToArray());
});
_runHistory = Enumerable.Repeat("N/A", _numberOfRuns).ToList();
_rTSSService.SetRunHistory(_runHistory.ToArray());
_rTSSService.SetRunHistoryAggregation(string.Empty);
_rTSSService.SetRunHistoryOutlierFlags(_runHistoryOutlierFlags);
_rTSSService.SetIsCaptureTimerActive(false);
stopwatch.Stop();
_logger.LogInformation(GetType().Name + " {initializationTime}s initialization time", Math.Round(stopwatch.ElapsedMilliseconds * 1E-03, 1));
}
public OverlayService(IStatisticProvider statisticProvider,
ISensorService sensorService,
IOverlayEntryProvider overlayEntryProvider,
IAppConfiguration appConfiguration,
ILogger <OverlayService> logger,
IRecordManager recordManager,
IRTSSService rTSSService)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
_statisticProvider = statisticProvider;
_overlayEntryProvider = overlayEntryProvider;
_appConfiguration = appConfiguration;
_logger = logger;
_recordManager = recordManager;
_rTSSService = rTSSService;
_numberOfRuns = _appConfiguration.SelectedHistoryRuns;
SecondMetric = _appConfiguration.SecondMetricOverlay;
ThirdMetric = _appConfiguration.ThirdMetricOverlay;
IsOverlayActiveStream = new BehaviorSubject <bool>(_appConfiguration.IsOverlayActive);
_runHistoryOutlierFlags = Enumerable.Repeat(false, _numberOfRuns).ToArray();
_logger.LogDebug("{componentName} Ready", this.GetType().Name);
IsOverlayActiveStream.AsObservable()
.Select(isActive =>
{
if (isActive)
{
TryCloseRTSS();
_rTSSService.CheckRTSSRunning().Wait();
_rTSSService.ResetOSD();
return(sensorService.OnDictionaryUpdated
.SelectMany(_ => _overlayEntryProvider.GetOverlayEntries()));
}
else
{
// OSD status logging
Task.Run(async() =>
{
var processId = await _rTSSService.ProcessIdStream.Take(1);
try
{
_logger.LogInformation("Is process {detectedProcess} detected: {isDetected}", processId, _rTSSService.IsProcessDetected(processId));
}
catch
{
_logger.LogError("Error while checking RTSS core process detection");
}
//try
//{
// _logger.LogInformation("Is OS locked: {isLocked}", _rTSSService.IsOSDLocked());
//}
//catch
//{
// _logger.LogError("Error while checking RTSS core OSD lock status");
//}
}).Wait();
_rTSSService.ReleaseOSD();
return(Observable.Empty <IOverlayEntry[]>());
}
}).Switch()
.SubscribeOn(Scheduler.Default)
.Subscribe(async entries =>
{
_rTSSService.SetOverlayEntries(entries);
await _rTSSService.CheckRTSSRunningAndRefresh();
});
_runHistory = Enumerable.Repeat("N/A", _numberOfRuns).ToList();
_rTSSService.SetRunHistory(_runHistory.ToArray());
_rTSSService.SetRunHistoryAggregation(string.Empty);
_rTSSService.SetRunHistoryOutlierFlags(_runHistoryOutlierFlags);
_rTSSService.SetIsCaptureTimerActive(false);
stopwatch.Stop();
_logger.LogInformation(GetType().Name + " {initializationTime}s initialization time", Math.Round(stopwatch.ElapsedMilliseconds * 1E-03, 1));
}
public GPUBase(string name, Identifier identifier, ISettings settings, IRTSSService rTSSService) : base(name, identifier, settings)
{
refreshRateBuffer = new RefreshRateBuffer(2);
try
{
if (PerformanceCounterCategory.Exists("GPU Adapter Memory"))
{
var category = new PerformanceCounterCategory("GPU Adapter Memory");
var instances = category.GetInstanceNames().Where(inst => inst != string.Empty).ToArray();
if (instances.Any())
{
float maxValue = 0;
int maxIndex = 0;
for (int i = 0; i < instances.Length; i++)
{
try
{
var currentPerfCounter = new PerformanceCounter("GPU Adapter Memory", "Dedicated Usage", instances[i]);
if (currentPerfCounter.NextValue() > maxValue)
{
maxValue = currentPerfCounter.NextValue();
maxIndex = i;
}
}
catch (Exception ex)
{
Log.Logger.Error(ex, $"Error while creating performance counter with instance {i}.");
}
}
dedicatedVramUsagePerformCounter = new PerformanceCounter("GPU Adapter Memory", "Dedicated Usage", instances[maxIndex]);
sharedVramUsagePerformCounter = new PerformanceCounter("GPU Adapter Memory", "Shared Usage", instances[maxIndex]);
}
else
{
Log.Logger.Error("Error while creating GPU memory performance counter. No instances found.");
}
}
}
catch (Exception ex)
{
Log.Logger.Error(ex, "Error while creating GPU memory performance counter.");
}
try
{
if (PerformanceCounterCategory.Exists("GPU Process Memory"))
{
var category = new PerformanceCounterCategory("GPU Process Memory");
_ = rTSSService
.ProcessIdStream
.DistinctUntilChanged()
.Subscribe(id =>
{
lock (_performanceCounterLock)
{
if (id == 0)
{
dedicatedVramUsageProcessPerformCounter = null;
sharedVramUsageProcessPerformCounter = null;
}
else
{
string idString = $"pid_{id}_luid";
var instances = category.GetInstanceNames();
if (instances != null && instances.Any())
{
var pids = instances.Where(instance => instance.Contains(idString));
if (pids != null)
{
var pid = GetMaximumPid(pids);
dedicatedVramUsageProcessPerformCounter = new PerformanceCounter("GPU Process Memory", "Dedicated Usage", pid);
sharedVramUsageProcessPerformCounter = new PerformanceCounter("GPU Process Memory", "Shared Usage", pid);
}
else
{
dedicatedVramUsageProcessPerformCounter = null;
sharedVramUsageProcessPerformCounter = null;
}
}
else
{
dedicatedVramUsageProcessPerformCounter = null;
sharedVramUsageProcessPerformCounter = null;
Log.Logger.Error("Error while creating GPU process memory performance counter. No instances found.");
}
}
}
lock (_displayLock)
{
refreshRateBuffer.Clear();
if (id == 0)
{
display = null;
refreshRateCurrentWindowHandle = 0;
}
else
{
try
{
var process = Process.GetProcessById(id);
display = new Display(process.MainWindowHandle);
refreshRateCurrentWindowHandle = display.GetDisplayRefreshRate();
}
catch
{
display = null;
refreshRateCurrentWindowHandle = 0;
}
}
}
});
}
}
catch (Exception ex)
{
Log.Logger.Error(ex, "Error while creating GPU process memory performance counter.");
}
}
public NvidiaGPU(int adapterIndex, NvPhysicalGpuHandle handle,
NvDisplayHandle?displayHandle, ISettings settings, ISensorConfig config, IRTSSService rTSSService)
: base(GetName(handle), new Identifier("nvidiagpu",
adapterIndex.ToString(CultureInfo.InvariantCulture)), settings, rTSSService)
{
this.adapterIndex = adapterIndex;
this.handle = handle;
this.displayHandle = displayHandle;
this.sensorConfig = config;
this.stopwatch = new Stopwatch();
NvGPUThermalSettings thermalSettings = GetThermalSettings();
temperatures = new Sensor[thermalSettings.Count];
for (int i = 0; i < temperatures.Length; i++)
{
NvSensor sensor = thermalSettings.Sensor[i];
string name;
switch (sensor.Target)
{
case NvThermalTarget.BOARD: name = "GPU Board"; break;
case NvThermalTarget.GPU: name = "GPU Core"; break;
case NvThermalTarget.MEMORY: name = "GPU Memory"; break;
case NvThermalTarget.POWER_SUPPLY: name = "GPU Power Supply"; break;
case NvThermalTarget.UNKNOWN: name = "GPU Unknown"; break;
default: name = "GPU"; break;
}
temperatures[i] = new Sensor(name, i, SensorType.Temperature, this,
new ParameterDescription[0], settings);
ActivateSensor(temperatures[i]);
}
clocks = new Sensor[3];
clocks[0] = new Sensor("GPU Core", 0, SensorType.Clock, this, settings);
clocks[1] = new Sensor("GPU Memory", 1, SensorType.Clock, this, settings);
clocks[2] = new Sensor("GPU Shader", 2, SensorType.Clock, this, settings);
for (int i = 0; i < clocks.Length; i++)
{
ActivateSensor(clocks[i]);
}
loads = new Sensor[4];
loads[0] = new Sensor("GPU Core", 0, SensorType.Load, this, settings);
loads[1] = new Sensor("GPU Frame Buffer", 1, SensorType.Load, this, settings);
loads[2] = new Sensor("GPU Video Engine", 2, SensorType.Load, this, settings);
loads[3] = new Sensor("GPU Bus Interface", 3, SensorType.Load, this, settings);
memoryLoad = new Sensor("GPU Memory", 4, SensorType.Load, this, settings);
memoryFree = new Sensor("GPU Memory Free", 1, SensorType.Data, this, settings);
memoryUsed = new Sensor("GPU Memory Used", 2, SensorType.Data, this, settings);
memoryAvail = new Sensor("GPU Memory Total", 3, SensorType.Data, this, settings);
memoryUsageDedicated = new Sensor("GPU Memory Dedicated", 4, SensorType.Data, this, settings);
memoryUsageShared = new Sensor("GPU Memory Shared", 5, SensorType.Data, this, settings);
processMemoryUsageDedicated = new Sensor("GPU Memory Dedicated Game", 6, SensorType.Data, this, settings);
processMemoryUsageShared = new Sensor("GPU Memory Shared Game", 7, SensorType.Data, this, settings);
fan = new Sensor("GPU Fan", 0, SensorType.Fan, this, settings);
control = new Sensor("GPU Fan", 1, SensorType.Control, this, settings);
voltage = new Sensor("GPU Voltage", 0, SensorType.Voltage, this, settings);
power = new Sensor("GPU Power", 0, SensorType.Power, this, settings);
NvGPUCoolerSettings coolerSettings = GetCoolerSettings();
if (coolerSettings.Count > 0)
{
fanControl = new Control(control, settings,
coolerSettings.Cooler[0].DefaultMin,
coolerSettings.Cooler[0].DefaultMax);
fanControl.ControlModeChanged += ControlModeChanged;
fanControl.SoftwareControlValueChanged += SoftwareControlValueChanged;
ControlModeChanged(fanControl);
control.Control = fanControl;
}
monitorRefreshRate = new Sensor("Monitor Refresh Rate", 0, SensorType.Frequency, this, settings);
if (NVML.IsInitialized)
{
if (NVAPI.NvAPI_GPU_GetBusId != null &&
NVAPI.NvAPI_GPU_GetBusId(handle, out uint busId) == NvStatus.OK)
{
if (NVML.NvmlDeviceGetHandleByPciBusId != null &&
NVML.NvmlDeviceGetHandleByPciBusId(
"0000:" + busId.ToString("X2") + ":00.0", out var result)
== NVML.NvmlReturn.Success)
{
device = result;
pcieThroughputRx = new Sensor("GPU PCIE Rx", 0,
SensorType.Throughput, this, settings);
pcieThroughputTx = new Sensor("GPU PCIE Tx", 1,
SensorType.Throughput, this, settings);
}
}
}
Update();
}
public ATIGroup(ISettings settings, ISensorConfig sensorConfig, IRTSSService rTSSService)
{
try
{
int adlStatus = ADL.ADL_Main_Control_Create(1);
int adl2Status = ADL.ADL2_Main_Control_Create(1, out context);
report.AppendLine("AMD Display Library");
report.AppendLine();
report.Append("ADL Status: ");
report.AppendLine(adlStatus == ADL.ADL_OK ? "OK" :
adlStatus.ToString(CultureInfo.InvariantCulture));
report.Append("ADL2 Status: ");
report.AppendLine(adl2Status == ADL.ADL_OK ? "OK" :
adl2Status.ToString(CultureInfo.InvariantCulture));
report.AppendLine();
if (adlStatus == ADL.ADL_OK)
{
int numberOfAdapters = 0;
ADL.ADL_Adapter_NumberOfAdapters_Get(ref numberOfAdapters);
report.Append("Number of adapters: ");
report.AppendLine(numberOfAdapters.ToString(CultureInfo.InvariantCulture));
report.AppendLine();
if (numberOfAdapters > 0)
{
ADLAdapterInfo[] adapterInfo = new ADLAdapterInfo[numberOfAdapters];
if (ADL.ADL_Adapter_AdapterInfo_Get(adapterInfo) == ADL.ADL_OK)
{
for (int i = 0; i < numberOfAdapters; i++)
{
int isActive;
ADL.ADL_Adapter_Active_Get(adapterInfo[i].AdapterIndex,
out isActive);
int adapterID;
ADL.ADL_Adapter_ID_Get(adapterInfo[i].AdapterIndex,
out adapterID);
report.Append("AdapterIndex: ");
report.AppendLine(i.ToString(CultureInfo.InvariantCulture));
report.Append("isActive: ");
report.AppendLine(isActive.ToString(CultureInfo.InvariantCulture));
report.Append("AdapterName: ");
report.AppendLine(adapterInfo[i].AdapterName);
report.Append("UDID: ");
report.AppendLine(adapterInfo[i].UDID);
report.Append("Present: ");
report.AppendLine(adapterInfo[i].Present.ToString(
CultureInfo.InvariantCulture));
report.Append("VendorID: 0x");
report.AppendLine(adapterInfo[i].VendorID.ToString("X",
CultureInfo.InvariantCulture));
report.Append("BusNumber: ");
report.AppendLine(adapterInfo[i].BusNumber.ToString(
CultureInfo.InvariantCulture));
report.Append("DeviceNumber: ");
report.AppendLine(adapterInfo[i].DeviceNumber.ToString(
CultureInfo.InvariantCulture));
report.Append("FunctionNumber: ");
report.AppendLine(adapterInfo[i].FunctionNumber.ToString(
CultureInfo.InvariantCulture));
report.Append("AdapterID: 0x");
report.AppendLine(adapterID.ToString("X",
CultureInfo.InvariantCulture));
if (!string.IsNullOrEmpty(adapterInfo[i].UDID) &&
adapterInfo[i].VendorID == ADL.ATI_VENDOR_ID)
{
bool found = false;
foreach (ATIGPU gpu in hardware)
{
if (gpu.BusNumber == adapterInfo[i].BusNumber &&
gpu.DeviceNumber == adapterInfo[i].DeviceNumber)
{
found = true;
break;
}
}
if (!found)
{
hardware.Add(new ATIGPU(
adapterInfo[i].AdapterName.Trim(),
adapterInfo[i].AdapterIndex,
adapterInfo[i].BusNumber,
adapterInfo[i].DeviceNumber,
context, settings,
sensorConfig,
rTSSService));
}
}
report.AppendLine();
}
}
}
}
}
catch (DllNotFoundException) { }
catch (EntryPointNotFoundException e)
{
report.AppendLine();
report.AppendLine(e.ToString());
report.AppendLine();
}
}
public ATIGPU(string name, int adapterIndex, int busNumber,
int deviceNumber, IntPtr context, ISettings settings, ISensorConfig config, IRTSSService rTSSService)
: base(name, new Identifier("atigpu",
adapterIndex.ToString(CultureInfo.InvariantCulture)), settings, rTSSService)
{
this.adapterIndex = adapterIndex;
this.busNumber = busNumber;
this.deviceNumber = deviceNumber;
this.sensorConfig = config;
this.context = context;
if (ADL.ADL_Overdrive_Caps(adapterIndex, out _, out _,
out overdriveVersion) != ADL.ADL_OK)
{
overdriveVersion = -1;
}
this.temperatureCore =
new Sensor("GPU Core", 0, SensorType.Temperature, this, settings);
this.temperatureMemory =
new Sensor("GPU Memory", 1, SensorType.Temperature, this, settings);
this.temperatureVrmCore =
new Sensor("GPU VRM Core", 2, SensorType.Temperature, this, settings);
this.temperatureVrmMemory =
new Sensor("GPU VRM Memory", 3, SensorType.Temperature, this, settings);
//this.temperatureVrmMemory0 =
// new Sensor("GPU VRM Memory #1", 4, SensorType.Temperature, this, settings);
//this.temperatureVrmMemory1 =
// new Sensor("GPU VRM Memory #2", 5, SensorType.Temperature, this, settings);
this.temperatureVrmSoc =
new Sensor("GPU VRM SOC", 6, SensorType.Temperature, this, settings);
this.temperatureLiquid =
new Sensor("GPU Liquid", 7, SensorType.Temperature, this, settings);
this.temperaturePlx =
new Sensor("GPU PLX", 8, SensorType.Temperature, this, settings);
this.temperatureHotSpot =
new Sensor("GPU Hot Spot", 9, SensorType.Temperature, this, settings);
this.powerTotal = new Sensor("GPU Total", 0, SensorType.Power, this, settings);
this.powerCore = new Sensor("GPU Core", 1, SensorType.Power, this, settings);
this.powerPpt = new Sensor("GPU PPT", 2, SensorType.Power, this, settings);
this.powerSocket = new Sensor("GPU Socket", 3, SensorType.Power, this, settings);
this.powerSoc = new Sensor("GPU SOC", 4, SensorType.Power, this, settings);
this.fan = new Sensor("GPU Fan", 0, SensorType.Fan, this, settings);
this.coreClock = new Sensor("GPU Core", 0, SensorType.Clock, this, settings);
this.memoryClock = new Sensor("GPU Memory", 1, SensorType.Clock, this, settings);
this.socClock = new Sensor("GPU SOC", 2, SensorType.Clock, this, settings);
this.coreVoltage = new Sensor("GPU Core", 0, SensorType.Voltage, this, settings);
this.memoryVoltage = new Sensor("GPU Memory", 1, SensorType.Voltage, this, settings);
this.socVoltage = new Sensor("GPU SOC", 2, SensorType.Voltage, this, settings);
this.coreLoad = new Sensor("GPU Core", 0, SensorType.Load, this, settings);
this.memoryControllerLoad = new Sensor("GPU Memory Controller", 1, SensorType.Load, this, settings);
this.controlSensor = new Sensor("GPU Fan", 0, SensorType.Control, this, settings);
this.memoryUsed = new Sensor("GPU Memory Used", 4, SensorType.Data, this, settings);
this.memoryUsageDedicated = new Sensor("GPU Memory Dedicated", 0, SensorType.Data, this, settings);
this.memoryUsageShared = new Sensor("GPU Memory Shared", 1, SensorType.Data, this, settings);
this.processMemoryUsageDedicated = new Sensor("GPU Memory Dedicated Game", 2, SensorType.Data, this, settings);
this.processMemoryUsageShared = new Sensor("GPU Memory Shared Game", 3, SensorType.Data, this, settings);
ADLFanSpeedInfo afsi = new ADLFanSpeedInfo();
if (ADL.ADL_Overdrive5_FanSpeedInfo_Get(adapterIndex, 0, ref afsi)
!= ADL.ADL_OK)
{
afsi.MaxPercent = 100;
afsi.MinPercent = 0;
}
this.fanControl = new Control(controlSensor, settings, afsi.MinPercent,
afsi.MaxPercent);
this.fanControl.ControlModeChanged += ControlModeChanged;
this.fanControl.SoftwareControlValueChanged +=
SoftwareControlValueChanged;
ControlModeChanged(fanControl);
this.controlSensor.Control = fanControl;
Update();
}
public GenericRAM(string name, ISettings settings, ISensorConfig config, IRTSSService service)
: base(name, new Identifier("ram"), settings)
{
sensorConfig = config;
try
{
if (PerformanceCounterCategory.Exists("Process"))
{
service
.ProcessIdStream
.DistinctUntilChanged()
.Subscribe(id =>
{
lock (_performanceCounterLock)
{
try
{
if (id == 0)
{
ramUsageGamePerformanceCounter = null;
ramAndCacheUsageGamePerformanceCounter = null;
return;
}
var process = Process.GetProcessById(id);
if (process != null)
{
var validInstanceName = GetValidInstanceName(process);
Log.Logger.Information("Valid instance name for memory performance counter: {instanceName}", validInstanceName);
// Working Set - Private
ramUsageGamePerformanceCounter = new PerformanceCounter("Process", "Working Set - Private", validInstanceName, true);
// Working Set (private + resources)
ramAndCacheUsageGamePerformanceCounter = new PerformanceCounter("Process", "Working Set", validInstanceName, true);
}
else
{
Log.Logger.Error("Failed to get process by Id={Id}.", id);
ramUsageGamePerformanceCounter = null;
ramAndCacheUsageGamePerformanceCounter = null;
}
}
catch
{
ramUsageGamePerformanceCounter = null;
ramAndCacheUsageGamePerformanceCounter = null;
Log.Logger.Error("Failed to create performance counter Working Set or Working Set - Private");
}
}
});
}
else
{
Log.Logger.Error("Failed to create memory performance counter. Category Process does not exist.");
}
}
catch (Exception ex)
{
Log.Logger.Error(ex, "Failed to create memory performance counter.");
}
loadSensor = new Sensor("Memory", 0, SensorType.Load, this, settings);
ActivateSensor(loadSensor);
usedMemory = new Sensor("Used Memory", 0, SensorType.Data, this,
settings);
ActivateSensor(usedMemory);
availableMemory = new Sensor("Available Memory", 1, SensorType.Data, this,
settings);
ActivateSensor(availableMemory);
usedMemoryProcess = new Sensor("Used Memory Game", 2, SensorType.Data, this,
settings);
ActivateSensor(usedMemoryProcess);
usedMemoryAndCacheProcess = new Sensor("Memory + Cache Game", 3, SensorType.Data, this,
settings);
ActivateSensor(usedMemoryAndCacheProcess);
}
