set governor to "performance" if available (#2438)

* set governor to "performance" if available

* add linux-cpupower

* fix: Boolean blindness, thanks @dr-bones

---------

Co-authored-by: J H <2364004+Blu-J@users.noreply.github.com>

backend/src/init.rs

@@ -20,6 +20,9 @@ use crate::middleware::auth::LOCAL_AUTH_COOKIE_PATH;
 use crate::prelude::*;
 use crate::sound::BEP;
 use crate::system::time;
+use crate::util::cpupower::{
+    current_governor, get_available_governors, set_governor, GOVERNOR_PERFORMANCE,
+};
 use crate::util::docker::{create_bridge_network, CONTAINER_DATADIR, CONTAINER_TOOL};
 use crate::util::Invoke;
 use crate::{Error, ARCH};
@@ -341,6 +344,23 @@ pub async fn init(cfg: &RpcContextConfig) -> Result<InitResult, Error> {
         .await?;
     tracing::info!("Enabled Docker QEMU Emulation");
 
+    if current_governor()
+        .await?
+        .map(|g| &g != &GOVERNOR_PERFORMANCE)
+        .unwrap_or(false)
+    {
+        tracing::info!("Setting CPU Governor to \"{}\"", GOVERNOR_PERFORMANCE);
+        if get_available_governors()
+            .await?
+            .contains(&GOVERNOR_PERFORMANCE)
+        {
+            set_governor(&GOVERNOR_PERFORMANCE).await?;
+            tracing::info!("Set CPU Governor");
+        } else {
+            tracing::warn!("CPU Governor \"{}\" Not Available", GOVERNOR_PERFORMANCE)
+        }
+    }
+
     let mut warn_time_not_synced = true;
     for _ in 0..60 {
         if check_time_is_synchronized().await? {

backend/src/util/cpupower.rs

@@ -0,0 +1,125 @@
+use std::borrow::Cow;
+use std::collections::BTreeSet;
+
+use imbl::OrdMap;
+use tokio::process::Command;
+
+use crate::prelude::*;
+use crate::util::Invoke;
+
+pub const GOVERNOR_PERFORMANCE: Governor = Governor(Cow::Borrowed("performance"));
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Governor(Cow<'static, str>);
+impl std::fmt::Display for Governor {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.fmt(f)
+    }
+}
+impl std::ops::Deref for Governor {
+    type Target = str;
+    fn deref(&self) -> &Self::Target {
+        &*self.0
+    }
+}
+impl std::borrow::Borrow<str> for Governor {
+    fn borrow(&self) -> &str {
+        &**self
+    }
+}
+
+pub async fn get_available_governors() -> Result<BTreeSet<Governor>, Error> {
+    let raw = String::from_utf8(
+        Command::new("cpupower")
+            .arg("frequency-info")
+            .arg("-g")
+            .invoke(ErrorKind::CpuSettings)
+            .await?,
+    )?;
+    let mut for_cpu: OrdMap<u32, BTreeSet<Governor>> = OrdMap::new();
+    let mut current_cpu = None;
+    for line in raw.lines() {
+        if line.starts_with("analyzing") {
+            current_cpu = Some(
+                sscanf::sscanf!(line, "analyzing CPU {u32}:")
+                    .map_err(|e| eyre!("{e}"))
+                    .with_kind(ErrorKind::ParseSysInfo)?,
+            );
+        } else if let Some(rest) = line
+            .trim()
+            .strip_prefix("available cpufreq governors:")
+            .map(|s| s.trim())
+        {
+            if rest != "Not Available" {
+                for_cpu
+                    .entry(current_cpu.ok_or_else(|| {
+                        Error::new(
+                            eyre!("governors listed before cpu"),
+                            ErrorKind::ParseSysInfo,
+                        )
+                    })?)
+                    .or_default()
+                    .extend(
+                        rest.split_ascii_whitespace()
+                            .map(|g| Governor(Cow::Owned(g.to_owned()))),
+                    );
+            }
+        }
+    }
+    Ok(for_cpu
+        .into_iter()
+        .fold(None, |acc: Option<BTreeSet<Governor>>, (_, x)| {
+            if let Some(acc) = acc {
+                Some(acc.intersection(&x).cloned().collect())
+            } else {
+                Some(x)
+            }
+        })
+        .unwrap_or_default()) // include only governors available for ALL cpus
+}
+
+pub async fn current_governor() -> Result<Option<Governor>, Error> {
+    let Some(raw) = Command::new("cpupower")
+        .arg("frequency-info")
+        .arg("-p")
+        .invoke(ErrorKind::CpuSettings)
+        .await
+        .and_then(|s| Ok(Some(String::from_utf8(s)?)))
+        .or_else(|e| {
+            if e.source
+                .to_string()
+                .contains("Unable to determine current policy")
+            {
+                Ok(None)
+            } else {
+                Err(e)
+            }
+        })?
+    else {
+        return Ok(None);
+    };
+
+    for line in raw.lines() {
+        if let Some(governor) = line
+            .trim()
+            .strip_prefix("The governor \"")
+            .and_then(|s| s.strip_suffix("\" may decide which speed to use"))
+        {
+            return Ok(Some(Governor(Cow::Owned(governor.to_owned()))));
+        }
+    }
+    Err(Error::new(
+        eyre!("Failed to parse cpupower output:\n{raw}"),
+        ErrorKind::ParseSysInfo,
+    ))
+}
+
+pub async fn set_governor(governor: &Governor) -> Result<(), Error> {
+    Command::new("cpupower")
+        .arg("frequency-set")
+        .arg("-g")
+        .arg(&*governor.0)
+        .invoke(ErrorKind::CpuSettings)
+        .await?;
+    Ok(())
+}

backend/src/util/mod.rs

@@ -24,6 +24,7 @@ use tracing::instrument;
 use crate::shutdown::Shutdown;
 use crate::{Error, ErrorKind, ResultExt as _};
 pub mod config;
+pub mod cpupower;
 pub mod docker;
 pub mod http_reader;
 pub mod io;