Struct Executor 

pub struct Executor<'a, H: NodeHandler> { /* private fields */ }

Runtime executor for planner-generated runtime plans.

use daedalus_runtime::executor::Executor;
use daedalus_planner::{ExecutionPlan, Graph};
use daedalus_runtime::RuntimePlan;

fn handler(
    _node: &daedalus_runtime::RuntimeNode,
    _ctx: &daedalus_runtime::state::ExecutionContext,
    _io: &mut daedalus_runtime::io::NodeIo,
) -> Result<(), daedalus_runtime::executor::NodeError> {
    Ok(())
}

let plan = RuntimePlan::from_execution(&ExecutionPlan::new(Graph::default(), vec![]));
let _exec = Executor::new(&plan, handler);

Implementations

impl<'a, H: NodeHandler> Executor<'a, H>

pub fn new(plan: &'a RuntimePlan, handler: H) -> Self

Build an executor from a runtime plan and handler.

pub fn with_const_coercers(self, coercers: ConstCoercerMap) -> Self

Provide a shared constant coercer registry (used by dynamic plugins).

pub fn with_output_movers(self, movers: OutputMoverMap) -> Self

Provide a shared output mover registry (used by dynamic plugins).

pub fn with_state(self, state: StateStore) -> Self

Inject shared state store (optional).

pub fn without_gpu(self) -> Self

pub fn with_pool_size(self, size: Option<usize>) -> Self

Override pool size when using the pool-based parallel executor.

pub fn with_metrics_level(self, level: MetricsLevel) -> Self

pub fn with_host_bridges(self, mgr: HostBridgeManager) -> Self

Attach a host bridge manager to enable implicit host I/O nodes.

pub fn reset(&mut self)

Reset per-run state (queues, telemetry, warnings) so this executor can be reused.

pub fn run(self) -> Result<ExecutionTelemetry, ExecuteError>

Execute the runtime plan serially in segment order.

pub fn run_in_place(&mut self) -> Result<ExecutionTelemetry, ExecuteError>

Execute the runtime plan serially without rebuilding the executor.

pub fn run_parallel(self) -> Result<ExecutionTelemetry, ExecuteError>

where H: Send + Sync + 'static,

Execute the runtime plan allowing independent segments to run in parallel.

pub fn run_parallel_in_place( &mut self, ) -> Result<ExecutionTelemetry, ExecuteError>

where H: Send + Sync + 'static,

Execute the runtime plan in parallel without rebuilding the executor.