superfreq/watt/daemon.rs

use std::{
  cell::LazyCell,
  collections::{
    HashMap,
    VecDeque,
  },
  sync::{
    Arc,
    atomic::{
      AtomicBool,
      Ordering,
    },
  },
  thread,
  time::{
    Duration,
    Instant,
  },
};

use anyhow::Context;

use crate::{
  config,
  system,
};

/// Calculate the idle time multiplier based on system idle time.
///
/// Returns a multiplier between 1.0 and 5.0:
/// - For idle times < 2 minutes: Linear interpolation from 1.0 to 2.0
/// - For idle times >= 2 minutes: Logarithmic scaling (1.0 + log2(minutes))
fn idle_multiplier(idle_for: Duration) -> f64 {
  let factor = match idle_for.as_secs() < 120 {
    // Less than 2 minutes.
    // Linear interpolation from 1.0 (at 0s) to 2.0 (at 120s)
    true => (idle_for.as_secs() as f64) / 120.0,

    // 2 minutes or more.
    // Logarithmic scaling: 1.0 + log2(minutes)
    false => {
      let idle_minutes = idle_for.as_secs() as f64 / 60.0;
      idle_minutes.log2()
    },
  };

  // Clamp the multiplier to avoid excessive delays.
  (1.0 + factor).clamp(1.0, 5.0)
}

#[derive(Debug)]
struct Daemon {
  /// Last time when there was user activity.
  last_user_activity: Instant,

  /// The last computed polling delay.
  last_polling_delay: Option<Duration>,

  /// The system state.
  system: system::System,

  /// CPU usage and temperature log.
  cpu_log: VecDeque<CpuLog>,

  /// Power supply status log.
  power_supply_log: VecDeque<PowerSupplyLog>,
}

impl Daemon {
  fn rescan(&mut self) -> anyhow::Result<()> {
    self.system.rescan()?;

    log::debug!("appending daemon logs...");

    let at = Instant::now();

    while self.cpu_log.len() > 100 {
      log::debug!("daemon CPU log was too long, popping element");
      self.cpu_log.pop_front();
    }

    let cpu_log = CpuLog {
      at,

      usage: self
        .system
        .cpus
        .iter()
        .map(|cpu| cpu.stat.usage())
        .sum::<f64>()
        / self.system.cpus.len() as f64,

      temperature: self.system.cpu_temperatures.values().sum::<f64>()
        / self.system.cpu_temperatures.len() as f64,
    };
    log::debug!("appending CPU log item: {cpu_log:?}");
    self.cpu_log.push_back(cpu_log);

    while self.power_supply_log.len() > 100 {
      log::debug!("daemon power supply log was too long, popping element");
      self.power_supply_log.pop_front();
    }

    let power_supply_log = PowerSupplyLog {
      at,
      charge: {
        let (charge_sum, charge_nr) = self.system.power_supplies.iter().fold(
          (0.0, 0u32),
          |(sum, count), power_supply| {
            if let Some(charge_percent) = power_supply.charge_percent {
              (sum + charge_percent, count + 1)
            } else {
              (sum, count)
            }
          },
        );

        charge_sum / charge_nr as f64
      },
    };
    log::debug!("appending power supply log item: {power_supply_log:?}");
    self.power_supply_log.push_back(power_supply_log);

    Ok(())
  }
}

#[derive(Debug)]
struct CpuLog {
  at: Instant,

  /// CPU usage between 0-1, a percentage.
  usage: f64,

  /// CPU temperature in celsius.
  temperature: f64,
}

#[derive(Debug)]
struct CpuVolatility {
  usage: f64,

  temperature: f64,
}

impl Daemon {
  fn cpu_volatility(&self) -> Option<CpuVolatility> {
    let recent_log_count = self
      .cpu_log
      .iter()
      .rev()
      .take_while(|log| log.at.elapsed() < Duration::from_secs(5 * 60))
      .count();

    if recent_log_count < 2 {
      return None;
    }

    if self.cpu_log.len() < 2 {
      return None;
    }

    let change_count = self.cpu_log.len() - 1;

    let mut usage_change_sum = 0.0;
    let mut temperature_change_sum = 0.0;

    for index in 0..change_count {
      let usage_change =
        self.cpu_log[index + 1].usage - self.cpu_log[index].usage;
      usage_change_sum += usage_change.abs();

      let temperature_change =
        self.cpu_log[index + 1].temperature - self.cpu_log[index].temperature;
      temperature_change_sum += temperature_change.abs();
    }

    Some(CpuVolatility {
      usage:       usage_change_sum / change_count as f64,
      temperature: temperature_change_sum / change_count as f64,
    })
  }

