Struct SystemResourceTracker 

pub struct SystemResourceTracker { /* private fields */ }

System resource tracker backed by an injectable TelemetrySource (F12).

It previously returned hard-coded readings (32 GB memory / 16 GB used, 60% CPU, 4 GPUs at 80%, 1 TB disk, 1 GB/s network, 65 C, 250 W) from seven get_*_info helpers, each commented “in a real implementation, this would query system APIs”. Those numbers reached ResourceTracker::check_limits and were compared against the caller’s real constraints, so a tight memory budget aborted the search on invented data.

Now it reports whatever its source can actually measure and None for the rest, and check_limits skips any check whose measurement is missing.

Implementations

impl SystemResourceTracker

pub fn new(name: String, monitoring_interval: Duration) -> Self

Create a tracker using the default (honest, sparse) telemetry source.

pub fn with_telemetry( name: String, monitoring_interval: Duration, telemetry: Box<dyn TelemetrySource>, ) -> Self

Create a tracker backed by a caller-supplied telemetry source. This is how GPU / thermal / power constraints become enforceable: provide a source that can measure them.

pub fn telemetry_name(&self) -> &str

Name of the telemetry source in use.

pub fn last_sample(&self) -> Option<&TelemetrySample>

The most recent reading, if one has been taken.

pub fn sample(&self) -> TelemetrySample

Take a fresh reading.

pub fn memory_pressure(&self) -> Option<MemoryPressure>

Memory pressure derived from the current reading, or None when memory is not measurable here.

Trait Implementations

impl Debug for SystemResourceTracker

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

Formats the value using the given formatter.

impl<T> ResourceTracker<T> for SystemResourceTracker

where T: From<f64> + Debug + Float + Debug + Send + Sync + 'static,

fn get_current_usage(&self) -> Result<ResourceUsage<T>>

Resource usage attributable to this search.

Only the process’s own resident set size is reported, and only where it can be measured; everything else stays at the accumulator identity (0), which is honest for a usage total that nothing has been attributed to. The previous version reported system-wide invented figures here, which is a category error as well as a fabrication: ResourceUsage is compared against a budget for the search, so charging it for the whole machine aborts the search whenever the host is busy.

fn check_limits( &self, constraints: &ResourceConstraints<T>, ) -> Result<Vec<ResourceViolation<T>>>

Report only violations backed by an actual measurement (F12).

Every check is guarded by the presence of its measurement, so an unmeasurable resource is treated as unlimited and can never abort a search. This is the whole point: check_violations is called from NeuralArchitectureSearch::should_stop_search on every iteration, so a fabricated reading here terminated real searches.

fn get_system_metrics(&self) -> Result<SystemMetrics<T>>

Get system metrics

fn name(&self) -> &str

Get tracker name

fn initialize(&mut self) -> Result<()>

Initialize tracker

fn cleanup(&mut self) -> Result<()>

Cleanup tracker

fn telemetry_sample(&self) -> Option<TelemetrySample>

The raw telemetry reading behind ResourceTracker::get_system_metrics, if this tracker has one.