Enum AccessClass 

pub enum AccessClass {
    HotRecurrentMicrodecoder,
    HotRecurrentTalker,
    HotCodecDecoder,
    ColdTextEmbedding,
    EnrollmentSpeakerEncoder,
    EnrollmentCodecEncoder,
    Metadata,
}

How the runtime touches a section. Drives the page-in policy.

Unknown values are refused rather than defaulted: a section whose access class we do not understand is one we cannot page correctly, and guessing “probably hot” for a 622 MB cold section is exactly the mistake that costs the microdecoder its cache residency.

Variants

HotRecurrentMicrodecoder

The ~110 MB microdecoder hot pack, reread 15× per frame.

HotRecurrentTalker

The ~440 MB talker body, read once per frame across 28 layers.

HotCodecDecoder

The codec decoder, read once per frame.

ColdTextEmbedding

The ~622 MB text embedding: lazy, row-granular, never paged in wholesale.

EnrollmentSpeakerEncoder

Speaker encoder, needed only during enrollment.

EnrollmentCodecEncoder

Codec encoder, needed only during enrollment.

Metadata

Config, manifests, and the license notice.

Implementations

impl AccessClass

pub const fn as_str(self) -> &'static str

The stable wire string.

Examples found in repository

examples/fttsq_census.rs (line 61)

fn main() {
    let path = std::env::args().nth(1).unwrap_or_else(|| {
        eprintln!("usage: fttsq_census <artifact.fttsq>");
        std::process::exit(2);
    });
    let mapped = match MappedFttsq::open(&path) {
        Ok(mapped) => mapped,
        Err(error) => {
            eprintln!("refusing census: {error}");
            std::process::exit(1);
        }
    };
    let reader = mapped.reader();
    let file_bytes = mapped.len() as u64;

    let mut class_bytes: BTreeMap<&str, u64> = BTreeMap::new();
    let mut sections_total = 0_u64;
    for section in reader.sections() {
        sections_total += section.length;
        *class_bytes
            .entry(section.access_class.as_str())
            .or_default() += section.length;
        row(
            "section",
            &[
                ("name", quoted(&section.name)),
                ("access_class", quoted(section.access_class.as_str())),
                ("bytes", section.length.to_string()),
                ("share_of_file", share(section.length, file_bytes)),
            ],
        );
    }

    // Dtype split inside each section: separates payload from quantization-scale overhead and
    // shows how much of a "quantized" section is still wide.
    let mut dtype_bytes: BTreeMap<(String, &str), u64> = BTreeMap::new();
    let mut scale_bytes: BTreeMap<String, u64> = BTreeMap::new();
    let scale_names: std::collections::BTreeSet<&str> = reader
        .tensors()
        .iter()
        .filter_map(|tensor| tensor.scales.as_deref())
        .collect();
    for tensor in reader.tensors() {
        *dtype_bytes
            .entry((tensor.section.clone(), tensor.dtype.as_str()))
            .or_default() += tensor.length;
        if scale_names.contains(tensor.name.as_str()) {
            *scale_bytes.entry(tensor.section.clone()).or_default() += tensor.length;
        }
    }
    for ((section, dtype), bytes) in &dtype_bytes {
        row(
            "section_dtype",
            &[
                ("section", quoted(section)),
                ("dtype", quoted(dtype)),
                ("bytes", bytes.to_string()),
                ("share_of_file", share(*bytes, file_bytes)),
            ],
        );
    }
    for (section, bytes) in &scale_bytes {
        row(
            "scale_overhead",
            &[
                ("section", quoted(section)),
                ("bytes", bytes.to_string()),
                ("share_of_file", share(*bytes, file_bytes)),
            ],
        );
    }

    for (class, bytes) in &class_bytes {
        row(
            "access_class",
            &[
                ("access_class", quoted(class)),
                ("bytes", bytes.to_string()),
                ("share_of_file", share(*bytes, file_bytes)),
            ],
        );
    }
    row(
        "total",
        &[
            ("file_bytes", file_bytes.to_string()),
            ("section_bytes", sections_total.to_string()),
            (
                "header_directory_bytes",
                (file_bytes - sections_total).to_string(),
            ),
            ("model_family", quoted(reader.model_family())),
        ],
    );
}

pub fn parse(text: &str) -> Option<Self>

Parses a wire string, refusing anything unrecognized.

pub const fn is_hot(self) -> bool

Whether this section should be resident during steady-state decode.

Consumed by the page-in policy: hot classes are advised resident, the cold embedding is explicitly not, and enrollment sections are only touched by the voice compiler.

pub const fn is_row_granular(self) -> bool

Whether the runtime must access this section row-granularly rather than as a unit.

impl AccessClass

pub const fn page_policy(self) -> PagePolicy

The page-in policy for this access class. Total, and the only place the mapping is defined.

Trait Implementations

impl Clone for AccessClass

fn clone(&self) -> AccessClass

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for AccessClass

impl Debug for AccessClass

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

Formats the value using the given formatter.

impl Display for AccessClass

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

Formats the value using the given formatter.

impl Eq for AccessClass

impl Ord for AccessClass

fn cmp(&self, other: &AccessClass) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for AccessClass

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for AccessClass

fn partial_cmp(&self, other: &AccessClass) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for AccessClass