Again

src/engine/realtime.rs

@@ -0,0 +1,114 @@
+use std::sync::atomic::{AtomicBool, Ordering};
+
+static MLOCKALL_CALLED: AtomicBool = AtomicBool::new(false);
+static MLOCKALL_SUCCESS: AtomicBool = AtomicBool::new(false);
+
+/// Locks all current and future memory pages to prevent page faults during RT execution.
+/// Must be called BEFORE spawning any threads for maximum effectiveness.
+/// Returns true if mlockall succeeded, false otherwise (which is common without rtprio).
+#[cfg(unix)]
+pub fn lock_memory() -> bool {
+    if MLOCKALL_CALLED.swap(true, Ordering::SeqCst) {
+        return MLOCKALL_SUCCESS.load(Ordering::SeqCst);
+    }
+
+    let result = unsafe { libc::mlockall(libc::MCL_CURRENT | libc::MCL_FUTURE) };
+
+    if result == 0 {
+        MLOCKALL_SUCCESS.store(true, Ordering::SeqCst);
+        true
+    } else {
+        // Get the actual error for better diagnostics
+        let errno = std::io::Error::last_os_error();
+        eprintln!("[cagire] mlockall failed: {errno}");
+        eprintln!("[cagire] Memory locking disabled. For best RT performance on Linux:");
+        eprintln!("[cagire]   1. Add user to 'audio' group: sudo usermod -aG audio $USER");
+        eprintln!("[cagire]   2. Add to /etc/security/limits.conf:");
+        eprintln!("[cagire]      @audio   -  memlock    unlimited");
+        eprintln!("[cagire]   3. Log out and back in");
+        false
+    }
+}
+
+#[cfg(not(unix))]
+pub fn lock_memory() -> bool {
+    // Windows: VirtualLock exists but isn't typically needed for audio
+    true
+}
+
+/// Check if memory locking is active.
+#[allow(dead_code)]
+pub fn is_memory_locked() -> bool {
+    MLOCKALL_SUCCESS.load(Ordering::Relaxed)
+}
+
+/// Attempts to set realtime scheduling priority for the current thread.
+/// Returns true if RT priority was successfully set, false otherwise.
+///
+/// On Linux, this requires either:
+/// - CAP_SYS_NICE capability, or
+/// - Configured rtprio limits in /etc/security/limits.conf:
+///   @audio   -  rtprio     95
+///   @audio   -  memlock    unlimited
+#[cfg(unix)]
+pub fn set_realtime_priority() -> bool {
+    use thread_priority::unix::{
+        set_thread_priority_and_policy, thread_native_id, NormalThreadSchedulePolicy,
+        RealtimeThreadSchedulePolicy, ThreadSchedulePolicy,
+    };
+    use thread_priority::ThreadPriority;
+
+    let tid = thread_native_id();
+
+    // Try SCHED_FIFO first (requires CAP_SYS_NICE on Linux)
+    let fifo = ThreadSchedulePolicy::Realtime(RealtimeThreadSchedulePolicy::Fifo);
+    if set_thread_priority_and_policy(tid, ThreadPriority::Max, fifo).is_ok() {
+        return true;
+    }
+
+    // Try SCHED_RR (round-robin realtime, sometimes works without caps)
+    let rr = ThreadSchedulePolicy::Realtime(RealtimeThreadSchedulePolicy::RoundRobin);
+    if set_thread_priority_and_policy(tid, ThreadPriority::Max, rr).is_ok() {
+        return true;
+    }
+
+    // Fall back to highest normal priority (SCHED_OTHER)
+    let _ = set_thread_priority_and_policy(
+        tid,
+        ThreadPriority::Max,
+        ThreadSchedulePolicy::Normal(NormalThreadSchedulePolicy::Other),
+    );
+
+    // Also try nice -20 on Linux
+    #[cfg(target_os = "linux")]
+    unsafe {
+        libc::setpriority(libc::PRIO_PROCESS, 0, -20);
+    }
+
+    false
+}
+
+#[cfg(not(unix))]
+pub fn set_realtime_priority() -> bool {
+    use thread_priority::{set_current_thread_priority, ThreadPriority};
+    set_current_thread_priority(ThreadPriority::Max).is_ok()
+}
+
+/// High-precision sleep using clock_nanosleep on Linux.
+/// Uses monotonic clock for jitter-free sleeping.
+#[cfg(target_os = "linux")]
+pub fn precise_sleep_us(micros: u64) {
+    let duration_ns = micros * 1000;
+    let ts = libc::timespec {
+        tv_sec: (duration_ns / 1_000_000_000) as i64,
+        tv_nsec: (duration_ns % 1_000_000_000) as i64,
+    };
+    unsafe {
+        libc::clock_nanosleep(libc::CLOCK_MONOTONIC, 0, &ts, std::ptr::null_mut());
+    }
+}
+
+#[cfg(not(target_os = "linux"))]
+pub fn precise_sleep_us(micros: u64) {
+    std::thread::sleep(std::time::Duration::from_micros(micros));
+}