+#![feature(

+ generic_arg_infer,

+ import_trait_associated_functions,

+ string_deref_patterns,

+ deref_patterns,

+ let_chains,

+ iter_array_chunks,

+ array_chunks,

+ generic_const_exprs,

+ portable_simd,

+ iter_chain

+)]

+use anyhow::*;

+use collar::CollectArray as _;

+use comat::cwrite;

+use grapher::Grapher;

+use parking_lot::Mutex;

+use std::array;

+use std::ffi::{c_char, CStr};

+use std::fmt::Display;

+use std::fs::{read_dir, read_to_string as read};

+use std::io::{stdout, Read};

+use std::io::{BufRead, BufReader, Write};

+use std::process::{Command, Stdio};

+use std::thread::sleep;

+use std::time::Duration;

+use termion::color::*;

+use termion::cursor::Hide;

+use termion::raw::IntoRawMode;

+use termion::screen::IntoAlternateScreen;

+use termion::{async_stdin, clear, cursor, style};

+

+#[repr(C)]

+#[derive(Default)]

+struct igt_devices_print_format {

+ ty: u32,

+ option: u32,

+ numeric: bool,

+ codename: bool,

+}

+#[repr(C)]

+struct strong<const N: usize>([c_char; N]);

+impl<const N: usize> Default for strong<N> {

+ fn default() -> Self {

+ Self([0; N])

+ }

+}

+impl<const N: usize> Display for strong<N> {

+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

+ write!(f, "{}", unsafe {

+ CStr::from_ptr(self.0.as_ptr()).to_str().unwrap()

+ })

+ }

+}

+

+#[repr(C)]

+#[derive(Default)]

+struct igt_device_card {

+ subsystem: strong<256>,

+ card: strong<256>,

+ render: strong<256>,

+ pci_slot_name: strong<13>,

+ pci_vendor: u16,

+ pci_device: u16,

+}

+

+unsafe extern "C" {

+ fn igt_devices_scan();

+ fn igt_devices_print(opts: *const igt_devices_print_format);

+ fn igt_device_find_integrated_card(card: *mut igt_device_card) -> bool;

+ fn igt_device_get_pretty_name(card: *const igt_device_card, numeric: bool) -> *const c_char;

+

+}

+

+fn uh() -> Result<()> {

+ dbg!("???");

+ let x = std::fs::read_dir("/sys/devices")?

+ .filter_map(Result::ok)

+ .filter(|x| {

+ x.file_name()

+ .into_string()

+ .is_ok_and(|x| x.starts_with("pci"))

+ })

+ .filter_map(|x| read_dir(x.path()).ok())

+ .flatten()

+ .filter_map(Result::ok)

+ .find(|x| read(x.path().join("uevent")).is_ok_and(|x| x.contains("i915")))

+ .ok_or(anyhow!("intelless"))?

+ .path();

+

+ // println!("{:?}", x.location().unwrap());

+ let pciid = read(x.join("uevent"))

+ .unwrap()

+ .lines()

+ .find(|x| x.starts_with("PCI_ID"))

+ .ok_or(anyhow!("eh"))?

+ .split_once("=")

+ .unwrap()

+ .1

+ .split_once(":")

+ .unwrap()

+ .1

+ .to_lowercase();

+

+ let name = read("/usr/share/hwdata/pci.ids")?

+ .lines()

+ .filter(|x| x.starts_with('\t'))

+ .find(|x| x[1..].starts_with(&pciid))

+ .map(|x| x[1 + pciid.len()..].trim().to_string())

+ .unwrap();

+ dbg!(name);

+ Ok(())

+}

+fn main() -> Result<()> {

+ use atools::Join;

+

+ let mut c = Command::new("intel_gpu_top")

+ .args(["-s", "100", "-c"])

+ .stdout(Stdio::piped())

+ .stdin(Stdio::inherit())

+ .spawn()?;

+ let r = c.stdout.take().unwrap();

+ static last: Mutex<[f64; 7]> = Mutex::new([f64::NAN; _]);

+ std::thread::spawn(move || {

+ // Freq MHz req,Freq MHz act,IRQ /s,RC6 %,Power W gpu,Power W pkg,RCS %,RCS se,RCS wa,BCS %,BCS se,BCS wa,VCS %,VCS se,VCS wa,VECS %,VECS se,VECS wa

+ for line in BufReader::new(r).lines().skip(1) {

+ let line = line.unwrap();

+ let mut splat = line.split(",").map(|x| x.parse::<f64>().unwrap());

+ let x = splat.collect_array::<6>();

+ let busy = splat.array_chunks::<3>().map(|x| x[0]).sum::<f64>();

+ *last.lock() = x.join(busy / 100.);

+ }

+ });

+

+ // [f_req, f_act, irq, rc6, power_gpu, power_package, busy]

+ unsafe { igt_devices_scan() };

+ let mut card = igt_device_card::default();

+ let ret = unsafe { igt_device_find_integrated_card(&mut card) };

+ if !ret {

+ bail!("igpuless!! (i dont have an arc gpu it should be simple to add that tho)")

+ }

+ let name = unsafe {

+ CStr::from_ptr(igt_device_get_pretty_name(&card, false))

+ .to_str()

+ .unwrap()

+ };

+

+ fn inter([a, b, c]: [f32; 3], [d, e, f]: [f32; 3], fc: f32) -> [f32; 3] {

+ [a + (d - a) * fc, b + (e - b) * fc, c + (f - c) * fc]

+ }

+

+ let mut g = Grapher::new()?;

+ sleep(Duration::from_secs_f32(0.5));

+ if let std::result::Result::Ok(Some(_)) = c.try_wait() {

+ return Ok(());

+ }

+ let d = 0.1;

+ let mut stdout = stdout().into_raw_mode()?.into_alternate_screen()?;

+ let mut stdin = async_stdin();

+ write!(stdout, "{}{}{}", Hide, clear::All, style::Reset).unwrap();

+ 'out: loop {

+ if let std::result::Result::Ok(Some(_)) = c.try_wait() {

+ return Ok(());

+ }

+ let (_, h) = termion::terminal_size()?;

+

+ let mut key = 0;

+ while stdin.read(array::from_mut(&mut key)).unwrap() != 0 {

+ match key {

+ b'q' => break 'out,

+

+ _ => (),

+ }

+ }

+

+ g.draw(|y| {

+ Some(

+ inter(

+ [243, 64, 64].map(|x| x as f32 / 255.0), // red

+ [228, 197, 63].map(|x| x as f32 / 255.0), // yellow

+ y as f32 / (h - 1) as f32,

+ )

+ .map(|x| (x * 255.0) as u8),

+ )

+ })?;

+

+ write!(g.buffer, "{}{}", White.fg_str(), cursor::Goto(1, 1))?;

+ let [f_req, f_act, irq, _rc6, power_gpu, power_package, busy] = *last.lock();

+ cwrite!(

+ g.buffer,

+ " {name} @ {f_req:.0}/ {f_act:.0} MHz ─── {power_gpu:.1}/ {power_package:.1} W ─── {irq:.0} irqs/s"

+ )?;

+ stdout.write_all(&g.buffer)?;

+ stdout.flush()?;

+

+ sleep(Duration::from_secs_f32(d));

+ g.push_point(busy);

+ }

+ println!("\x1B[?7l");

+ Ok(())

+}