Add priority mode + always-on network packet priority
Priority mode (per-profile toggle, Audio profile tab, Alt+U): - Bundled PROCESS_POWER_THROTTLING_STATE with EXECUTION_SPEED and IGNORE_TIMER_RESOLUTION flags (keeps CPU at full clock + 1 ms quantum pinned regardless of OS idle decisions) - PowerSetRequest(EXECUTION_REQUIRED) + SetThreadExecutionState so the system can't decide we're idle and downclock - timeBeginPeriod(1) for 1 ms scheduler quantum - ProcessPriorityClass.High, ProcessMemoryPriority normal, working-set minimum locked via SetProcessWorkingSetSizeEx(HARDWS_MIN_ENABLE) - Fully reversed on toggle-off and on form close - Off by default (battery cost on laptops); explicit opt-in per profile MMCSS thread priority on hot threads bumped from High to Critical (network listener, mix loop, render thread) — always on. Network packet priority (always on, no toggle): - qWAVE flow on the outbound UDP socket at QOS_TRAFFIC_TYPE_VOICE with QOS_NON_ADAPTIVE_FLOW (Voice priority, DSCP 46/EF, WMM Voice on Wi-Fi) - Silent fallback if qwave.dll missing or QoS service disabled - Sender + receiver kernel UDP buffers bumped to 1 MB each (was 256 KB send / 512 KB receive) for resilience against ~30 ms stalls Bug fix: PreferencesDialog logging toggle no longer flags the profile as dirty. Logging is a machine-local AppConfig setting; the spurious ChangedAnyProfileSetting flag was triggering the unsaved-changes prompt on exit after toggling logs alone. Manual updated: new "Use CPU and Windows performance settings in high priority mode (Alt+U)" subsection on the Audio profile tab, new "Network packet priority (qWAVE / Voice / WMM)" subsection in the network chapter, Alt+U row added to keyboard-shortcuts table. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
Ednunp
co-authored by
Claude Opus 4.7
Claude Opus 4.7
parent
146e76c6e6
commit
768875cebb
@@ -0,0 +1,425 @@
|
||||
using System.Diagnostics;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace RemSound.App;
|
||||
|
||||
/// <summary>
|
||||
/// "Full CPU speed" mode for the current profile. When enabled, pulls every documented
|
||||
/// Windows lever to keep our process running at full clock — no EcoQoS downclocking, no
|
||||
/// migration to E-cores, no deep-C-state idling, 1 ms scheduler quantum, High priority
|
||||
/// class. All five mechanisms are per-process or per-thread: nothing affects other apps,
|
||||
/// and nothing here changes the system power plan (which is global) or anyone else's
|
||||
/// scheduling. Untoggling reverses every change cleanly.
|
||||
///
|
||||
/// Mechanisms layered on:
|
||||
/// <list type="number">
|
||||
/// <item><b>Process power throttling — opt out of EXECUTION_SPEED</b>. This is the
|
||||
/// main one. Tells Windows' scheduler "this is not a background process; don't
|
||||
/// downclock it, don't migrate its threads onto efficiency cores on hybrid CPUs".
|
||||
/// Without this, Windows aggressively saves power on processes it thinks are
|
||||
/// idle, which is the root cause of the "cold start sounds awful, warms up after
|
||||
/// a few seconds" behaviour the user reported. Same API Discord, Spotify, OBS
|
||||
/// and similar real-time apps use.</item>
|
||||
/// <item><b>PowerSetRequest(EXECUTION_REQUIRED)</b>. Tells the kernel the system as a
|
||||
/// whole can't enter deep low-power C-states while this process is active. Belt
|
||||
/// and braces with #1 — covers the case where #1 isn't honoured (very old build
|
||||
/// of Windows 10, some custom OEM image, etc.).</item>
|
||||
/// <item><b>Process priority class = High</b>. Standard for low-latency audio apps;
|
||||
/// bumps our dispatch priority above almost everything except OS internals. We
|
||||
/// deliberately do <i>not</i> use Realtime — that class can starve OS services
|
||||
/// (including the audio service itself) and is widely documented as causing
|
||||
/// worse audio behaviour, not better.</item>
|
||||
/// <item><b>timeBeginPeriod(1)</b>. Asks Windows for a 1 ms scheduler quantum. Helps
|
||||
/// any code path that does timer-based waiting. Since Windows 10 build 1803,
|
||||
/// this is scoped per-process — so we don't damage other apps' scheduling. We
|
||||
/// match every <c>timeBeginPeriod</c> with a <c>timeEndPeriod</c> when the
|
||||
/// feature is disabled, otherwise the OS keeps the elevated rate forever (the
|
||||
/// old global-period gotcha is long gone but we're tidy anyway).</item>
|
||||
/// <item><b>SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED)</b>. Older
|
||||
/// API but additive to #2; prevents the system from idle-sleeping. Negligible
|
||||
/// cost. ES_DISPLAY_REQUIRED is deliberately omitted — we don't need the
|
||||
/// screen on while we're running, just the CPU.</item>
|
||||
/// </list>
|
||||
///
|
||||
/// Trade-offs the user should know about:
|
||||
/// <list type="bullet">
|
||||
/// <item>Laptop on battery: faster drain while RemSound is open with this on. Worth
|
||||
/// the energy for a "live session" profile; not worth it for a "background
|
||||
/// listening" one. That's why this lives on the Profile, not on AppConfig.</item>
|
||||
/// <item>Desktop on mains: usually a couple of watts more, no practical downside.</item>
|
||||
/// </list>
|
||||
///
|
||||
/// Idempotent — calling <see cref="Apply"/> with the same value twice is a no-op. The
|
||||
/// internal state tracks the active power request handle so <see cref="Apply(bool, Action{string})"/>
|
||||
/// with <c>enable: false</c> releases every resource it acquired. Safe to call from the
|
||||
/// UI thread; none of the underlying API calls block in any meaningful sense.
|
||||
/// </summary>
|
||||
internal static class PerformanceMode
|
||||
{
|
||||
private static readonly object gate = new();
|
||||
private static bool currentlyEnabled;
|
||||
private static IntPtr powerRequestHandle = IntPtr.Zero;
|
||||
private static ProcessPriorityClass? priorityBeforeBoost;
|
||||
|
||||
/// <summary>Apply or reverse Full-CPU-speed mode. <paramref name="log"/> receives a
|
||||
/// short status line so the activation is visible in the diagnostic log file.
|
||||
/// Failures on individual mechanisms (e.g. an OEM image rejecting one of the Win32
|
||||
/// calls) are logged but don't abort the rest of the application of the mode.</summary>
|
||||
public static void Apply(bool enable, Action<string>? log = null)
|
||||
{
|
||||
lock (gate)
|
||||
{
|
||||
if (enable == currentlyEnabled)
|
||||
{
|
||||
log?.Invoke($"performance mode: already {(enable ? "on" : "off")}, no change");
|
||||
return;
|
||||
}
|
||||
|
||||
if (enable)
|
||||
{
|
||||
TrySetPowerThrottling(disable: true, log);
|
||||
TryStartPowerRequest(log);
|
||||
TryRaisePriority(log);
|
||||
TryBeginTimePeriod(log);
|
||||
TrySetThreadExecutionState(keepAwake: true, log);
|
||||
TrySetMemoryPriorityNormal(log);
|
||||
TryLockWorkingSetMin(log);
|
||||
currentlyEnabled = true;
|
||||
log?.Invoke("priority mode: ON (EcoQoS off, timer resolution honored, power-request set, priority High, 1 ms quantum, system-required, memory priority normal, working-set min locked)");
|
||||
}
|
||||
else
|
||||
{
|
||||
TrySetPowerThrottling(disable: false, log);
|
||||
TryStopPowerRequest(log);
|
||||
TryRestorePriority(log);
|
||||
TryEndTimePeriod(log);
|
||||
TrySetThreadExecutionState(keepAwake: false, log);
|
||||
TryRelaxWorkingSet(log);
|
||||
currentlyEnabled = false;
|
||||
log?.Invoke("priority mode: OFF (all overrides cleared, defaults restored)");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// === 1. Process power throttling (EcoQoS opt-out + timer-resolution honoring) ===
|
||||
|
||||
private static void TrySetPowerThrottling(bool disable, Action<string>? log)
|
||||
{
|
||||
try
|
||||
{
|
||||
// We control two flags at once:
|
||||
// * EXECUTION_SPEED — StateMask=0 means "don't throttle this process"
|
||||
// (no downclock, no E-core migration). The main lever.
|
||||
// * IGNORE_TIMER_RESOLUTION — StateMask=0 means "honour my
|
||||
// timeBeginPeriod request even if other apps don't want fine grain".
|
||||
// Pairs naturally with the timeBeginPeriod(1) call further down.
|
||||
// When we revert (disable=false) we set ControlMask=0, which hands both
|
||||
// flags back to Windows' system-default decision-making rather than
|
||||
// forcing them on.
|
||||
var state = new PROCESS_POWER_THROTTLING_STATE
|
||||
{
|
||||
Version = ProcessPowerThrottlingCurrentVersion,
|
||||
ControlMask = disable
|
||||
? (ProcessPowerThrottlingExecutionSpeed | ProcessPowerThrottlingIgnoreTimerResolution)
|
||||
: 0u,
|
||||
StateMask = 0u,
|
||||
};
|
||||
var ok = SetProcessInformation(GetCurrentProcess(), ProcessPowerThrottling,
|
||||
ref state, Marshal.SizeOf<PROCESS_POWER_THROTTLING_STATE>());
|
||||
if (!ok) log?.Invoke($"priority mode: SetProcessInformation(power throttling) failed (win32={Marshal.GetLastWin32Error()})");
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
log?.Invoke($"priority mode: power throttling threw: {ex.GetType().Name}: {ex.Message}");
|
||||
}
|
||||
}
|
||||
|
||||
// === 2. Kernel power request (no deep C-states) ===
|
||||
|
||||
private static void TryStartPowerRequest(Action<string>? log)
|
||||
{
|
||||
try
|
||||
{
|
||||
var ctx = new REASON_CONTEXT
|
||||
{
|
||||
Version = PowerRequestContextVersion,
|
||||
Flags = PowerRequestContextSimpleString,
|
||||
Reason = "RemSound is running with Full CPU speed enabled.",
|
||||
};
|
||||
var handle = PowerCreateRequest(ref ctx);
|
||||
if (handle == new IntPtr(-1))
|
||||
{
|
||||
log?.Invoke($"performance mode: PowerCreateRequest failed (win32={Marshal.GetLastWin32Error()})");
|
||||
return;
|
||||
}
|
||||
if (!PowerSetRequest(handle, PowerRequestExecutionRequired))
|
||||
{
|
||||
log?.Invoke($"performance mode: PowerSetRequest failed (win32={Marshal.GetLastWin32Error()})");
|
||||
CloseHandle(handle);
|
||||
return;
|
||||
}
|
||||
powerRequestHandle = handle;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
log?.Invoke($"performance mode: power request threw: {ex.GetType().Name}: {ex.Message}");
|
||||
}
|
||||
}
|
||||
|
||||
private static void TryStopPowerRequest(Action<string>? log)
|
||||
{
|
||||
if (powerRequestHandle == IntPtr.Zero) return;
|
||||
try
|
||||
{
|
||||
PowerClearRequest(powerRequestHandle, PowerRequestExecutionRequired);
|
||||
CloseHandle(powerRequestHandle);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
log?.Invoke($"performance mode: power-request release threw: {ex.GetType().Name}: {ex.Message}");
|
||||
}
|
||||
finally
|
||||
{
|
||||
powerRequestHandle = IntPtr.Zero;
|
||||
}
|
||||
}
|
||||
|
||||
// === 3. Process priority class ===
|
||||
|
||||
private static void TryRaisePriority(Action<string>? log)
|
||||
{
|
||||
try
|
||||
{
|
||||
using var proc = Process.GetCurrentProcess();
|
||||
priorityBeforeBoost = proc.PriorityClass;
|
||||
proc.PriorityClass = ProcessPriorityClass.High;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
log?.Invoke($"performance mode: priority raise threw: {ex.GetType().Name}: {ex.Message}");
|
||||
}
|
||||
}
|
||||
|
||||
private static void TryRestorePriority(Action<string>? log)
|
||||
{
|
||||
if (priorityBeforeBoost is null) return;
|
||||
try
|
||||
{
|
||||
using var proc = Process.GetCurrentProcess();
|
||||
proc.PriorityClass = priorityBeforeBoost.Value;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
log?.Invoke($"performance mode: priority restore threw: {ex.GetType().Name}: {ex.Message}");
|
||||
}
|
||||
finally
|
||||
{
|
||||
priorityBeforeBoost = null;
|
||||
}
|
||||
}
|
||||
|
||||
// === 4. timeBeginPeriod / timeEndPeriod ===
|
||||
|
||||
private static bool timePeriodActive;
|
||||
|
||||
private static void TryBeginTimePeriod(Action<string>? log)
|
||||
{
|
||||
if (timePeriodActive) return;
|
||||
try
|
||||
{
|
||||
if (timeBeginPeriod(1) == 0)
|
||||
{
|
||||
timePeriodActive = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
log?.Invoke("performance mode: timeBeginPeriod(1) failed");
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
log?.Invoke($"performance mode: timeBeginPeriod threw: {ex.GetType().Name}: {ex.Message}");
|
||||
}
|
||||
}
|
||||
|
||||
private static void TryEndTimePeriod(Action<string>? log)
|
||||
{
|
||||
if (!timePeriodActive) return;
|
||||
try
|
||||
{
|
||||
timeEndPeriod(1);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
log?.Invoke($"performance mode: timeEndPeriod threw: {ex.GetType().Name}: {ex.Message}");
|
||||
}
|
||||
finally
|
||||
{
|
||||
timePeriodActive = false;
|
||||
}
|
||||
}
|
||||
|
||||
// === 5. SetThreadExecutionState ===
|
||||
|
||||
private static void TrySetThreadExecutionState(bool keepAwake, Action<string>? log)
|
||||
{
|
||||
try
|
||||
{
|
||||
var flags = keepAwake
|
||||
? ES_CONTINUOUS | ES_SYSTEM_REQUIRED
|
||||
: ES_CONTINUOUS;
|
||||
var prev = SetThreadExecutionState(flags);
|
||||
if (prev == 0) log?.Invoke("priority mode: SetThreadExecutionState returned 0 (call rejected)");
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
log?.Invoke($"priority mode: SetThreadExecutionState threw: {ex.GetType().Name}: {ex.Message}");
|
||||
}
|
||||
}
|
||||
|
||||
// === 6. Process memory priority ===
|
||||
|
||||
// Setting our process's memory priority explicitly to NORMAL. The OS default is
|
||||
// already NORMAL (5), but Windows can demote "background-looking" processes
|
||||
// (especially after long idle periods or under memory pressure), and a demoted
|
||||
// process gets its working-set pages evicted first when the trimmer runs. This
|
||||
// call is a defensive assertion: "I am a foreground-class process, treat my
|
||||
// pages accordingly".
|
||||
private static void TrySetMemoryPriorityNormal(Action<string>? log)
|
||||
{
|
||||
try
|
||||
{
|
||||
var info = new MEMORY_PRIORITY_INFORMATION { MemoryPriority = MemoryPriorityNormal };
|
||||
var ok = SetProcessInformationMemory(GetCurrentProcess(), ProcessMemoryPriority,
|
||||
ref info, Marshal.SizeOf<MEMORY_PRIORITY_INFORMATION>());
|
||||
if (!ok) log?.Invoke($"priority mode: SetProcessInformation(memory) failed (win32={Marshal.GetLastWin32Error()})");
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
log?.Invoke($"priority mode: memory priority threw: {ex.GetType().Name}: {ex.Message}");
|
||||
}
|
||||
}
|
||||
|
||||
// === 7. Lock the minimum working-set size ===
|
||||
|
||||
// Windows trims a process's working set proactively when the machine looks idle.
|
||||
// For RemSound that's exactly the moment we'd rather it didn't — the first packet
|
||||
// after an idle stretch hits a cold cache and pages have to be brought back in,
|
||||
// which audibly stalls the first frames. Locking a minimum working set (32 MB —
|
||||
// enough for the JIT'd code + audio scratch buffers plus headroom for NAudio's
|
||||
// and the GC's reserves) tells Windows "you may not trim below this floor".
|
||||
// Released cleanly when priority mode is turned off.
|
||||
private const long MinWorkingSetBytes = 32L * 1024 * 1024;
|
||||
|
||||
private static void TryLockWorkingSetMin(Action<string>? log)
|
||||
{
|
||||
try
|
||||
{
|
||||
// dwMaximumWorkingSetSize = -1 means "leave unchanged".
|
||||
var min = (IntPtr)MinWorkingSetBytes;
|
||||
var maxUnchanged = (IntPtr)(-1);
|
||||
if (!SetProcessWorkingSetSizeEx(GetCurrentProcess(), min, maxUnchanged, QUOTA_LIMITS_HARDWS_MIN_ENABLE))
|
||||
{
|
||||
log?.Invoke($"priority mode: SetProcessWorkingSetSizeEx(lock) failed (win32={Marshal.GetLastWin32Error()})");
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
log?.Invoke($"priority mode: working-set lock threw: {ex.GetType().Name}: {ex.Message}");
|
||||
}
|
||||
}
|
||||
|
||||
private static void TryRelaxWorkingSet(Action<string>? log)
|
||||
{
|
||||
try
|
||||
{
|
||||
var unchanged = (IntPtr)(-1);
|
||||
if (!SetProcessWorkingSetSizeEx(GetCurrentProcess(), unchanged, unchanged, QUOTA_LIMITS_HARDWS_MIN_DISABLE))
|
||||
{
|
||||
log?.Invoke($"priority mode: SetProcessWorkingSetSizeEx(unlock) failed (win32={Marshal.GetLastWin32Error()})");
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
log?.Invoke($"priority mode: working-set unlock threw: {ex.GetType().Name}: {ex.Message}");
|
||||
}
|
||||
}
|
||||
|
||||
// === Native interop ===
|
||||
|
||||
private const int ProcessMemoryPriority = 0; // PROCESS_INFORMATION_CLASS.ProcessMemoryPriority
|
||||
private const int ProcessPowerThrottling = 4; // PROCESS_INFORMATION_CLASS.ProcessPowerThrottling
|
||||
private const uint ProcessPowerThrottlingCurrentVersion = 1;
|
||||
private const uint ProcessPowerThrottlingExecutionSpeed = 0x1;
|
||||
private const uint ProcessPowerThrottlingIgnoreTimerResolution = 0x4;
|
||||
private const int PowerRequestExecutionRequired = 3;
|
||||
private const uint PowerRequestContextVersion = 0;
|
||||
private const uint PowerRequestContextSimpleString = 0x1;
|
||||
private const uint ES_CONTINUOUS = 0x80000000;
|
||||
private const uint ES_SYSTEM_REQUIRED = 0x00000001;
|
||||
private const uint MemoryPriorityNormal = 5;
|
||||
private const int QUOTA_LIMITS_HARDWS_MIN_ENABLE = 0x1;
|
||||
private const int QUOTA_LIMITS_HARDWS_MIN_DISABLE = 0x2;
|
||||
|
||||
[StructLayout(LayoutKind.Sequential)]
|
||||
private struct PROCESS_POWER_THROTTLING_STATE
|
||||
{
|
||||
public uint Version;
|
||||
public uint ControlMask;
|
||||
public uint StateMask;
|
||||
}
|
||||
|
||||
[StructLayout(LayoutKind.Sequential)]
|
||||
private struct MEMORY_PRIORITY_INFORMATION
|
||||
{
|
||||
public uint MemoryPriority;
|
||||
}
|
||||
|
||||
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
|
||||
private struct REASON_CONTEXT
|
||||
{
|
||||
public uint Version;
|
||||
public uint Flags;
|
||||
[MarshalAs(UnmanagedType.LPWStr)]
|
||||
public string Reason;
|
||||
}
|
||||
|
||||
[DllImport("kernel32.dll", SetLastError = true)]
|
||||
private static extern IntPtr GetCurrentProcess();
|
||||
|
||||
[DllImport("kernel32.dll", SetLastError = true)]
|
||||
private static extern bool SetProcessInformation(IntPtr hProcess, int ProcessInformationClass,
|
||||
ref PROCESS_POWER_THROTTLING_STATE ProcessInformation, int ProcessInformationSize);
|
||||
|
||||
// Same kernel32 entry point as SetProcessInformation, but with a different struct type
|
||||
// in the ref parameter — declare a separate P/Invoke so the marshaller picks the right
|
||||
// signature without us needing to manually pin and StructureToPtr the buffer.
|
||||
[DllImport("kernel32.dll", SetLastError = true, EntryPoint = "SetProcessInformation")]
|
||||
private static extern bool SetProcessInformationMemory(IntPtr hProcess, int ProcessInformationClass,
|
||||
ref MEMORY_PRIORITY_INFORMATION ProcessInformation, int ProcessInformationSize);
|
||||
|
||||
[DllImport("kernel32.dll", SetLastError = true)]
|
||||
private static extern bool SetProcessWorkingSetSizeEx(IntPtr hProcess,
|
||||
IntPtr dwMinimumWorkingSetSize, IntPtr dwMaximumWorkingSetSize, int Flags);
|
||||
|
||||
[DllImport("kernel32.dll", SetLastError = true)]
|
||||
private static extern IntPtr PowerCreateRequest(ref REASON_CONTEXT Context);
|
||||
|
||||
[DllImport("kernel32.dll", SetLastError = true)]
|
||||
private static extern bool PowerSetRequest(IntPtr PowerRequest, int RequestType);
|
||||
|
||||
[DllImport("kernel32.dll", SetLastError = true)]
|
||||
private static extern bool PowerClearRequest(IntPtr PowerRequest, int RequestType);
|
||||
|
||||
[DllImport("kernel32.dll", SetLastError = true)]
|
||||
private static extern bool CloseHandle(IntPtr hObject);
|
||||
|
||||
[DllImport("winmm.dll")]
|
||||
private static extern uint timeBeginPeriod(uint uMilliseconds);
|
||||
|
||||
[DllImport("winmm.dll")]
|
||||
private static extern uint timeEndPeriod(uint uMilliseconds);
|
||||
|
||||
[DllImport("kernel32.dll", SetLastError = true)]
|
||||
private static extern uint SetThreadExecutionState(uint esFlags);
|
||||
}
|
||||
Reference in New Issue
Block a user