Struct EngineConfig 

pub struct EngineConfig {

    pub schema_version: u32,
    pub model_name: String,
    pub system_name: String,
    pub systems_path: Option<PathBuf>,
    pub backend: BackendKind,
    pub backend_version: Option<String>,
    pub forward_model: Option<String>,
    pub kv_block_size: Option<u32>,
    pub parallel: ParallelMapping,
    pub quantization: QuantizationConfig,
    pub speculative: Option<SpeculativeConfig>,
    pub enable_shared_layer: Option<bool>,
    pub strict_provenance: bool,
    pub database_mode: DatabaseMode,
    pub tolerate_dirless_version: bool,
    pub transfer_policy: Option<Vec<String>>,
    pub extra: BTreeMap<String, String>,
}

Static engine identity and setup information carried by an crate::perfmodel::engine::spec::EngineSpec.

Cohesive multi-field groupings (parallel, quantization, speculative) are extracted into sub-structs but #[serde(flatten)]-ed so the wire JSON stays flat. Python (sdk/engine.py) emits a flat object with keys like tp_size, weight_dtype, nextn, which deserialize into the regrouped struct unchanged.

Fields

schema_version: u32

model_name: String

system_name: String

systems_path: Option<PathBuf>

Optional override for the bundled systems/ directory. None (the default) uses the resolution path baked into the build/env.

backend: BackendKind

backend_version: Option<String>

forward_model: Option<String>

Forward-pass modeling mode ("op_level" | "fpm"); None keeps Python’s default (op_level). Threaded to compile_engine so the FPM arena can select the whole-model engine through the supported predictor API (additive-optional: absent in older payloads).

kv_block_size: Option<u32>

parallel: ParallelMapping

quantization: QuantizationConfig

speculative: Option<SpeculativeConfig>

enable_shared_layer: Option<bool>

Shared-layer (sibling/cross-version) source inheritance on/off. The engine resolves per-op sources ITSELF (perf_database/source_resolution.rs — schema v13; the resolved perf_db_sources map left the wire with the Python resolver). None derives the flag from database_mode (SILICON/HYBRID = on), mirroring Python _shared_layer_enabled; Some carries an explicit override (Python’s shared_layer= kwarg, used by regression harnesses to pin per-version behavior).

strict_provenance: bool

Fail-closed provenance mode (Python’s strict_provenance / AIC_STRICT_PROVENANCE): malformed sidecar metadata errors the load instead of warn-and-continue. Absent on old specs -> false.

database_mode: DatabaseMode

Perf-database lookup mode (Python’s database._default_database_mode). SILICON queries collected tables only; HYBRID falls back to the util-space empirical layer on a typed silicon miss; EMPIRICAL always answers SOL/util. Absent on old specs -> Silicon (back-compat).

tolerate_dirless_version: bool

Directory-less next load (design §14). Set by the Python spec builder ONLY after it resolved the requested version to the fleet-advertised next slot and loaded it without a local version directory (every op rides channel-1 backward fill). Tells the engine reload to skip the missing-directory gate for THIS spec; raw-version and provenance gates are untouched, and native builders never set it (additive-optional: absent in older payloads -> false).

transfer_policy: Option<Vec<String>>

Enabled empirical transfer kinds as explicit tokens (xshape / xquant / xprofile / xop). Python resolves preset names before serialising, so no preset vocabulary exists on the wire. None = the default ALL-transfers policy (mirrors common.ALL_TRANSFERS).

extra: BTreeMap<String, String>

Trait Implementations

impl Clone for EngineConfig

fn clone(&self) -> EngineConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EngineConfig

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EngineConfig

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for EngineConfig

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for EngineConfig

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 EngineConfig