jkocon/archived-g-helper
1
0
Fork 0
mirror of https://github.com/jkocon/g-helper.git synced 2026-02-23 13:00:52 +01:00
Code Issues Packages Projects Releases Wiki Activity

More cleanup

Browse Source
This commit is contained in:
Serge
2023-06-26 16:46:15 +02:00
parent 164d417b06
commit d0d44c3ef1
32 changed files with 738 additions and 726 deletions
Download Patch File Download Diff File Expand all files Collapse all files

105
app/Gpu/AmdAdl2.cs → app/Gpu/AMD/AmdAdl2.cs
View File

@@ -1,8 +1,8 @@
using System.Diagnostics;
using System.Runtime.InteropServices;
using static AmdAdl2.Adl2.NativeMethods;
using static GHelper.Gpu.AMD.Adl2.NativeMethods;
namespace AmdAdl2;
namespace GHelper.Gpu.AMD;
#region Export Struct
@@ -33,13 +33,15 @@ public struct ADLBdf
}
[StructLayout(LayoutKind.Sequential)]
public struct ADLSingleSensorData {
public struct ADLSingleSensorData
{
public int Supported;
public int Value;
}
[StructLayout(LayoutKind.Sequential)]
public struct ADLPMLogDataOutput {
public struct ADLPMLogDataOutput
{
int Size;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = Adl2.ADL_PMLOG_MAX_SENSORS)]
@@ -57,7 +59,8 @@ public struct ADLGcnInfo
}
[Flags]
public enum ADLAsicFamilyType {
public enum ADLAsicFamilyType
{
Undefined = 0,
Discrete = 1 << 0,
Integrated = 1 << 1,
@@ -69,7 +72,8 @@ public enum ADLAsicFamilyType {
Embedded = 1 << 7,
}
public enum ADLSensorType {
public enum ADLSensorType
{
SENSOR_MAXTYPES = 0,
PMLOG_CLK_GFXCLK = 1, // Current graphic clock value in MHz
PMLOG_CLK_MEMCLK = 2, // Current memory clock value in MHz
@@ -149,13 +153,15 @@ public enum ADLSensorType {
//Throttle Status
[Flags]
public enum ADL_THROTTLE_NOTIFICATION {
public enum ADL_THROTTLE_NOTIFICATION
{
ADL_PMLOG_THROTTLE_POWER = 1 << 0,
ADL_PMLOG_THROTTLE_THERMAL = 1 << 1,
ADL_PMLOG_THROTTLE_CURRENT = 1 << 2,
};
public enum ADL_PMLOG_SENSORS {
public enum ADL_PMLOG_SENSORS
{
ADL_SENSOR_MAXTYPES = 0,
ADL_PMLOG_CLK_GFXCLK = 1,
ADL_PMLOG_CLK_MEMCLK = 2,
@@ -237,7 +243,8 @@ public enum ADL_PMLOG_SENSORS {
/// <summary> ADLAdapterInfo Structure</summary>
[StructLayout(LayoutKind.Sequential)]
public struct ADLAdapterInfo {
public struct ADLAdapterInfo
{
/// <summary>The size of the structure</summary>
int Size;
@@ -292,7 +299,8 @@ public struct ADLAdapterInfo {
/// <summary> ADLAdapterInfo Array</summary>
[StructLayout(LayoutKind.Sequential)]
public struct ADLAdapterInfoArray {
public struct ADLAdapterInfoArray
{
/// <summary> ADLAdapterInfo Array </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = Adl2.ADL_MAX_ADAPTERS)]
public ADLAdapterInfo[] ADLAdapterInfo;
@@ -304,7 +312,8 @@ public struct ADLAdapterInfoArray {
/// <summary> ADLDisplayID Structure</summary>
[StructLayout(LayoutKind.Sequential)]
public struct ADLDisplayID {
public struct ADLDisplayID
{
/// <summary> Display Logical Index </summary>
public int DisplayLogicalIndex;
@@ -320,7 +329,8 @@ public struct ADLDisplayID {
/// <summary> ADLDisplayInfo Structure</summary>
[StructLayout(LayoutKind.Sequential)]
public struct ADLDisplayInfo {
public struct ADLDisplayInfo
{
/// <summary> Display Index </summary>
public ADLDisplayID DisplayID;
@@ -355,7 +365,8 @@ public struct ADLDisplayInfo {
#endregion Export Struct
public class Adl2 {
public class Adl2
{
public const string Atiadlxx_FileName = "atiadlxx.dll";
#region Internal Constant
@@ -398,24 +409,30 @@ public class Adl2 {
// ///// <summary> ADL Create Function to create ADL Data</summary>
/// <param name="enumConnectedAdapters">If it is 1, then ADL will only return the physical exist adapters </param>
///// <returns> retrun ADL Error Code</returns>
public static int ADL2_Main_Control_Create(int enumConnectedAdapters, out IntPtr adlContextHandle) {
public static int ADL2_Main_Control_Create(int enumConnectedAdapters, out nint adlContextHandle)
{
return NativeMethods.ADL2_Main_Control_Create(ADL_Main_Memory_Alloc_Impl_Reference, enumConnectedAdapters, out adlContextHandle);
}
public static void FreeMemory(IntPtr buffer) {
public static void FreeMemory(nint buffer)
{
Memory_Free_Impl(buffer);
}
private static bool? isDllLoaded;
public static bool Load() {
public static bool Load()
{
if (isDllLoaded != null)
return isDllLoaded.Value;
try {
try
{
Marshal.PrelinkAll(typeof(Adl2));
isDllLoaded = true;
} catch (Exception e) when (e is DllNotFoundException or EntryPointNotFoundException) {
}
catch (Exception e) when (e is DllNotFoundException or EntryPointNotFoundException)
{
Debug.WriteLine(e);
isDllLoaded = false;
}
@@ -423,53 +440,57 @@ public class Adl2 {
return isDllLoaded.Value;
}
private static NativeMethods.ADL_Main_Memory_Alloc ADL_Main_Memory_Alloc_Impl_Reference = Memory_Alloc_Impl;
private static ADL_Main_Memory_Alloc ADL_Main_Memory_Alloc_Impl_Reference = Memory_Alloc_Impl;
/// <summary> Build in memory allocation function</summary>
/// <param name="size">input size</param>
/// <returns>return the memory buffer</returns>
private static IntPtr Memory_Alloc_Impl(int size) {
private static nint Memory_Alloc_Impl(int size)
{
return Marshal.AllocCoTaskMem(size);
}
/// <summary> Build in memory free function</summary>
/// <param name="buffer">input buffer</param>
private static void Memory_Free_Impl(IntPtr buffer) {
if (IntPtr.Zero != buffer) {
private static void Memory_Free_Impl(nint buffer)
{
if (nint.Zero != buffer)
{
Marshal.FreeCoTaskMem(buffer);
}
}
public static class NativeMethods {
public static class NativeMethods
{
/// <summary> ADL Memory allocation function allows ADL to callback for memory allocation</summary>
/// <param name="size">input size</param>
/// <returns> retrun ADL Error Code</returns>
public delegate IntPtr ADL_Main_Memory_Alloc(int size);
public delegate nint ADL_Main_Memory_Alloc(int size);
// ///// <summary> ADL Create Function to create ADL Data</summary>
/// <param name="callback">Call back functin pointer which is ised to allocate memeory </param>
/// <param name="enumConnectedAdapters">If it is 1, then ADL will only retuen the physical exist adapters </param>
///// <returns> retrun ADL Error Code</returns>
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_Main_Control_Create(ADL_Main_Memory_Alloc callback, int enumConnectedAdapters, out IntPtr adlContextHandle);
public static extern int ADL2_Main_Control_Create(ADL_Main_Memory_Alloc callback, int enumConnectedAdapters, out nint adlContextHandle);
/// <summary> ADL Destroy Function to free up ADL Data</summary>
/// <returns> retrun ADL Error Code</returns>
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_Main_Control_Destroy(IntPtr adlContextHandle);
public static extern int ADL2_Main_Control_Destroy(nint adlContextHandle);
/// <summary> ADL Function to get the number of adapters</summary>
/// <param name="numAdapters">return number of adapters</param>
/// <returns> retrun ADL Error Code</returns>
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_Adapter_NumberOfAdapters_Get(IntPtr adlContextHandle, out int numAdapters);
public static extern int ADL2_Adapter_NumberOfAdapters_Get(nint adlContextHandle, out int numAdapters);
/// <summary> ADL Function to get the GPU adapter information</summary>
/// <param name="info">return GPU adapter information</param>
/// <param name="inputSize">the size of the GPU adapter struct</param>
/// <returns> retrun ADL Error Code</returns>
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_Adapter_AdapterInfo_Get(IntPtr adlContextHandle, IntPtr info, int inputSize);
public static extern int ADL2_Adapter_AdapterInfo_Get(nint adlContextHandle, nint info, int inputSize);
/// <summary> Function to determine if the adapter is active or not.</summary>
/// <remarks>The function is used to check if the adapter associated with iAdapterIndex is active</remarks>
@@ -477,7 +498,7 @@ public class Adl2 {
/// <param name="status"> Status of the adapter. True: Active; False: Dsiabled</param>
/// <returns>Non zero is successfull</returns>
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_Adapter_Active_Get(IntPtr adlContextHandle, int adapterIndex, out int status);
public static extern int ADL2_Adapter_Active_Get(nint adlContextHandle, int adapterIndex, out int status);
/// <summary>Get display information based on adapter index</summary>
/// <param name="adapterIndex">Adapter Index</param>
@@ -487,16 +508,16 @@ public class Adl2 {
/// <returns>return ADL Error Code</returns>
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_Display_DisplayInfo_Get(
IntPtr adlContextHandle,
nint adlContextHandle,
int adapterIndex,
out int numDisplays,
out IntPtr displayInfoArray,
out nint displayInfoArray,
int forceDetect
);
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_Overdrive_Caps(
IntPtr adlContextHandle,
nint adlContextHandle,
int adapterIndex,
out int supported,
out int enabled,
@@ -504,21 +525,21 @@ public class Adl2 {
);
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_New_QueryPMLogData_Get(IntPtr adlContextHandle, int adapterIndex, out ADLPMLogDataOutput adlpmLogDataOutput);
public static extern int ADL2_New_QueryPMLogData_Get(nint adlContextHandle, int adapterIndex, out ADLPMLogDataOutput adlpmLogDataOutput);
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_Adapter_ASICFamilyType_Get(IntPtr adlContextHandle, int adapterIndex, out ADLAsicFamilyType asicFamilyType, out int asicFamilyTypeValids);
public static extern int ADL2_Adapter_ASICFamilyType_Get(nint adlContextHandle, int adapterIndex, out ADLAsicFamilyType asicFamilyType, out int asicFamilyTypeValids);
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_SwitchableGraphics_Applications_Get(
IntPtr context,
nint context,
int iListType,
out int lpNumApps,
out IntPtr lppAppList);
out nint lppAppList);
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_Adapter_VariBright_Caps(
IntPtr context,
nint context,
int iAdapterIndex,
out int iSupported,
out int iEnabled,
@@ -526,7 +547,7 @@ public class Adl2 {
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_Adapter_VariBrightEnable_Set(
IntPtr context,
nint context,
int iAdapterIndex,
int iEnabled);
@@ -553,25 +574,25 @@ public class Adl2 {
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_OverdriveN_SystemClocks_Get(
IntPtr context,
nint context,
int adapterIndex,
ref ADLODNPerformanceLevels performanceLevels);
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_OverdriveN_SystemClocks_Set(
IntPtr context,
nint context,
int adapterIndex,
ref ADLODNPerformanceLevels performanceLevels);
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_OverdriveN_MemoryClocks_Get(
IntPtr context,
nint context,
int adapterIndex,
ref ADLODNPerformanceLevels performanceLevels);
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_OverdriveN_MemoryClocks_Set(
IntPtr context,
nint context,
int adapterIndex,
ref ADLODNPerformanceLevels performanceLevels);
}

30
app/Gpu/AmdGpuControl.cs → app/Gpu/AMD/AmdGpuControl.cs
View File

@@ -1,14 +1,14 @@
using AmdAdl2;
using GHelper.Helpers;
using System.Runtime.InteropServices;
using static AmdAdl2.Adl2.NativeMethods;
using static GHelper.Gpu.AMD.Adl2.NativeMethods;
namespace GHelper.Gpu;
namespace GHelper.Gpu.AMD;
// Reference: https://github.com/GPUOpen-LibrariesAndSDKs/display-library/blob/master/Sample-Managed/Program.cs
public class AmdGpuControl : IGpuControl
{
private bool _isReady;
private IntPtr _adlContextHandle;
private nint _adlContextHandle;
private readonly ADLAdapterInfo _internalDiscreteAdapter;
public bool IsNvidia => false;
@@ -23,7 +23,7 @@ public class AmdGpuControl : IGpuControl
ADLAdapterInfoArray osAdapterInfoData = new();
int osAdapterInfoDataSize = Marshal.SizeOf(osAdapterInfoData);
IntPtr AdapterBuffer = Marshal.AllocCoTaskMem(osAdapterInfoDataSize);
nint AdapterBuffer = Marshal.AllocCoTaskMem(osAdapterInfoDataSize);
Marshal.StructureToPtr(osAdapterInfoData, AdapterBuffer, false);
if (ADL2_Adapter_AdapterInfo_Get(_adlContextHandle, AdapterBuffer, osAdapterInfoDataSize) != Adl2.ADL_SUCCESS)
return null;
@@ -76,7 +76,7 @@ public class AmdGpuControl : IGpuControl
}
public bool IsValid => _isReady && _adlContextHandle != IntPtr.Zero;
public bool IsValid => _isReady && _adlContextHandle != nint.Zero;
public int? GetCurrentTemperature()
{
@@ -112,7 +112,7 @@ public class AmdGpuControl : IGpuControl
public bool SetVariBright(int enabled)
{
if (_adlContextHandle == IntPtr.Zero) return false;
if (_adlContextHandle == nint.Zero) return false;
ADLAdapterInfo? iGPU = FindByType(ADLAsicFamilyType.Integrated);
if (iGPU is null) return false;
@@ -125,7 +125,7 @@ public class AmdGpuControl : IGpuControl
{
supported = enabled = -1;
if (_adlContextHandle == IntPtr.Zero) return false;
if (_adlContextHandle == nint.Zero) return false;
ADLAdapterInfo? iGPU = FindByType(ADLAsicFamilyType.Integrated);
if (iGPU is null) return false;
@@ -154,7 +154,7 @@ public class AmdGpuControl : IGpuControl
if (!IsValid) return;
IntPtr appInfoPtr = IntPtr.Zero;
nint appInfoPtr = nint.Zero;
int appCount = 0;
try
@@ -168,12 +168,12 @@ public class AmdGpuControl : IGpuControl
// Convert the application data pointers to an array of structs
var appInfoArray = new ADLSGApplicationInfo[appCount];
IntPtr currentPtr = appInfoPtr;
nint currentPtr = appInfoPtr;
for (int i = 0; i < appCount; i++)
{
appInfoArray[i] = Marshal.PtrToStructure<ADLSGApplicationInfo>(currentPtr);
currentPtr = IntPtr.Add(currentPtr, Marshal.SizeOf<ADLSGApplicationInfo>());
currentPtr = nint.Add(currentPtr, Marshal.SizeOf<ADLSGApplicationInfo>());
}
var appNames = new List<string>();
@@ -189,7 +189,7 @@ public class AmdGpuControl : IGpuControl
List<string> immune = new() { "svchost", "system", "ntoskrnl", "csrss", "winlogon", "wininit", "smss" };
foreach (string kill in appNames)
foreach (string kill in appNames)
if (!immune.Contains(kill.ToLower()))
ProcessHelper.KillByName(kill);
@@ -202,7 +202,7 @@ public class AmdGpuControl : IGpuControl
finally
{
// Clean up resources
if (appInfoPtr != IntPtr.Zero)
if (appInfoPtr != nint.Zero)
{
Marshal.FreeCoTaskMem(appInfoPtr);
}
@@ -213,10 +213,10 @@ public class AmdGpuControl : IGpuControl
private void ReleaseUnmanagedResources()
{
if (_adlContextHandle != IntPtr.Zero)
if (_adlContextHandle != nint.Zero)
{
ADL2_Main_Control_Destroy(_adlContextHandle);
_adlContextHandle = IntPtr.Zero;
_adlContextHandle = nint.Zero;
_isReady = false;
}
}

316
app/Gpu/GPUModeControl.cs Normal file
View File

@@ -0,0 +1,316 @@
using GHelper.Gpu.NVidia;
using GHelper.Helpers;
using GHelper.Mode;
using System.Diagnostics;
namespace GHelper.Gpu
{
public class GPUModeControl
{
static SettingsForm settings = Program.settingsForm;
ModeControl modeControl = new ModeControl();
public void InitGPUMode()
{
int eco = Program.acpi.DeviceGet(AsusACPI.GPUEco);
int mux = Program.acpi.DeviceGet(AsusACPI.GPUMux);
Logger.WriteLine("Eco flag : " + eco);
Logger.WriteLine("Mux flag : " + mux);
int GpuMode;
if (mux == 0)
{
GpuMode = AsusACPI.GPUModeUltimate;
}
else
{
if (eco == 1)
GpuMode = AsusACPI.GPUModeEco;
else
GpuMode = AsusACPI.GPUModeStandard;
// Ultimate mode not suported
if (mux != 1) settings.HideUltimateMode();
if (eco < 0 && mux < 0) settings.HideGPUModes();
}
AppConfig.Set("gpu_mode", GpuMode);
InitXGM();
settings.VisualiseGPUMode(GpuMode);
}
public void SetGPUMode(int GPUMode)
{
int CurrentGPU = AppConfig.Get("gpu_mode");
AppConfig.Set("gpu_auto", 0);
if (CurrentGPU == GPUMode)
{
settings.VisualiseGPUMode();
return;
}
var restart = false;
var changed = false;
if (CurrentGPU == AsusACPI.GPUModeUltimate)
{
DialogResult dialogResult = MessageBox.Show(Properties.Strings.AlertUltimateOff, Properties.Strings.AlertUltimateTitle, MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.Yes)
{
Program.acpi.DeviceSet(AsusACPI.GPUMux, 1, "GPUMux");
restart = true;
changed = true;
}
}
else if (GPUMode == AsusACPI.GPUModeUltimate)
{
DialogResult dialogResult = MessageBox.Show(Properties.Strings.AlertUltimateOn, Properties.Strings.AlertUltimateTitle, MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.Yes)
{
Program.acpi.DeviceSet(AsusACPI.GPUMux, 0, "GPUMux");
restart = true;
changed = true;
}
}
else if (GPUMode == AsusACPI.GPUModeEco)
{
settings.VisualiseGPUMode(GPUMode);
SetGPUEco(1, true);
changed = true;
}
else if (GPUMode == AsusACPI.GPUModeStandard)
{
settings.VisualiseGPUMode(GPUMode);
SetGPUEco(0);
changed = true;
}
if (changed)
{
AppConfig.Set("gpu_mode", GPUMode);
}
if (restart)
{
settings.VisualiseGPUMode();
Process.Start("shutdown", "/r /t 1");
}
}
public void SetGPUEco(int eco, bool hardWay = false)
{
settings.LockGPUModes();
Task.Run(async () =>
{
int status = 1;
if (eco == 1)
{
if (NvidiaSmi.GetDisplayActiveStatus())
{
DialogResult dialogResult = MessageBox.Show(Properties.Strings.EnableOptimusText, Properties.Strings.EnableOptimusTitle, MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.No)
{
InitGPUMode();
return;
}
}
HardwareControl.KillGPUApps();
}
Logger.WriteLine($"Running eco command {eco}");
status = Program.acpi.SetGPUEco(eco);
if (status == 0 && eco == 1 && hardWay) RestartGPU();
await Task.Delay(TimeSpan.FromMilliseconds(100));
settings.Invoke(delegate
{
InitGPUMode();
settings.AutoScreen();
});
if (eco == 0)
{
await Task.Delay(TimeSpan.FromMilliseconds(3000));
HardwareControl.RecreateGpuControl();
modeControl.SetGPUClocks(false);
}
});
}
public static bool IsPlugged()
{
bool optimizedUSBC = AppConfig.Get("optimized_usbc") != 1;
return SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online &&
(optimizedUSBC || Program.acpi.DeviceGet(AsusACPI.ChargerMode) < AsusACPI.ChargerUSB);
}
public bool AutoGPUMode()
{
bool GpuAuto = AppConfig.Is("gpu_auto");
bool ForceGPU = AppConfig.ContainsModel("503");
int GpuMode = AppConfig.Get("gpu_mode");
if (!GpuAuto && !ForceGPU) return false;
int eco = Program.acpi.DeviceGet(AsusACPI.GPUEco);
int mux = Program.acpi.DeviceGet(AsusACPI.GPUMux);
if (mux == 0) // GPU in Ultimate, ignore
return false;
else
{
if (ReEnableGPU()) return true;
if (eco == 1)
if ((GpuAuto && IsPlugged()) || (ForceGPU && GpuMode == AsusACPI.GPUModeStandard))
{
SetGPUEco(0);
return true;
}
if (eco == 0)
if ((GpuAuto && !IsPlugged()) || (ForceGPU && GpuMode == AsusACPI.GPUModeEco))
{
if (HardwareControl.IsUsedGPU())
{
DialogResult dialogResult = MessageBox.Show(Properties.Strings.AlertDGPU, Properties.Strings.AlertDGPUTitle, MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.No) return false;
}
SetGPUEco(1);
return true;
}
}
return false;
}
public void RestartGPU(bool confirm = true)
{
if (HardwareControl.GpuControl is null) return;
if (!HardwareControl.GpuControl!.IsNvidia) return;
if (confirm)
{
DialogResult dialogResult = MessageBox.Show(Properties.Strings.RestartGPU, Properties.Strings.EcoMode, MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.No) return;
}
ProcessHelper.RunAsAdmin("gpurestart");
if (!ProcessHelper.IsUserAdministrator()) return;
Logger.WriteLine("Trying to restart dGPU");
Task.Run(async () =>
{
settings.LockGPUModes("Restarting GPU ...");
var nvControl = (NvidiaGpuControl)HardwareControl.GpuControl;
bool status = nvControl.RestartGPU();
settings.Invoke(delegate
{
//labelTipGPU.Text = status ? "GPU Restarted, you can try Eco mode again" : "Failed to restart GPU"; TODO
InitGPUMode();
});
});
}
public bool ReEnableGPU()
{
if (AppConfig.Get("gpu_reenable") != 1) return false;
if (Screen.AllScreens.Length <= 1) return false;
Logger.WriteLine("Re-enabling gpu for 503 model");
Thread.Sleep(1000);
SetGPUEco(1);
Thread.Sleep(1000);
SetGPUEco(0);
return true;
}
public void InitXGM()
{
bool connected = Program.acpi.IsXGConnected();
int activated = Program.acpi.DeviceGet(AsusACPI.GPUXG);
settings.VisualizeXGM(connected, activated == 1);
}
public void ToggleXGM()
{
Task.Run(async () =>
{
settings.LockGPUModes();
if (Program.acpi.DeviceGet(AsusACPI.GPUXG) == 1)
{
HardwareControl.KillGPUApps();
DialogResult dialogResult = MessageBox.Show("Did you close all applications running on XG Mobile?", "Disabling XG Mobile", MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.Yes)
{
Program.acpi.DeviceSet(AsusACPI.GPUXG, 0, "GPU XGM");
await Task.Delay(TimeSpan.FromSeconds(15));
}
}
else
{
Program.acpi.DeviceSet(AsusACPI.GPUXG, 1, "GPU XGM");
AsusUSB.ApplyXGMLight(AppConfig.Is("xmg_light"));
await Task.Delay(TimeSpan.FromSeconds(15));
if (AppConfig.IsMode("auto_apply"))
AsusUSB.SetXGMFan(AppConfig.GetFanConfig(AsusFan.XGM));
}
settings.Invoke(delegate
{
InitGPUMode();
});
});
}
public void KillGPUApps()
{
if (HardwareControl.GpuControl is not null)
{
HardwareControl.GpuControl.KillGPUApps();
}
}
}
}

11
app/Gpu/NvidiaGpuControl.cs → app/Gpu/NVidia/NvidiaGpuControl.cs
View File

@@ -1,4 +1,5 @@
using NvAPIWrapper.GPU;
using GHelper.Helpers;
using NvAPIWrapper.GPU;
using NvAPIWrapper.Native;
using NvAPIWrapper.Native.GPU;
using NvAPIWrapper.Native.GPU.Structures;
@@ -6,7 +7,7 @@ using NvAPIWrapper.Native.Interfaces.GPU;
using System.Diagnostics;
using static NvAPIWrapper.Native.GPU.Structures.PerformanceStates20InfoV1;
namespace GHelper.Gpu;
namespace GHelper.Gpu.NVidia;
public class NvidiaGpuControl : IGpuControl
{
@@ -126,8 +127,8 @@ public class NvidiaGpuControl : IGpuControl
public int SetClocksFromConfig()
{
int core = AppConfig.Get("gpu_core",0);
int memory = AppConfig.Get("gpu_memory",0);
int core = AppConfig.Get("gpu_core", 0);
int memory = AppConfig.Get("gpu_memory", 0);
int status = SetClocks(core, memory);
return status;
}
@@ -145,7 +146,7 @@ public class NvidiaGpuControl : IGpuControl
var voltageEntry = new PerformanceStates20BaseVoltageEntryV1(PerformanceVoltageDomain.Core, new PerformanceStates20ParameterDelta(voltage));
PerformanceStates20ClockEntryV1[] clocks = { coreClock, memoryClock };
PerformanceStates20BaseVoltageEntryV1[] voltages = { };
PerformanceStates20BaseVoltageEntryV1[] voltages = { };
PerformanceState20[] performanceStates = { new PerformanceState20(PerformanceStateId.P0_3DPerformance, clocks, voltages) };

0
app/Gpu/NvidiaSmi.cs → app/Gpu/NVidia/NvidiaSmi.cs
View File