Struct ModelParallelContract 

pub struct ModelParallelContract {

    pub family: &'static str,
    pub variant: String,
    pub trunk_layers: usize,
    pub mtp_layers: usize,
    pub hidden_size: usize,
    pub vocab_size: usize,
    pub dense_ffn_size: usize,
    pub dense_prefix_layers: usize,
    pub head_dim: usize,
    pub query_heads: Vec<usize>,
    pub kv_heads: Vec<usize>,
    pub tensor_attention_supported: bool,
    pub expert_count: usize,
    pub experts_per_token: usize,
    pub expert_ffn_size: usize,
    pub shared_expert_ffn_size: usize,
    pub routed_layers: Vec<usize>,
    pub partition_boundaries: Vec<usize>,
    pub hardware_targets: Vec<HardwareTarget>,
}

Fields

family: &'static str

variant: String

trunk_layers: usize

mtp_layers: usize

hidden_size: usize

vocab_size: usize

dense_ffn_size: usize

dense_prefix_layers: usize

head_dim: usize

query_heads: Vec<usize>

kv_heads: Vec<usize>

tensor_attention_supported: bool

True when every layer exposes a Full/Sliding attention geometry that the generic TP planner can shard. Expert-only EP does not require this.

expert_count: usize

experts_per_token: usize

expert_ffn_size: usize

shared_expert_ffn_size: usize

routed_layers: Vec<usize>

Trunk layer indices whose ModelPlan MLP is routed MoE. This is the automatic EP scope.

partition_boundaries: Vec<usize>

hardware_targets: Vec<HardwareTarget>

Implementations

impl ModelParallelContract

pub fn from_model(cfg: &ModelConfig) -> Result<Self, TopologyError>

Build the structural contract from the canonical operation plan. Unsupported operations refuse during ModelPlan compilation; family names do not select placement.

pub fn plan( &self, request: TopologyRequest, ) -> Result<ParallelPlan, TopologyError>

pub fn plan_grouped( &self, request: GroupedTopologyRequest, ) -> Result<GroupedParallelPlan, TopologyError>

Plan an explicit sequence of PP stages whose TP/EP widths may differ.

This is the placement contract for arbitrary 1-8 card counts. It validates only the layers assigned to each group, so a TP1 dense-prefix stage can coexist with a TP2/TP4/TP8 MoE stage. Logical ranks are contiguous per stage; physical-device binding is a separate runtime concern and must preserve each group’s rank order.

Trait Implementations

impl Clone for ModelParallelContract

fn clone(&self) -> ModelParallelContract

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ModelParallelContract

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

Formats the value using the given formatter.

impl Eq for ModelParallelContract

impl PartialEq for ModelParallelContract

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ModelParallelContract