Struct ResolvedPlanningConfig 

pub struct ResolvedPlanningConfig { /* private fields */ }

Fully resolved planning configuration.

Examples

use tenferro_runtime::{
    Determinism, ExecutionPolicy, HardwareClassId, PrepareOptions, ResolvedPlanningConfig,
};

let policy = ExecutionPolicy::new(Determinism::Fast, Some(32), 5);
let config = ResolvedPlanningConfig::resolve(
    &policy,
    &PrepareOptions::new(),
    HardwareClassId::new("tenferro.cpu")?,
);
assert_eq!(config.hard_workspace_limit_bytes(), Some(32));

Implementations

impl ResolvedPlanningConfig

pub fn resolve( policy: &ExecutionPolicy, options: &PrepareOptions, hardware_class: HardwareClassId, ) -> Self

Resolve raw policy and per-call options into concrete planning config.

Examples

use tenferro_runtime::{
    Determinism, ExecutionPolicy, HardwareClassId, PrepareOptions, ResolvedPlanningConfig,
};

let policy = ExecutionPolicy::new(Determinism::Fast, Some(32), 5);
let options = PrepareOptions::new().with_hard_workspace_limit_bytes(Some(0));
let config = ResolvedPlanningConfig::resolve(
    &policy,
    &options,
    HardwareClassId::new("tenferro.cpu")?,
);
assert_eq!(config.hard_workspace_limit_bytes(), Some(0));

pub fn determinism(&self) -> Determinism

Return the resolved determinism mode.

Examples

use tenferro_runtime::{
    Determinism, ExecutionPolicy, HardwareClassId, PrepareOptions, ResolvedPlanningConfig,
};

let config = ResolvedPlanningConfig::resolve(
    &ExecutionPolicy::new(Determinism::Reproducible, None, 0),
    &PrepareOptions::new(),
    HardwareClassId::new("tenferro.cpu")?,
);
assert_eq!(config.determinism(), Determinism::Reproducible);

pub fn hard_workspace_limit_bytes(&self) -> Option<usize>

Return the resolved hard workspace limit.

Examples

use tenferro_runtime::{
    Determinism, ExecutionPolicy, HardwareClassId, PrepareOptions, ResolvedPlanningConfig,
};

let config = ResolvedPlanningConfig::resolve(
    &ExecutionPolicy::new(Determinism::Fast, Some(7), 0),
    &PrepareOptions::new(),
    HardwareClassId::new("tenferro.cpu")?,
);
assert_eq!(config.hard_workspace_limit_bytes(), Some(7));

pub fn planning_seed(&self) -> u64

Return the resolved planning seed.

Examples

use tenferro_runtime::{
    Determinism, ExecutionPolicy, HardwareClassId, PrepareOptions, ResolvedPlanningConfig,
};

let config = ResolvedPlanningConfig::resolve(
    &ExecutionPolicy::new(Determinism::Fast, None, 19),
    &PrepareOptions::new(),
    HardwareClassId::new("tenferro.cpu")?,
);
assert_eq!(config.planning_seed(), 19);

pub fn hardware_class(&self) -> &HardwareClassId

Return the resolved hardware class.

Examples

use tenferro_runtime::{
    Determinism, ExecutionPolicy, HardwareClassId, PrepareOptions, ResolvedPlanningConfig,
};

let hardware = HardwareClassId::new("tenferro.cpu")?;
let config = ResolvedPlanningConfig::resolve(
    &ExecutionPolicy::new(Determinism::Fast, None, 0),
    &PrepareOptions::new(),
    hardware.clone(),
);
assert_eq!(config.hardware_class(), &hardware);

Trait Implementations

impl Clone for ResolvedPlanningConfig

fn clone(&self) -> ResolvedPlanningConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResolvedPlanningConfig

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

Formats the value using the given formatter.

impl Hash for ResolvedPlanningConfig

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ResolvedPlanningConfig

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

impl StructuralPartialEq for ResolvedPlanningConfig