  fn is_cpu_idle(&self) -> bool {
    let recent_log_count = self
      .cpu_log
      .iter()
      .rev()
      .take_while(|log| log.at.elapsed() < Duration::from_secs(5 * 60))
      .count();

    if recent_log_count < 2 {
      return false;
    }

    let recent_average = self
      .cpu_log
      .iter()
      .rev()
      .take(recent_log_count)
      .map(|log| log.usage)
      .sum::<f64>()
      / recent_log_count as f64;

    recent_average < 0.1
      && self
        .cpu_volatility()
        .is_none_or(|volatility| volatility.usage < 0.05)
  }
}

#[derive(Debug)]
struct PowerSupplyLog {
  at: Instant,

  /// Charge 0-1, as a percentage.
  charge: f64,
}

impl Daemon {
  fn discharging(&self) -> bool {
    self.system.power_supplies.iter().any(|power_supply| {
      power_supply.charge_state.as_deref() == Some("Discharging")
    })
  }

  /// Calculates the discharge rate, returns a number between 0 and 1.
  ///
  /// The discharge rate is averaged per hour.
  /// So a return value of Some(0.3) means the battery has been
  /// discharging 30% per hour.
  fn power_supply_discharge_rate(&self) -> Option<f64> {
    let mut last_charge = None;

    // A list of increasing charge percentages.
    let discharging: Vec<&PowerSupplyLog> = self
      .power_supply_log
      .iter()
      .rev()
      .take_while(move |log| {
        let Some(last_charge_value) = last_charge else {
          last_charge = Some(log.charge);
          return true;
        };

        last_charge = Some(log.charge);

        log.charge > last_charge_value
      })
      .collect();

    if discharging.len() < 2 {
      return None;
    }

    // Start of discharging. Has the most charge.
    let start = discharging.last().unwrap();
    // End of discharging, very close to now. Has the least charge.
    let end = discharging.first().unwrap();

    let discharging_duration_seconds = (start.at - end.at).as_secs_f64();
    let discharging_duration_hours = discharging_duration_seconds / 60.0 / 60.0;
    let discharged = start.charge - end.charge;

    Some(discharged / discharging_duration_hours)
  }
}

impl Daemon {
  fn polling_delay(&mut self) -> Duration {
    let mut delay = Duration::from_secs(5);

    // We are on battery, so we must be more conservative with our polling.
    if self.discharging() {
      match self.power_supply_discharge_rate() {
        Some(discharge_rate) => {
          if discharge_rate > 0.2 {
            delay *= 3;
          } else if discharge_rate > 0.1 {
            delay *= 2;
          } else {
            // *= 1.5;
            delay /= 2;
            delay *= 3;
          }
        },

        // If we can't determine the discharge rate, that means that
        // we were very recently started. Which is user activity.
        None => {
          delay *= 2;
        },
      }
    }

    if self.is_cpu_idle() {
      let idle_for = self.last_user_activity.elapsed();

      if idle_for > Duration::from_secs(30) {
        let factor = idle_multiplier(idle_for);

        log::debug!(
          "system has been idle for {seconds} seconds (approx {minutes} \
           minutes), applying idle factor: {factor:.2}x",
          seconds = idle_for.as_secs(),
          minutes = idle_for.as_secs() / 60,
        );

        delay = Duration::from_secs_f64(delay.as_secs_f64() * factor);
      }
    }

    if let Some(volatility) = self.cpu_volatility() {
      if volatility.usage > 0.1 || volatility.temperature > 0.02 {
        delay = (delay / 2).max(Duration::from_secs(1));
      }
    }

    let delay = match self.last_polling_delay {
      Some(last_delay) => {
        Duration::from_secs_f64(
          // 30% of current computed delay, 70% of last delay.
          delay.as_secs_f64() * 0.3 + last_delay.as_secs_f64() * 0.7,
        )
      },

      None => delay,
    };

    let delay = Duration::from_secs_f64(delay.as_secs_f64().clamp(1.0, 30.0));

    self.last_polling_delay = Some(delay);

    delay
  }
}

