Struct ResourceAllocation 

pub struct ResourceAllocation {
    pub strategy: ResourceAllocationStrategy,
    pub budget: ResourceBudget,
    pub used_tokens: u64,
    pub used_time_ms: u64,
    pub used_cost_cents: f64,
    pub children_spawned: u32,
    pub current_depth: u32,
}

ResourceAllocation - Allocated resources for an execution @see packages/enact-schemas/src/execution.schemas.ts - resourceAllocationSchema

Fields

strategy: ResourceAllocationStrategy

Allocation strategy used

budget: ResourceBudget

Budget for this allocation

used_tokens: u64

Currently used tokens

used_time_ms: u64

Currently used time in milliseconds

used_cost_cents: f64

Currently used cost in cents

children_spawned: u32

Number of children spawned

current_depth: u32

Current discovery depth

Implementations

impl ResourceAllocation

pub fn new(strategy: ResourceAllocationStrategy, budget: ResourceBudget) -> Self

Create a new allocation with a budget

pub fn can_spawn_child(&self) -> bool

Check if we can spawn another child

pub fn can_discover_deeper(&self) -> bool

Check if we can go deeper in discovery

pub fn has_token_budget(&self, tokens: u64) -> bool

Check if we have token budget remaining

pub fn has_time_budget(&self, time_ms: u64) -> bool

Check if we have time budget remaining

pub fn record_tokens(&mut self, tokens: u64)

Record token usage

pub fn record_time(&mut self, time_ms: u64)

Record time usage

pub fn record_child_spawn(&mut self)

Record child spawn

pub fn increment_depth(&mut self)

Increment depth

pub fn child_allocation(&self) -> Self

Create a child allocation (for nested invocations)

Trait Implementations

impl Clone for ResourceAllocation

fn clone(&self) -> ResourceAllocation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResourceAllocation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ResourceAllocation

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ResourceAllocation

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

where __S: Serializer,

Serialize this value into the given Serde serializer.