Struct Gpu3Config 

pub struct Gpu3Config {
    pub bound: ErrorBound,
    pub block: usize,
    pub block2d: usize,
    pub tile: usize,
    pub resctx: bool,
    pub rho: f64,
    pub lanes: usize,
    pub model: Model3,
    pub compact: bool,
    pub axis: bool,
    pub adapt: Option<AdCfg>,
}

v3 options.

Fields

bound: ErrorBound

Error target.

block: usize

Code-block edge for 3D data (in coefficients).

block2d: usize

Code-block edge for 2D data.

tile: usize

Outlier-tile edge (3D; 2D tiles are 4× this).

resctx: bool

Residual-based contexts.

rho: f64

Deadzone rounding offset.

lanes: usize

rANS lanes per code-block: 1 = raster order (best ratio); more splits a block’s lines into parity passes dealt to the lanes (more GPU parallelism, TCG1’s rule inside the block).

model: Model3

Coefficient probability model.

compact: bool

Compact lanes: a multi-lane block of v coefficients uses clamp(8·v·lanes / V, 1, lanes) lanes, V the full block volume (small coarse-level blocks stop paying lanes lanes of rANS framing, while no lane runs longer than 1/8 of a full block’s lane), and the last lane’s length is implied by the block size.

axis: bool

Axis-grouped line taps (crate::gpuwav::BandInfo::ax).

adapt: Option<AdCfg>

Per-lane adaptive probability maps over the learned model (crate::lmodel3::Adapt); ignored by static models.

Implementations

impl Gpu3Config

pub fn new(bound: ErrorBound) -> Self

Defaults: 32³ / 128² blocks, 64³ outlier tiles, residual contexts.

Examples found in repository

examples/gpubench.rs (line 44)

fn cfg3_of(bound: ErrorBound, bk: usize, args: &[String]) -> Gpu3Config {
    let m = opt(args, "--model3", "static");
    let model = if m == "static" {
        Model3::Static
    } else if let Some(h) = m.strip_prefix("overfit") {
        let hidden = h.strip_prefix(':').map_or(vec![16], |h| {
            h.split(',').map(|v| v.parse().unwrap()).collect()
        });
        Model3::Overfit {
            hidden,
            per_epoch: 200_000,
            epochs: 4,
        }
    } else if let Some(p) = m.strip_prefix("pretrained:") {
        let net = std::sync::Arc::new(
            cram_codec::learned::Net::from_bytes(&std::fs::read(p).expect("model")).expect("parse"),
        );
        cram_codec::learned::register(net.clone());
        Model3::Pretrained(net)
    } else {
        panic!("model3 {m}")
    };
    Gpu3Config {
        block: bk,
        block2d: bk,
        resctx: !args.iter().any(|a| a == "--nores"),
        lanes: opt(args, "--l3", "1").parse().unwrap(),
        compact: !args.iter().any(|a| a == "--nocompact"),
        axis: !args.iter().any(|a| a == "--noaxis"),
        model,
        ..Gpu3Config::new(bound)
    }
}

examples/pretrain3.rs (line 48)

fn main() {
    let args: Vec<String> = std::env::args().skip(1).collect();
    let out = &args[0];
    let hidden: Vec<usize> = opt(&args, "--hidden", "32,16")
        .split(',')
        .map(|v| v.parse().unwrap())
        .collect();
    let psnr: Vec<f64> = opt(&args, "--psnr", "40,50,60,70,80,90,100")
        .split(',')
        .map(|v| v.parse().unwrap())
        .collect();
    let lanes: usize = opt(&args, "--lanes", "8").parse().unwrap();
    let block: usize = opt(&args, "--block", "32").parse().unwrap();
    let per: usize = opt(&args, "--per", "100000").parse().unwrap();
    let epochs: usize = opt(&args, "--epochs", "8").parse().unwrap();
    let mut smp = Vec::new();
    for a in args.iter().filter(|a| a.contains(".f32:")) {
        let (path, d) = a.split_once(':').unwrap();
        let dims: Vec<usize> = d.split('x').map(|s| s.parse().unwrap()).collect();
        let b = std::fs::read(path).unwrap();
        let x: Vec<f32> = b
            .as_chunks::<4>()
            .0
            .iter()
            .map(|&c| f32::from_le_bytes(c))
            .collect();
        for &p in &psnr {
            let cfg = Gpu3Config {
                block,
                block2d: block * 4,
                lanes,
                ..Gpu3Config::new(ErrorBound::Psnr(p))
            };
            let s = samples3(&x, &dims, &cfg, 16, per);
            eprintln!("{path} {p} dB: {} samples", s.len());
            smp.extend(s);
        }
    }
    let tc = TrainConfig {
        hidden,
        epochs,
        per_epoch: 3_000_000,
        batch: 256,
        lr: 3e-3,
        apm: false,
        seed: 7,
    };
    let t = std::time::Instant::now();
    let net = train(&smp, &tc);
    eprintln!(
        "trained on {} samples in {:.1}s: {:.4} bits/sample (float view), {} params",
        smp.len(),
        t.elapsed().as_secs_f64(),
        mean_bits_float(&net, &smp),
        net.num_params()
    );
    std::fs::write(out, net.to_bytes()).unwrap();
}