pub fn run(config: config::DaemonConfig) -> anyhow::Result<()> {
  assert!(config.rules.is_sorted_by_key(|rule| rule.priority));

  log::info!("starting daemon...");

  let cancelled = Arc::new(AtomicBool::new(false));

  log::debug!("setting ctrl-c handler...");
  let cancelled_ = Arc::clone(&cancelled);
  ctrlc::set_handler(move || {
    log::info!("received shutdown signal");
    cancelled_.store(true, Ordering::SeqCst);
  })
  .context("failed to set ctrl-c handler")?;

  let mut daemon = Daemon {
    last_user_activity: Instant::now(),

    last_polling_delay: None,

    system: system::System::new()?,

    cpu_log:          VecDeque::new(),
    power_supply_log: VecDeque::new(),
  };

  while !cancelled.load(Ordering::SeqCst) {
    daemon.rescan()?;

    let delay = daemon.polling_delay();
    log::info!(
      "next poll will be in {seconds} seconds or {minutes} minutes, possibly \
       delayed if application of rules takes more than the polling delay",
      seconds = delay.as_secs_f64(),
      minutes = delay.as_secs_f64() / 60.0,
    );

    log::debug!("filtering rules and applying them...");

    let start = Instant::now();

    let state = config::EvalState {
      cpu_usage:                   daemon.cpu_log.back().unwrap().usage,
      cpu_usage_volatility:        daemon.cpu_volatility().map(|vol| vol.usage),
      cpu_temperature:             daemon.cpu_log.back().unwrap().temperature,
      cpu_temperature_volatility:  daemon
        .cpu_volatility()
        .map(|vol| vol.temperature),
      cpu_idle_seconds:            daemon
        .last_user_activity
        .elapsed()
        .as_secs_f64(),
      power_supply_charge:         daemon
        .power_supply_log
        .back()
        .unwrap()
        .charge,
      power_supply_discharge_rate: daemon.power_supply_discharge_rate(),
      discharging:                 daemon.discharging(),
    };

    let mut cpu_delta_for = HashMap::<u32, config::CpuDelta>::new();
    let all_cpus =
      LazyCell::new(|| (0..num_cpus::get() as u32).collect::<Vec<_>>());

    for rule in &config.rules {
      let Some(condition) = rule.condition.eval(&state)? else {
        continue;
      };

      let cpu_for = rule.cpu.for_.as_ref().unwrap_or_else(|| &*all_cpus);

      for cpu in cpu_for {
        let delta = cpu_delta_for.entry(*cpu).or_default();

        delta.for_ = Some(vec![*cpu]);

        if let Some(governor) = rule.cpu.governor.as_ref() {
          delta.governor = Some(governor.clone());
        }

        if let Some(epp) = rule.cpu.energy_performance_preference.as_ref() {
          delta.energy_performance_preference = Some(epp.clone());
        }

        if let Some(epb) = rule.cpu.energy_performance_bias.as_ref() {
          delta.energy_performance_bias = Some(epb.clone());
        }

        if let Some(mhz_minimum) = rule.cpu.frequency_mhz_minimum {
          delta.frequency_mhz_minimum = Some(mhz_minimum);
        }

        if let Some(mhz_maximum) = rule.cpu.frequency_mhz_maximum {
          delta.frequency_mhz_maximum = Some(mhz_maximum);
        }

        if let Some(turbo) = rule.cpu.turbo {
          delta.turbo = Some(turbo);
        }
      }

      // TODO: Also merge this into one like CPU.
      if condition.as_boolean()? {
        rule.power.apply()?;
      }
    }

    for delta in cpu_delta_for.values() {
      delta.apply()?;
    }

    let elapsed = start.elapsed();
    log::info!(
      "filtered and applied rules in {seconds} seconds or {minutes} minutes",
      seconds = elapsed.as_secs_f64(),
      minutes = elapsed.as_secs_f64() / 60.0,
    );

    thread::sleep(delay.saturating_sub(elapsed));
  }

  log::info!("stopping polling loop and thus daemon...");

  Ok(())
}