Struct Offload 

pub struct Offload {
    pub app: String,
    pub entrypoint: String,
    pub gpu: bool,
    pub cpu_time_ms: u64,
    pub memory_bytes: u64,
    pub output_bytes: u64,
}

How an offloadable action runs away from the device it was invoked on.

An offloadable action is a pure content transform: its inputs are content (files the invoker can read), its outputs are content, and the outputs are a function of the inputs alone, byte for byte, whichever device computes them. That is what lets the system run it on the invoker’s best-placed device — placed by the workspace’s relay, run as the signed package’s catalogue entrypoint under that device’s launcher sandbox — and hand back exactly what a local run returns. When no device is better placed, or the offload fails for any reason other than the action’s own, it runs locally.

The declaration names a package and entrypoint and bounds the work. It grants nothing: the worker reads only the inputs the invoker hands it, and is admitted by the same rules as any compute job.

Fields

app: String

The signed package whose catalogue entrypoint performs the transform.

entrypoint: String

The package’s catalogue (CLI) command that performs it.

gpu: bool

Whether it needs a GPU.

Encoded always, false or not: the declaration travels inside frames of formats that carry no field names or lengths, where a field skipped when absent is read out of the next field’s bytes.

cpu_time_ms: u64

memory_bytes: u64

Memory ceiling, in bytes. The inputs count against it.

output_bytes: u64

Ceiling on all outputs together, in bytes.

Implementations

impl Offload

pub fn validate(&self) -> Vec<String>

Why this declaration could never be placed as a compute job, if it could not.

Trait Implementations

impl Clone for Offload

fn clone(&self) -> Offload

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Offload

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Offload

fn deserialize<__D>( __deserializer: __D, ) -> Result<Offload, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Offload

fn eq(&self, other: &Offload) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Offload

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Offload

impl StructuralPartialEq for Offload