Struct NodeCaps 

pub struct NodeCaps {
    pub addr: String,
    pub os: String,
    pub cores: usize,
    pub ram_total: u64,
    pub ram_avail: u64,
    pub disk_free: u64,
    pub devices: Vec<DeviceInfo>,
    pub gflops: f64,
    pub io_mbps: f64,
}

A node’s measured hardware profile.

Fields

addr: String

Address the coordinator reaches this node’s worker at (host:port).

os: String

OS string (macos, linux).

cores: usize

Logical CPU cores.

ram_total: u64

Total / currently-available host RAM (bytes).

ram_avail: u64

disk_free: u64

Free disk at the checkpoint location (bytes).

devices: Vec<DeviceInfo>

Compute devices, CPU first.

gflops: f64

Rough sustained matmul throughput (GFLOP/s, f32) from a micro-bench.

io_mbps: f64

Rough disk read throughput (MB/s) from a micro-bench (0 if not measured).

Implementations

impl NodeCaps

pub fn accel_mem(&self) -> u64

Best (non-CPU) accelerator memory ceiling, else host RAM — the largest a stage can occupy on this node’s device. A GPU that reports a positive mem_bytes (discrete VRAM, or an APU’s GTT / GPU-addressable system RAM) caps the stage even when it is “unified”: an amdgpu APU shares system RAM but the kernel bounds GPU access at GTT, so we must honor it. Devices with no meaningful ceiling (Apple Metal, mem_bytes == 0) fall through to RAM.

pub fn gflops_for(&self, dev: Device) -> f64

Measured throughput of dev specifically, falling back to the node’s headline figure when that device was not benched.

Costing a stage by Self::gflops — the node’s fastest device — is only right when the stage runs there, and it need not: the device is picked for its memory ceiling (or pinned by hand in the config). On an M4 Pro the CPU’s AMX benches ~1100 GFLOP/s against Metal’s ~540, so a node placed on Metal and costed on the headline is priced at twice the throughput it will deliver.

pub fn summary(&self) -> String

One-line summary for logs / the monitor table.

Trait Implementations

impl Clone for NodeCaps

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for NodeCaps

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NodeCaps

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for NodeCaps

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.