Struct RuntimePlan 

pub struct RuntimePlan {
    pub default_policy: EdgePolicyKind,
    pub backpressure: BackpressureStrategy,
    pub lockfree_queues: bool,
    pub graph_metadata: BTreeMap<String, Value>,
    pub nodes: Vec<RuntimeNode>,
    pub edges: Vec<(NodeRef, String, NodeRef, String, EdgePolicyKind)>,
    pub gpu_segments: Vec<GpuSegment>,
    pub gpu_edges: Vec<EdgeBufferInfo>,
    pub gpu_entries: Vec<usize>,
    pub gpu_exits: Vec<usize>,
    pub segments: Vec<RuntimeSegment>,
    pub schedule_order: Vec<NodeRef>,
}

Final runtime plan, derived from planner output.

use daedalus_runtime::RuntimePlan;
use daedalus_planner::{ExecutionPlan, Graph};
let plan = RuntimePlan::from_execution(&ExecutionPlan::new(Graph::default(), vec![]));
assert!(plan.nodes.is_empty());

Fields

default_policy: EdgePolicyKind

backpressure: BackpressureStrategy

lockfree_queues: bool

Prefer lock-free bounded edge queues when available.

This is a runtime knob; it should not appear in serialized runtime plans.

graph_metadata: BTreeMap<String, Value>

Graph-level metadata (typed values) propagated into ExecutionContext.graph_metadata.

nodes: Vec<RuntimeNode>

edges: Vec<(NodeRef, String, NodeRef, String, EdgePolicyKind)>

gpu_segments: Vec<GpuSegment>

gpu_edges: Vec<EdgeBufferInfo>

gpu_entries: Vec<usize>

Edges that enter a GPU segment (CPU->GPU).

gpu_exits: Vec<usize>

Edges that leave a GPU segment to CPU consumers.

segments: Vec<RuntimeSegment>

schedule_order: Vec<NodeRef>

Implementations

impl RuntimePlan

pub fn from_execution(plan: &ExecutionPlan) -> Self

Convert a planner execution plan into a runtime plan.

Trait Implementations

impl Clone for RuntimePlan

fn clone(&self) -> RuntimePlan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RuntimePlan

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RuntimePlan

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RuntimePlan

fn eq(&self, other: &RuntimePlan) -> 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 RuntimePlan

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RuntimePlan