examples/sweep3.rs (line 130)

fn main() {
    let args: Vec<String> = std::env::args().skip(1).collect();
    let root = std::path::PathBuf::from(&args[0]);
    let threads: usize = opt(&args, "--threads", "16").parse().unwrap();
    let lanes: usize = opt(&args, "--l3", "8").parse().unwrap();
    let m = opt(&args, "--model3", "static");
    let model = if m == "static" {
        Model3::Static
    } else if let Some(p) = m.strip_prefix("pretrained:") {
        let net = std::sync::Arc::new(
            cram_codec::learned::Net::from_bytes(&std::fs::read(p).expect("model")).expect("parse"),
        );
        cram_codec::learned::register(net.clone());
        Model3::Pretrained(net)
    } else {
        panic!("model3 {m}")
    };
    let mut fields: Vec<(String, std::path::PathBuf, Vec<usize>)> = ORIG
        .iter()
        .map(|n| {
            (
                n.to_string(),
                root.join(format!("out/{n}-64x128x128.f32")),
                vec![64, 128, 128],
            )
        })
        .collect();
    let man = std::fs::read_to_string(root.join("data/heldout/manifest.json")).unwrap();
    // minimal manifest parse: [{"name": "...", "shape": [..]}, ...]
    for obj in man.split('{').skip(1) {
        let name = obj
            .split("\"name\"")
            .nth(1)
            .unwrap()
            .split('"')
            .nth(1)
            .unwrap()
            .to_string();
        let sh = obj
            .split("\"shape\"")
            .nth(1)
            .unwrap()
            .split('[')
            .nth(1)
            .unwrap()
            .split(']')
            .next()
            .unwrap();
        let shape: Vec<usize> = sh.split(',').map(|v| v.trim().parse().unwrap()).collect();
        fields.push((
            name.clone(),
            root.join(format!("data/heldout/{name}.f32")),
            shape,
        ));
    }
    let only = opt(&args, "--only", "");
    let ser: std::collections::HashMap<(String, String), f64> =
        std::fs::read_to_string(root.join("out/gpu_ratio.jsonl"))
            .unwrap()
            .lines()
            .filter(|l| l.contains("\"tc-wavelet\""))
            .map(|l| {
                let g = |k: &str| {
                    l.split(&format!("\"{k}\":"))
                        .nth(1)
                        .unwrap()
                        .split([',', '}'])
                        .next()
                        .unwrap()
                        .trim()
                        .trim_matches('"')
                        .to_string()
                };
                (
                    (g("field").replace("-64x128x128", ""), g("target")),
                    g("bpv").parse().unwrap(),
                )
            })
            .collect();
    let mut acc: std::collections::HashMap<(String, String), Vec<f64>> = Default::default();
    for t in opt(&args, "--targets", "p80").split(',') {
        for (name, path, dims) in &fields {
            if !only.is_empty() && !only.split(',').any(|o| name.contains(o)) {
                continue;
            }
            let b = std::fs::read(path).unwrap();
            let x: Vec<f32> = b
                .as_chunks::<4>()
                .0
                .iter()
                .map(|&c| f32::from_le_bytes(c))
                .collect();
            let range = x.iter().fold(f32::NEG_INFINITY, |a, &b| a.max(b)) as f64
                - x.iter().fold(f32::INFINITY, |a, &b| a.min(b)) as f64;
            let bound = if let Some(p) = t.strip_prefix('p') {
                ErrorBound::Psnr(p.parse().unwrap())
            } else {
                ErrorBound::MaxAbs(t[1..].parse::<f64>().unwrap() * range)
            };
            let cfg = Gpu3Config {
                lanes,
                compact: !args.iter().any(|a| a == "--nocompact"),
                axis: !args.iter().any(|a| a == "--noaxis"),
                model: model.clone(),
                ..Gpu3Config::new(bound)
            };
            let (s, _) = gpuwav3::encode3_f32(&x, dims, &cfg, threads);
            let bpv = s.len() as f64 * 8.0 / x.len() as f64;
            let r = ser.get(&(name.clone(), t.to_string())).map(|sb| bpv / sb);
            println!(
                "{{\"field\": \"{name}\", \"target\": \"{t}\", \"bpv\": {bpv}, \"vs_serial\": {}}}",
                r.map_or("null".into(), |v| format!("{v:.4}"))
            );
            if let Some(r) = r {
                let g = if ORIG.contains(&name.as_str()) {
                    "orig"
                } else {
                    "held"
                };
                acc.entry((t.to_string(), "all".into()))
                    .or_default()
                    .push(r);
                acc.entry((t.to_string(), g.into())).or_default().push(r);
            }
        }
    }
    let mut keys: Vec<_> = acc.keys().cloned().collect();
    keys.sort();
    for k in keys {
        let v = &acc[&k];
        let gm = (v.iter().map(|x| x.ln()).sum::<f64>() / v.len() as f64).exp();
        println!("GEOMEAN {} {} n={} {:.4}", k.0, k.1, v.len(), gm);
    }
}

Trait Implementations

impl Clone for Gpu3Config

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Gpu3Config

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

Formats the value using the given formatter.