#![allow(clippy::expect_used, clippy::unwrap_used, clippy::panic)]
mod common;
use common::rng::{open_unit, seeded_rng};
use gprx::Adam;
use gprx::kernel::{
ArdDistance, ConstantKernel, DistanceSource, KernelSpec, RbfArdKernel, RbfKernel,
ScalarDistance,
};
use gprx::{
DoublePrecision, FittedGpr, Fixed, GaussianLikelihood, GpScalar, Gpr, GprError, KernelExp,
MixedPrecision, Prediction, ReevaluateKernel, Sgpr, SinglePrecision, Svgp,
};
use stats_alloc::{INSTRUMENTED_SYSTEM, Region, StatsAlloc};
use std::alloc::System;
use std::num::{NonZeroU64, NonZeroUsize};
use std::process::ExitCode;
use std::sync::{Mutex, OnceLock};
#[global_allocator]
static GLOBAL: &StatsAlloc<System> = &INSTRUMENTED_SYSTEM;
const N: usize = 256;
const D: usize = 8;
const M: usize = 100;
const SEED: u64 = 0;
const ELL: f64 = 1.0;
const NOISE: f64 = 0.1;
const MAX_MLL_AND_GRAD_ALLOCS: usize = 0;
const MAX_LEAF_STEP_ALLOCS: usize = 0;
const MAX_COMPOSITE_MLL_AND_GRAD_ALLOCS: [(&str, usize); 6] = [
("sum_with_ard", 0),
("product", 0),
("ard", 0),
("sum", 0),
("nested", 0),
("nested_mixed", 0),
];
const MAX_HESSIAN_ALLOCS: [(&str, usize); 7] = [
("rbf", 0),
("sum_with_ard", 0),
("product", 0),
("ard", 0),
("sum", 0),
("nested", 0),
("nested_mixed", 0),
];
const N_HESSIAN: usize = 32;
const MAX_COMPOSITE_PREDICT_100_ALLOCS: [(&str, usize); 6] = [
("sum_with_ard", 0),
("product", 0),
("ard", 0),
("sum", 0),
("nested", 0),
("nested_mixed", 0),
];
const MAX_PREDICT_100_ALLOCS: usize = 0;
const MAX_MIXED_PREDICT_100_BYTES: usize = N * N * std::mem::size_of::<f32>();
const M_SPARSE: usize = 32;
const MAX_SPARSE_ALLOCS: [(&str, usize); 5] = [
("sgpr_mll_and_grad", 12),
("sgpr_hessian", 109),
("online_sgpr_insert", 8),
("online_sgpr_insert_nested", 16),
("svgp_mll_and_grad", 16),
];
const MAX_SPARSE_PREDICT_100_ALLOCS: usize = 0;
const MAX_SVGP_MIXED_PREDICT_100_BYTES: usize = M * 3 * M_SPARSE * std::mem::size_of::<f64>();
fn ensure_one_rayon_worker() {
static INIT: OnceLock<()> = OnceLock::new();
INIT.get_or_init(|| {
unsafe {
std::env::set_var("RAYON_NUM_THREADS", "1");
}
});
}
fn fill_column_major(n: usize, d: usize, seed: u64) -> Vec<f64> {
let mut rng = seeded_rng(seed);
let mut x = vec![0.0; n * d];
for col in 0..d {
for row in 0..n {
x[col * n + row] = open_unit(&mut rng);
}
}
x
}
fn fitted_model() -> Result<(FittedGpr<Fixed>, Vec<f64>), GprError> {
ensure_one_rayon_worker();
let kernel = KernelSpec::from(RbfKernel::new(ELL)?);
let likelihood = GaussianLikelihood::new(NOISE)?;
let x = fill_column_major(N, D, SEED);
let mut rng = seeded_rng(SEED ^ 0xA5A5_A5A5_A5A5_A5A5);
let y: Vec<f64> = (0..N).map(|_| open_unit(&mut rng)).collect();
let gpr = Gpr::new(kernel, likelihood)
.with_optimizer(Fixed)
.factor(&x, N, D, &y)?;
let xs = fill_column_major(M, D, SEED.wrapping_add(1));
Ok((gpr, xs))
}
fn allocs_in(f: impl FnMut()) -> usize {
allocs_once(f)
}
fn allocs_once(f: impl FnOnce()) -> usize {
let region = Region::new(GLOBAL);
f();
let stats = region.change();
stats.allocations + stats.reallocations
}
fn assert_alloc_cap(label: &str, count: usize, cap: usize) {
eprintln!("{label}: allocations={count} cap={cap}");
assert!(
count <= cap,
"{label}: allocations={count}, cap={cap}; lower the cap when allocs drop, do not raise it without an Issue"
);
}
fn mll_and_grad_allocs_after_workspace() {
let (mut gpr, _) = fitted_model().expect("spd");
let mut params = vec![0.0; gpr.num_params()];
gpr.get_params(&mut params).expect("len");
let mut grad = vec![0.0; params.len()];
gpr.value_and_gradient_into(¶ms, &mut grad)
.expect("warmup");
let count = allocs_in(|| {
gpr.value_and_gradient_into(¶ms, &mut grad)
.expect("counted");
});
assert_alloc_cap("mll_and_grad", count, MAX_MLL_AND_GRAD_ALLOCS);
}
fn fast_approx_mll_and_grad_allocs_after_workspace() {
ensure_one_rayon_worker();
let kernel = KernelSpec::from(RbfKernel::new(ELL).expect("ell"));
let likelihood = GaussianLikelihood::new(NOISE).expect("noise");
let x = fill_column_major(N, D, SEED);
let mut rng = seeded_rng(SEED ^ 0xA5A5_A5A5_A5A5_A5A5);
let y: Vec<f64> = (0..N).map(|_| open_unit(&mut rng)).collect();
let mut gpr = Gpr::new(kernel, likelihood)
.with_math(KernelExp::FastApprox)
.with_optimizer(Fixed)
.factor(&x, N, D, &y)
.expect("spd");
let mut params = vec![0.0; gpr.num_params()];
gpr.get_params(&mut params).expect("len");
let mut grad = vec![0.0; params.len()];
gpr.value_and_gradient_into(¶ms, &mut grad)
.expect("warmup");
let count = allocs_in(|| {
gpr.value_and_gradient_into(¶ms, &mut grad)
.expect("counted");
});
assert_alloc_cap("fast_mll_and_grad", count, MAX_MLL_AND_GRAD_ALLOCS);
let _typed: FittedGpr<Fixed> = gpr;
}
fn predict_100_allocs_after_workspace() {
let (mut gpr, xs) = fitted_model().expect("spd");
let mut pred = Prediction::default();
gpr.predict_into(&xs, M, D, &mut pred).expect("warmup");
let count = allocs_in(|| {
gpr.predict_into(&xs, M, D, &mut pred).expect("counted");
});
assert_alloc_cap("predict_100", count, MAX_PREDICT_100_ALLOCS);
}
type MixedFitted<R> = FittedGpr<Fixed, MixedPrecision<R>>;
fn fitted_mixed<R>() -> Result<(MixedFitted<R>, Vec<f64>), GprError>
where
MixedPrecision<R>: gprx::GpScalar,
R: gprx::ResidualFormula,
{
ensure_one_rayon_worker();
let kernel = KernelSpec::from(RbfKernel::new(ELL)?);
let likelihood = GaussianLikelihood::new(NOISE)?;
let x = fill_column_major(N, D, SEED);
let mut rng = seeded_rng(SEED ^ 0xA5A5_A5A5_A5A5_A5A5);
let y: Vec<f64> = (0..N).map(|_| open_unit(&mut rng)).collect();
let gpr = Gpr::new(kernel, likelihood)
.with_optimizer(Fixed)
.with_precision::<MixedPrecision<R>>()
.factor(&x, N, D, &y)
.map_err(|(_, e)| e)?;
let xs = fill_column_major(M, D, SEED.wrapping_add(1));
Ok((gpr, xs))
}
fn bytes_in(mut f: impl FnMut()) -> usize {
let region = Region::new(GLOBAL);
f();
let stats = region.change();
stats.bytes_allocated + stats.bytes_reallocated.max(0) as usize
}
fn assert_mixed_predict_bytes<R>(label: &str)
where
MixedPrecision<R>: gprx::GpScalar,
R: gprx::ResidualFormula,
{
let (mut gpr, xs) = fitted_mixed::<R>().expect("spd");
let mut pred = Prediction::default();
gpr.predict_into(&xs, M, D, &mut pred).expect("warmup");
let bytes = bytes_in(|| {
gpr.predict_into(&xs, M, D, &mut pred).expect("counted");
});
eprintln!("{label}: bytes={bytes} cap={MAX_MIXED_PREDICT_100_BYTES}");
assert!(
bytes < MAX_MIXED_PREDICT_100_BYTES,
"{label}: bytes={bytes}, cap={MAX_MIXED_PREDICT_100_BYTES}; predict must not rebuild the n×n system"
);
}
fn mixed_promote_predict_100_bytes_after_workspace() {
assert_mixed_predict_bytes::<gprx::PromoteStorage>("mixed_promote_predict_100");
}
fn mixed_reevaluate_predict_100_bytes_after_workspace() {
assert_mixed_predict_bytes::<ReevaluateKernel>("mixed_reevaluate_predict_100");
}
#[derive(Clone, Copy, Debug)]
struct LeafStepProbe;
static LEAF_STEP_ALLOCS: Mutex<Option<usize>> = Mutex::new(None);
impl<P: gprx::Objective> gprx::Optimizer<P> for LeafStepProbe {
const USES_CHANGE_INDICES: bool = true;
fn minimize(&self, objective: &mut P, init: &[f64]) -> Result<gprx::OptResult, GprError> {
let mut step = init.to_vec();
let value = objective.value(&step)?;
step[0] += 0.01;
objective.value_at_changes(&step, &[0])?;
step[0] += 0.01;
let mut result = Ok(0.0);
let count = allocs_in(|| {
result = objective.value_at_changes(&step, &[0]);
});
result?;
if let Ok(mut slot) = LEAF_STEP_ALLOCS.lock() {
*slot = Some(count);
}
Ok(gprx::OptResult {
params: init.to_vec(),
value,
iterations: 0,
})
}
}
fn incremental_leaf_step_allocs_after_warmup() {
ensure_one_rayon_worker();
let kernel = KernelSpec::from(RbfKernel::new(ELL).expect("ell"))
+ KernelSpec::from(RbfKernel::new(2.0 * ELL).expect("ell"));
let likelihood = GaussianLikelihood::new(NOISE).expect("noise");
let x = fill_column_major(N, D, SEED);
let mut rng = seeded_rng(SEED ^ 0xA5A5_A5A5_A5A5_A5A5);
let y: Vec<f64> = (0..N).map(|_| open_unit(&mut rng)).collect();
Gpr::new(kernel, likelihood)
.with_optimizer(LeafStepProbe)
.fit(&x, N, D, &y)
.map_err(|(_, e)| e)
.expect("fit");
let count = LEAF_STEP_ALLOCS.lock().expect("lock").expect("probe ran");
assert_alloc_cap("leaf_step", count, MAX_LEAF_STEP_ALLOCS);
}
fn composite_kernels() -> [(&'static str, KernelSpec); 6] {
let rbf = |ell: f64| KernelSpec::from(RbfKernel::new(ell).expect("ell"));
let ard = || KernelSpec::from(RbfArdKernel::new(&[ELL; D]).expect("ell"));
let constant = |value: f64| KernelSpec::from(ConstantKernel::new(value).expect("constant"));
[
("sum_with_ard", rbf(ELL) + ard()),
("product", constant(1.5) * rbf(ELL)),
("ard", ard()),
("sum", rbf(ELL) + rbf(2.0 * ELL)),
(
"nested",
(rbf(ELL) + rbf(2.0 * ELL)) * (constant(1.5) * rbf(3.0 * ELL) + constant(0.5)),
),
(
"nested_mixed",
(rbf(ELL) + ard()) * (constant(1.5) * rbf(3.0 * ELL) + constant(0.5)),
),
]
}
fn fitted_with(kernel: KernelSpec, n: usize) -> FittedGpr<Fixed> {
ensure_one_rayon_worker();
let likelihood = GaussianLikelihood::new(NOISE).expect("noise");
let x = fill_column_major(n, D, SEED);
let mut rng = seeded_rng(SEED ^ 0xA5A5_A5A5_A5A5_A5A5);
let y: Vec<f64> = (0..n).map(|_| open_unit(&mut rng)).collect();
Gpr::new(kernel, likelihood)
.with_optimizer(Fixed)
.factor(&x, n, D, &y)
.map_err(|(_, e)| e)
.expect("spd")
}
fn composite_mll_and_grad_allocs_after_workspace() {
for ((label, cap), (name, kernel)) in MAX_COMPOSITE_MLL_AND_GRAD_ALLOCS
.into_iter()
.zip(composite_kernels())
{
assert_eq!(label, name);
let mut gpr = fitted_with(kernel, N);
let mut params = vec![0.0; gpr.num_params()];
gpr.get_params(&mut params).expect("len");
let mut grad = vec![0.0; params.len()];
gpr.value_and_gradient_into(¶ms, &mut grad)
.expect("warmup");
let count = allocs_in(|| {
gpr.value_and_gradient_into(¶ms, &mut grad)
.expect("counted");
});
assert_alloc_cap(label, count, cap);
}
}
fn hessian_allocs_after_warmup() {
let kernels = std::iter::once(("rbf", KernelSpec::from(RbfKernel::new(ELL).expect("ell"))))
.chain(composite_kernels());
for ((label, cap), (name, kernel)) in MAX_HESSIAN_ALLOCS.into_iter().zip(kernels) {
assert_eq!(label, name);
let mut gpr = fitted_with(kernel, N_HESSIAN);
let mut params = vec![0.0; gpr.num_params()];
gpr.get_params(&mut params).expect("len");
let mut hess = vec![0.0; params.len() * params.len()];
gpr.hessian_into(¶ms, &mut hess).expect("warmup");
let count = allocs_in(|| {
gpr.hessian_into(¶ms, &mut hess).expect("counted");
});
assert_alloc_cap(&format!("hessian_{label}"), count, cap);
}
}
fn composite_predict_100_allocs_after_workspace() {
let xs = fill_column_major(M, D, SEED.wrapping_add(1));
for ((label, cap), (name, kernel)) in MAX_COMPOSITE_PREDICT_100_ALLOCS
.into_iter()
.zip(composite_kernels())
{
assert_eq!(label, name);
let mut gpr = fitted_with(kernel, N);
let mut pred = Prediction::default();
gpr.predict_into(&xs, M, D, &mut pred).expect("warmup");
let count = allocs_in(|| {
gpr.predict_into(&xs, M, D, &mut pred).expect("counted");
});
assert_alloc_cap(&format!("predict_100_{label}"), count, cap);
}
}
fn sparse_allocs(label: &str, kernel: KernelSpec) -> Vec<(String, usize)> {
ensure_one_rayon_worker();
let x = fill_column_major(N, D, SEED);
let z = fill_column_major(M_SPARSE, D, SEED.wrapping_add(2));
let mut rng = seeded_rng(SEED ^ 0xA5A5_A5A5_A5A5_A5A5);
let y: Vec<f64> = (0..N).map(|_| open_unit(&mut rng)).collect();
let x_new: Vec<f64> = (0..D).map(|dim| 0.1 * dim as f64).collect();
let likelihood = GaussianLikelihood::new(NOISE).expect("noise");
let mut fitted = Sgpr::new(kernel.clone(), likelihood)
.with_optimizer(Fixed)
.factor(&x, N, D, &y, &z, M_SPARSE)
.map_err(|(_, e)| e)
.expect("spd");
let mut out = Vec::new();
if label == "rbf" {
let mut params = vec![0.0; fitted.num_params()];
fitted.get_params(&mut params).expect("len");
let mut grad = vec![0.0; params.len()];
let mut hess = vec![0.0; params.len() * params.len()];
fitted
.value_and_gradient_into(¶ms, &mut grad)
.expect("warmup");
let count = allocs_in(|| {
fitted
.value_and_gradient_into(¶ms, &mut grad)
.expect("counted");
});
out.push(("sgpr_mll_and_grad".to_owned(), count));
fitted.hessian_into(¶ms, &mut hess).expect("warmup");
let count = allocs_in(|| {
fitted.hessian_into(¶ms, &mut hess).expect("counted");
});
out.push(("sgpr_hessian".to_owned(), count));
}
let mut online = fitted.into_online();
online.insert(&x_new, 0.5).expect("warmup");
let count = allocs_in(|| {
online.insert(&x_new, 0.25).expect("counted");
});
let insert_label = if label == "rbf" {
"online_sgpr_insert"
} else {
"online_sgpr_insert_nested"
};
out.push((insert_label.to_owned(), count));
if label == "rbf" {
let mut svgp = Svgp::new(kernel, likelihood)
.factor(&x, N, D, &y, &z, M_SPARSE)
.map_err(|(_, e)| e)
.expect("spd");
let mut params = vec![0.0; svgp.num_params()];
svgp.get_params(&mut params).expect("len");
let mut grad = vec![0.0; params.len()];
svgp.value_and_gradient_into(¶ms, &mut grad)
.expect("warmup");
let count = allocs_in(|| {
svgp.value_and_gradient_into(¶ms, &mut grad)
.expect("counted");
});
out.push(("svgp_mll_and_grad".to_owned(), count));
}
out
}
fn sparse_allocs_after_warmup() {
let rbf = || KernelSpec::from(RbfKernel::new(ELL).expect("ell"));
let constant = |v: f64| KernelSpec::from(ConstantKernel::new(v).expect("constant"));
let nested = (rbf() + KernelSpec::from(RbfKernel::new(2.0 * ELL).expect("ell")))
* (constant(1.5) * rbf() + constant(0.5));
let mut counts = sparse_allocs("rbf", rbf());
counts.extend(sparse_allocs("nested", nested));
for (label, cap) in MAX_SPARSE_ALLOCS {
let count = counts
.iter()
.find(|(name, _)| name == label)
.map(|(_, count)| *count)
.expect("measured");
assert_alloc_cap(label, count, cap);
}
}
fn sparse_predict_counts<P: GpScalar>(
kernel: KernelSpec,
count: fn(&mut dyn FnMut()) -> usize,
) -> [(&'static str, usize); 3] {
ensure_one_rayon_worker();
let x = fill_column_major(N, D, SEED);
let z = fill_column_major(M_SPARSE, D, SEED.wrapping_add(2));
let xs = fill_column_major(M, D, SEED.wrapping_add(1));
let mut rng = seeded_rng(SEED ^ 0xA5A5_A5A5_A5A5_A5A5);
let y: Vec<f64> = (0..N).map(|_| open_unit(&mut rng)).collect();
let likelihood = GaussianLikelihood::new(NOISE).expect("noise");
let mut pred = Prediction::default();
let mut fitted = Sgpr::new(kernel.clone(), likelihood)
.with_optimizer(Fixed)
.with_precision::<P>()
.factor(&x, N, D, &y, &z, M_SPARSE)
.map_err(|(_, e)| e)
.expect("spd");
fitted.predict_into(&xs, M, D, &mut pred).expect("warmup");
let sgpr = count(&mut || fitted.predict_into(&xs, M, D, &mut pred).expect("counted"));
let mut online = fitted.into_online();
let x_new: Vec<f64> = (0..D).map(|dim| 0.1 * dim as f64).collect();
online.insert(&x_new, 0.5).expect("insert");
online.predict_into(&xs, M, D, &mut pred).expect("warmup");
let online = count(&mut || online.predict_into(&xs, M, D, &mut pred).expect("counted"));
let mut svgp = Svgp::new(kernel, likelihood)
.with_precision::<P>()
.factor(&x, N, D, &y, &z, M_SPARSE)
.map_err(|(_, e)| e)
.expect("spd");
svgp.predict_into(&xs, M, D, &mut pred).expect("warmup");
let svgp = count(&mut || svgp.predict_into(&xs, M, D, &mut pred).expect("counted"));
[("sgpr", sgpr), ("online_sgpr", online), ("svgp", svgp)]
}
fn allocs_in_dyn(f: &mut dyn FnMut()) -> usize {
allocs_in(f)
}
fn bytes_in_dyn(f: &mut dyn FnMut()) -> usize {
bytes_in(f)
}
fn sparse_predict_into_allocs_after_warmup() {
let rbf = || KernelSpec::from(RbfKernel::new(ELL).expect("ell"));
let constant = |v: f64| KernelSpec::from(ConstantKernel::new(v).expect("constant"));
let nested = || {
(rbf() + KernelSpec::from(RbfKernel::new(2.0 * ELL).expect("ell")))
* (constant(1.5) * rbf() + constant(0.5))
};
let cases = [
(
"f64",
sparse_predict_counts::<DoublePrecision>(rbf(), allocs_in_dyn),
),
(
"f64_nested",
sparse_predict_counts::<DoublePrecision>(nested(), allocs_in_dyn),
),
(
"f32",
sparse_predict_counts::<SinglePrecision>(rbf(), allocs_in_dyn),
),
(
"f32_nested",
sparse_predict_counts::<SinglePrecision>(nested(), allocs_in_dyn),
),
];
for (precision, counts) in cases {
for (model, count) in counts {
assert_alloc_cap(
&format!("{model}_predict_100_{precision}"),
count,
MAX_SPARSE_PREDICT_100_ALLOCS,
);
}
}
for (label, counts) in [
(
"promote",
sparse_predict_counts::<MixedPrecision<gprx::PromoteStorage>>(rbf(), allocs_in_dyn),
),
(
"reevaluate",
sparse_predict_counts::<MixedPrecision<ReevaluateKernel>>(rbf(), allocs_in_dyn),
),
] {
for (model, count) in counts {
if model != "svgp" {
assert_alloc_cap(
&format!("{model}_predict_100_mixed_{label}"),
count,
MAX_SPARSE_PREDICT_100_ALLOCS,
);
}
}
}
for (label, counts) in [
(
"promote",
sparse_predict_counts::<MixedPrecision<gprx::PromoteStorage>>(rbf(), bytes_in_dyn),
),
(
"reevaluate",
sparse_predict_counts::<MixedPrecision<ReevaluateKernel>>(rbf(), bytes_in_dyn),
),
] {
let bytes = counts[2].1;
eprintln!(
"svgp_predict_100_mixed_{label}: bytes={bytes} cap={MAX_SVGP_MIXED_PREDICT_100_BYTES}"
);
assert!(
bytes <= MAX_SVGP_MIXED_PREDICT_100_BYTES,
"svgp_predict_100_mixed_{label}: bytes={bytes}, cap={MAX_SVGP_MIXED_PREDICT_100_BYTES}"
);
}
}
const MAX_SVGP_STEP_BYTES_GROWTH: f64 = 1.25;
const SVGP_STEP_BYTES_SLACK: f64 = 1024.0;
fn svgp_fit_bytes(n: usize, epochs: u64) -> usize {
ensure_one_rayon_worker();
let x = fill_column_major(n, D, SEED);
let z = fill_column_major(M_SPARSE, D, SEED.wrapping_add(2));
let mut rng = seeded_rng(SEED ^ 0xA5A5_A5A5_A5A5_A5A5);
let y: Vec<f64> = (0..n).map(|_| open_unit(&mut rng)).collect();
let kernel = KernelSpec::from(RbfKernel::new(ELL).expect("ell"));
let adam = Adam::new()
.with_batch_size(NonZeroUsize::new(32).expect("batch"))
.with_epochs(NonZeroU64::new(epochs).expect("epochs"));
let trainer =
Svgp::new(kernel, GaussianLikelihood::new(NOISE).expect("noise")).with_optimizer(adam);
let mut trainers = vec![trainer.clone(), trainer];
let mut fitted = None;
let bytes = bytes_in(|| {
fitted = Some(
trainers
.pop()
.expect("one trainer per run")
.fit(&x, n, D, &y, &z, M_SPARSE)
.map_err(|(_, e)| e)
.expect("fit"),
);
});
drop(fitted);
bytes
}
fn svgp_step_bytes(n: usize) -> f64 {
let extra = svgp_fit_bytes(n, 2) as f64 - svgp_fit_bytes(n, 1) as f64;
extra / (n / 32) as f64
}
fn svgp_adam_step_bytes_do_not_grow_with_n() {
let _ = svgp_fit_bytes(64, 1); let small = svgp_step_bytes(512);
let large = svgp_step_bytes(4096);
eprintln!("svgp step bytes: n=512 {small:.0}, n=4096 {large:.0}");
assert!(
large <= MAX_SVGP_STEP_BYTES_GROWTH * small + SVGP_STEP_BYTES_SLACK,
"an Adam step allocates {large:.0} bytes at n=4096 and {small:.0} at n=512: it scales with n"
);
}
const MAX_SVGP_ADAM_EPOCH_ALLOCS: [(&str, usize); 3] =
[("rbf", 0), ("rbf_ard", 0), ("constant_times_rbf", 0)];
fn svgp_adam_epoch_allocs() {
let n = 64;
let x: Vec<f64> = (0..n * 2)
.map(|i| (i % n) as f64 / 8.0 + (i / n) as f64)
.collect();
let y: Vec<f64> = (0..n).map(|i| (i as f64 / 8.0).sin()).collect();
let z: Vec<f64> = (0..16).map(|i| (i % 8) as f64 + (i / 8) as f64).collect();
let kernels = [
KernelSpec::from(RbfKernel::new(ELL).expect("ell")),
KernelSpec::from(RbfArdKernel::new(&[ELL, 2.0 * ELL]).expect("ell")),
KernelSpec::from(ConstantKernel::new(1.5).expect("c"))
* KernelSpec::from(RbfKernel::new(ELL).expect("ell")),
];
for ((label, cap), kernel) in MAX_SVGP_ADAM_EPOCH_ALLOCS.iter().zip(kernels) {
let fit = |epochs: u64| {
allocs_in(|| {
let fitted =
Svgp::new(kernel.clone(), GaussianLikelihood::new(0.1).expect("noise"))
.with_optimizer(
Adam::new()
.with_batch_size(NonZeroUsize::new(8).expect("8"))
.with_epochs(NonZeroU64::new(epochs).expect("epochs")),
)
.fit(&x, n, 2, &y, &z, 8)
.map_err(|(_, e)| e)
.expect("fit");
std::hint::black_box(fitted);
})
};
fit(1);
let per_epoch = (0..3)
.map(|_| fit(3).saturating_sub(fit(1)) / 2)
.min()
.unwrap_or(usize::MAX);
assert_alloc_cap(&format!("svgp_adam_epoch_{label}"), per_epoch, *cap);
}
}
const DISTANCE_BASELINE_ALLOCS: [(&str, usize); 22] = [
("rbf/factor", 17),
("rbf/mll_and_grad", 3),
("rbf/predict_into", 0),
("rbf/online_insert", 4),
("rbf/online_delete_first", 1),
("rbf/online_delete_middle", 1),
("rbf/online_delete_last", 1),
("rbf/online_refit", 12),
("rbf/sgpr_factor", 22),
("rbf/sgpr_predict_into", 0),
("rbf/svgp_predict_into", 0),
("rbf_ard/factor", 24),
("rbf_ard/mll_and_grad", 3),
("rbf_ard/predict_into", 0),
("rbf_ard/online_insert", 4),
("rbf_ard/online_delete_first", 1),
("rbf_ard/online_delete_middle", 1),
("rbf_ard/online_delete_last", 1),
("rbf_ard/online_refit", 13),
("rbf_ard/sgpr_factor", 31),
("rbf_ard/sgpr_predict_into", 0),
("rbf_ard/svgp_predict_into", 0),
];
fn distance_baseline_allocs() -> Vec<(String, usize)> {
static COUNTS: OnceLock<Vec<(String, usize)>> = OnceLock::new();
COUNTS
.get_or_init(coordinate_allocs::<DoublePrecision>)
.clone()
}
fn distance_baseline_coordinate_allocs() {
ensure_one_rayon_worker();
let measured = distance_baseline_allocs();
assert_eq!(measured.len(), DISTANCE_BASELINE_ALLOCS.len());
for ((label, count), (expected, cap)) in measured.iter().zip(DISTANCE_BASELINE_ALLOCS) {
assert_eq!(label, expected);
assert_alloc_cap(&format!("distance_baseline/{label}"), *count, cap);
}
}
enum BaselineSlot {
Scalar(ScalarDistance),
Ard(ArdDistance),
}
impl BaselineSlot {
fn borrow<'a>(&self, sum: &'a [f64], refs: &'a [&'a [f64]]) -> DistanceSource<'a> {
match self {
Self::Scalar(slot) => slot.borrow(sum),
Self::Ard(slot) => slot.borrow(refs),
}
}
}
fn supplied_allocs<P: GpScalar>() -> Vec<(String, usize)> {
let p = common::problems::distance_baseline();
let s = p.supplied();
let train_refs: Vec<&[f64]> = s.train.iter().map(Vec::as_slice).collect();
let cross_refs: Vec<&[f64]> = s.cross.iter().map(Vec::as_slice).collect();
let new_refs: Vec<&[f64]> = s.new.iter().map(Vec::as_slice).collect();
let lik = || GaussianLikelihood::new(0.1).expect("noise");
let image = ScalarDistance::new();
let (bands, ard) =
ArdDistance::from_leaf(RbfArdKernel::new(&[0.5, 0.6, 0.7, 0.8][..p.d]).expect("ell"));
let kernels = [
(
"rbf",
BaselineSlot::Scalar(image),
image.kernel(RbfKernel::new(0.5).expect("ell")),
),
("rbf_ard", BaselineSlot::Ard(bands), ard),
];
let mut out = Vec::new();
for (name, slot, kernel) in kernels {
let fit = || {
Gpr::new(kernel.clone(), lik())
.with_precision::<P>()
.with_optimizer(Fixed)
.factor([slot.borrow(&s.train_sum, &train_refs)], p.n, &p.y)
.map_err(|(_, e)| e)
.expect("factor")
};
let _warm = fit();
let mut model = None;
let count = allocs_in(|| model = Some(fit()));
out.push((format!("{name}/factor"), count));
let mut model = model.expect("model");
let mut theta = vec![0.0; model.num_params()];
model.get_params(&mut theta).expect("theta");
let mut grad = vec![0.0; theta.len()];
model
.value_and_gradient_into(&theta, &mut grad)
.expect("warmup");
let count = {
allocs_in(|| {
model
.value_and_gradient_into(&theta, &mut grad)
.expect("counted");
})
};
out.push((format!("{name}/mll_and_grad"), count));
let mut pred = Prediction::default();
let cross = || slot.borrow(&s.cross_sum, &cross_refs);
model
.predict_into([cross()], p.q, &mut pred)
.expect("warmup");
let count = {
allocs_in(|| {
model
.predict_into([cross()], p.q, &mut pred)
.expect("counted")
})
};
out.push((format!("{name}/predict_into"), count));
let new = || slot.borrow(&s.new_sum, &new_refs);
let mut base = model.into_online().expect("online");
let id = base.insert([new()], p.y_new).expect("grow");
base.delete(id).expect("shrink");
let count = {
let count = allocs_once(|| {
base.insert([new()], p.y_new).expect("counted");
});
let id = base.point_ids()[p.n];
base.delete(id).expect("shrink");
count
};
out.push((format!("{name}/online_insert"), count));
online_deletes_and_refit(name, &base, p.n, &mut out);
let inducing: Vec<usize> = (0..p.m).collect();
let nm = p.n * p.m;
let sparse_refs: Vec<&[f64]> = s.train.iter().map(|b| &b[..nm]).collect();
let sparse_train = || slot.borrow(&s.train_sum[..nm], &sparse_refs);
let sgpr = || {
Sgpr::new(kernel.clone(), lik())
.with_precision::<P>()
.with_optimizer(Fixed)
.factor([sparse_train()], p.n, &p.y, &inducing)
.map_err(|(_, e)| e)
.expect("sgpr")
};
let _warm = sgpr();
let mut sparse = None;
out.push((
format!("{name}/sgpr_factor"),
allocs_in(|| sparse = Some(sgpr())),
));
let mut sparse = sparse.expect("sgpr");
let cross_refs: Vec<&[f64]> = s.sparse_cross.iter().map(Vec::as_slice).collect();
let cross = || slot.borrow(&s.sparse_cross_sum, &cross_refs);
sparse
.predict_into([cross()], p.q, &mut pred)
.expect("warmup");
out.push((
format!("{name}/sgpr_predict_into"),
allocs_in(|| {
sparse
.predict_into([cross()], p.q, &mut pred)
.expect("counted")
}),
));
let mut svgp = Svgp::new(kernel.clone(), lik())
.with_precision::<P>()
.factor([sparse_train()], p.n, &p.y, &inducing)
.map_err(|(_, e)| e)
.expect("svgp");
svgp.predict_into([cross()], p.q, &mut pred)
.expect("warmup");
out.push((
format!("{name}/svgp_predict_into"),
allocs_in(|| {
svgp.predict_into([cross()], p.q, &mut pred)
.expect("counted")
}),
));
}
out
}
fn online_deletes_and_refit<P: GpScalar, K: gprx::kernel::ModelKernel>(
name: &str,
base: &gprx::OnlineGpr<Fixed, P, K>,
n: usize,
out: &mut Vec<(String, usize)>,
) {
for (label, index) in [("first", 0), ("middle", n / 2), ("last", n - 1)] {
let id = base.point_ids()[index];
let count = {
let mut online = base.clone();
allocs_once(|| online.delete(id).expect("counted"))
};
out.push((format!("{name}/online_delete_{label}"), count));
}
let count = {
let mut online = base.clone();
allocs_once(|| online.refit().expect("counted"))
};
out.push((format!("{name}/online_refit"), count));
}
fn coordinate_allocs<P: GpScalar>() -> Vec<(String, usize)> {
let p = common::problems::distance_baseline();
let lik = || GaussianLikelihood::new(0.1).expect("noise");
let kernels = [
("rbf", KernelSpec::from(RbfKernel::new(0.5).expect("ell"))),
(
"rbf_ard",
KernelSpec::from(RbfArdKernel::new(&[0.5, 0.6, 0.7, 0.8]).expect("ell")),
),
];
let mut out = Vec::new();
for (name, kernel) in kernels {
let fit = || {
Gpr::new(kernel.clone(), lik())
.with_precision::<P>()
.with_optimizer(Fixed)
.factor(&p.x, p.n, p.d, &p.y)
.map_err(|(_, e)| e)
.expect("factor")
};
let _warm = fit();
let mut model = None;
let count = allocs_in(|| model = Some(fit()));
out.push((format!("{name}/factor"), count));
let mut model = model.expect("model");
let mut theta = vec![0.0; model.num_params()];
model.get_params(&mut theta).expect("theta");
let mut grad = vec![0.0; theta.len()];
model
.value_and_gradient_into(&theta, &mut grad)
.expect("warmup");
let count = {
allocs_in(|| {
model
.value_and_gradient_into(&theta, &mut grad)
.expect("counted");
})
};
out.push((format!("{name}/mll_and_grad"), count));
let mut pred = Prediction::default();
model
.predict_into(&p.xq, p.q, p.d, &mut pred)
.expect("warmup");
let count = {
allocs_in(|| {
model
.predict_into(&p.xq, p.q, p.d, &mut pred)
.expect("counted")
})
};
out.push((format!("{name}/predict_into"), count));
let mut base = model.into_online().expect("online");
let id = base.insert(&p.x_new, p.y_new).expect("grow");
base.delete(id).expect("shrink");
let count = {
let count = allocs_once(|| {
base.insert(&p.x_new, p.y_new).expect("counted");
});
let id = base.point_ids()[p.n];
base.delete(id).expect("shrink");
count
};
out.push((format!("{name}/online_insert"), count));
online_deletes_and_refit(name, &base, p.n, &mut out);
let sgpr = || {
Sgpr::new(kernel.clone(), lik())
.with_precision::<P>()
.with_optimizer(Fixed)
.factor(&p.x, p.n, p.d, &p.y, &p.z, p.m)
.map_err(|(_, e)| e)
.expect("sgpr")
};
let _warm = sgpr();
let mut sparse = None;
out.push((
format!("{name}/sgpr_factor"),
allocs_in(|| sparse = Some(sgpr())),
));
let mut sparse = sparse.expect("sgpr");
sparse
.predict_into(&p.xq, p.q, p.d, &mut pred)
.expect("warmup");
out.push((
format!("{name}/sgpr_predict_into"),
allocs_in(|| {
sparse
.predict_into(&p.xq, p.q, p.d, &mut pred)
.expect("counted")
}),
));
let mut svgp = Svgp::new(kernel.clone(), lik())
.with_precision::<P>()
.factor(&p.x, p.n, p.d, &p.y, &p.z, p.m)
.map_err(|(_, e)| e)
.expect("svgp");
svgp.predict_into(&p.xq, p.q, p.d, &mut pred)
.expect("warmup");
out.push((
format!("{name}/svgp_predict_into"),
allocs_in(|| {
svgp.predict_into(&p.xq, p.q, p.d, &mut pred)
.expect("counted")
}),
));
}
out
}
fn online_change_allocs<M: Clone>(
base: &M,
settle: &dyn Fn(&mut M),
changes: [&dyn Fn(&mut M); 4],
) -> [usize; 4] {
changes.map(|change| {
let mut model = base.clone();
settle(&mut model);
allocs_once(|| change(&mut model))
})
}
fn online_sparse_allocs<P: GpScalar>() -> Vec<(String, usize, usize)> {
let p = common::problems::distance_baseline();
let s = p.supplied();
let lik = || GaussianLikelihood::new(0.1).expect("noise");
let (n, m) = (p.n, p.m);
let inducing: Vec<usize> = (0..m).collect();
let nm = n * m;
let row: Vec<Vec<f64>> = s.new.iter().map(|b| b[..m].to_vec()).collect();
let column: Vec<Vec<f64>> = s
.train
.iter()
.map(|b| b[m * n..(m + 1) * n].to_vec())
.collect();
let sum = |blocks: &[Vec<f64>]| -> Vec<f64> {
(0..blocks[0].len())
.map(|i| blocks.iter().map(|b| b[i]).sum())
.collect()
};
let (row_sum, column_sum) = (sum(&row), sum(&column));
let z_new: Vec<f64> = (0..p.d).map(|k| p.x[m + k * n]).collect();
let image = ScalarDistance::new();
let ell = [0.5, 0.6, 0.7, 0.8];
let (bands, ard) = ArdDistance::from_leaf(RbfArdKernel::new(&ell[..p.d]).expect("ell"));
let mut out = Vec::new();
for name in ["rbf", "rbf_ard"] {
let scalar = name == "rbf";
let coords = Sgpr::new(
if scalar {
KernelSpec::from(RbfKernel::new(0.5).expect("ell"))
} else {
KernelSpec::from(RbfArdKernel::new(&ell[..p.d]).expect("ell"))
},
lik(),
)
.with_precision::<P>()
.with_optimizer(Fixed)
.factor(&p.x, n, p.d, &p.y, &p.z, m)
.map_err(|(_, e)| e)
.expect("coords");
let train: Vec<&[f64]> = s.train.iter().map(|b| &b[..nm]).collect();
let train_sum = &s.train_sum[..nm];
let supplied = if scalar {
Sgpr::new(image.kernel(RbfKernel::new(0.5).expect("ell")), lik())
.with_precision::<P>()
.with_optimizer(Fixed)
.factor([image.borrow(train_sum)], n, &p.y, &inducing)
} else {
Sgpr::new(ard.clone(), lik())
.with_precision::<P>()
.with_optimizer(Fixed)
.factor([bands.borrow(&train)], n, &p.y, &inducing)
}
.map_err(|(_, e)| e)
.expect("supplied");
let row_refs: Vec<&[f64]> = row.iter().map(Vec::as_slice).collect();
let column_refs: Vec<&[f64]> = column.iter().map(Vec::as_slice).collect();
let row_src = || {
if scalar {
image.borrow(&row_sum)
} else {
bands.borrow(&row_refs)
}
};
let column_src = || {
if scalar {
image.borrow(&column_sum)
} else {
bands.borrow(&column_refs)
}
};
let mut coords = coords.into_online();
let id = coords.insert(&p.x_new, p.y_new).expect("insert");
coords.delete(id).expect("delete");
let id = coords.insert_inducing(&z_new).expect("insert_inducing");
coords.delete_inducing(id).expect("delete_inducing");
let mut supplied = supplied.into_online();
let id = supplied.insert([row_src()], p.y_new).expect("insert");
supplied.delete(id).expect("delete");
let point = supplied.point_ids()[m];
let id = supplied
.insert_inducing(point, [column_src()])
.expect("insert_inducing");
supplied.delete_inducing(id).expect("delete_inducing");
let coordinate = online_change_allocs(
&coords,
&|model| {
let id = model.insert(&p.x_new, p.y_new).expect("settle");
model.delete(id).expect("settle");
},
[
&|model| {
model.insert(&p.x_new, p.y_new).expect("insert");
},
&|model| model.delete(model.point_ids()[n / 2]).expect("delete"),
&|model| {
model.insert_inducing(&z_new).expect("insert_inducing");
},
&|model| {
model
.delete_inducing(model.inducing_ids()[m / 2])
.expect("delete_inducing");
},
],
);
let on_supplied = online_change_allocs(
&supplied,
&|model| {
let id = model.insert([row_src()], p.y_new).expect("settle");
model.delete(id).expect("settle");
},
[
&|model| {
model.insert([row_src()], p.y_new).expect("insert");
},
&|model| model.delete(model.point_ids()[n / 2]).expect("delete"),
&|model| {
let point = model.point_ids()[m];
model
.insert_inducing(point, [column_src()])
.expect("insert_inducing");
},
&|model| {
model
.delete_inducing(model.inducing_ids()[m / 2])
.expect("delete_inducing");
},
],
);
for ((label, got), cap) in ["insert", "delete", "insert_inducing", "delete_inducing"]
.iter()
.zip(on_supplied)
.zip(coordinate)
{
out.push((format!("{name}/online_sgpr_{label}"), got, cap));
}
}
out
}
fn online_sgpr_on_supplied_distances_allocates_no_more_than_coordinates() {
ensure_one_rayon_worker();
let mut over = Vec::new();
for (precision, rows) in [
("f64", online_sparse_allocs::<DoublePrecision>()),
("f32", online_sparse_allocs::<SinglePrecision>()),
(
"mixed",
online_sparse_allocs::<MixedPrecision<ReevaluateKernel>>(),
),
] {
for (label, count, cap) in rows {
let label = format!("supplied/{precision}/{label}");
eprintln!("{label}: allocations={count} cap={cap}");
if count > cap {
over.push(label);
}
}
}
assert!(over.is_empty(), "over the coordinate path: {over:?}");
}
fn supplied_distances_allocate_no_more_than_coordinates() {
ensure_one_rayon_worker();
let mut over = Vec::new();
for (precision, supplied, coordinate) in [
(
"f64",
supplied_allocs::<DoublePrecision>(),
distance_baseline_allocs(),
),
(
"f32",
supplied_allocs::<SinglePrecision>(),
coordinate_allocs::<SinglePrecision>(),
),
(
"mixed",
supplied_allocs::<MixedPrecision<ReevaluateKernel>>(),
coordinate_allocs::<MixedPrecision<ReevaluateKernel>>(),
),
] {
assert_eq!(supplied.len(), coordinate.len());
for ((label, count), (expected, cap)) in supplied.into_iter().zip(coordinate) {
assert_eq!(label, expected);
let label = format!("supplied/{precision}/{label}");
eprintln!("{label}: allocations={count} cap={cap}");
if count > cap {
over.push(label);
}
}
}
assert!(over.is_empty(), "over the coordinate path: {over:?}");
}
fn grad_allocs(theta: Vec<f64>, mut value_and_gradient: impl FnMut(&[f64], &mut [f64])) -> usize {
let mut grad = vec![0.0; theta.len()];
value_and_gradient(&theta, &mut grad);
allocs_in(|| value_and_gradient(&theta, &mut grad))
}
fn svgp_with_points_grad_allocs<P: GpScalar>() -> (usize, usize) {
let p = common::problems::distance_baseline();
let s = p.supplied();
let lik = || GaussianLikelihood::new(0.1).expect("noise");
let rbf = |ell: f64| RbfKernel::new(ell).expect("ell");
let image = ScalarDistance::new();
let inducing: Vec<usize> = (0..p.m).collect();
let mut supplied = Svgp::new(image.kernel(rbf(0.5)) * KernelSpec::from(rbf(0.7)), lik())
.with_precision::<P>()
.factor(
[image.borrow(&s.train_sum[..p.n * p.m])],
p.n,
&p.x,
p.d,
&p.y,
&inducing,
)
.map_err(|(_, e)| e)
.expect("supplied");
let mut theta = vec![0.0; supplied.num_params()];
supplied.get_params(&mut theta).expect("theta");
let with_points = grad_allocs(theta, |t, g| {
supplied.value_and_gradient_into(t, g).expect("grad");
});
let mut coords = Svgp::new(
KernelSpec::from(rbf(0.5)) * KernelSpec::from(rbf(0.7)),
lik(),
)
.with_precision::<P>()
.factor(&p.x, p.n, p.d, &p.y, &p.z, p.m)
.map_err(|(_, e)| e)
.expect("coords");
let mut theta = vec![0.0; coords.num_params()];
coords.get_params(&mut theta).expect("theta");
let coordinate = grad_allocs(theta, |t, g| {
coords.value_and_gradient_into(t, g).expect("grad");
});
(with_points, coordinate)
}
fn svgp_gradient_with_points_allocates_no_more_than_coordinates() {
ensure_one_rayon_worker();
for (precision, (with_points, coordinate)) in [
("f64", svgp_with_points_grad_allocs::<DoublePrecision>()),
("f32", svgp_with_points_grad_allocs::<SinglePrecision>()),
(
"mixed",
svgp_with_points_grad_allocs::<MixedPrecision<ReevaluateKernel>>(),
),
] {
eprintln!(
"svgp_with_points/{precision}/mll_and_grad: allocations={with_points} cap={coordinate}"
);
assert!(
with_points <= coordinate,
"{precision}: {with_points} allocations, the coordinate path {coordinate}"
);
}
}
fn covariance_bytes() -> Vec<(String, usize, usize)> {
let p = common::problems::distance_baseline();
let s = p.supplied();
let lik = || GaussianLikelihood::new(0.1).expect("noise");
let block = |k: usize| -> Vec<f64> {
(0..p.q)
.flat_map(|j| (0..p.q).map(move |i| (i, j)))
.map(|(i, j)| (p.xq[i + k * p.q] - p.xq[j + k * p.q]).powi(2))
.collect()
};
let squares: Vec<Vec<f64>> = (0..p.d).map(block).collect();
let square_sum: Vec<f64> = (0..p.q * p.q)
.map(|at| squares.iter().map(|b| b[at]).sum())
.collect();
let square_refs: Vec<&[f64]> = squares.iter().map(Vec::as_slice).collect();
let train_refs: Vec<&[f64]> = s.train.iter().map(Vec::as_slice).collect();
let cross_refs: Vec<&[f64]> = s.cross.iter().map(Vec::as_slice).collect();
let image = ScalarDistance::new();
let ell = [0.5, 0.6, 0.7, 0.8];
let (bands, ard) = ArdDistance::from_leaf(RbfArdKernel::new(&ell).expect("ell"));
let mut out = Vec::new();
let coords = |kernel: KernelSpec| {
Gpr::new(kernel, lik())
.with_optimizer(Fixed)
.factor(&p.x, p.n, p.d, &p.y)
.expect("factor")
};
let c = coords(KernelSpec::from(RbfKernel::new(0.5).expect("ell")));
let d = Gpr::new(image.kernel(RbfKernel::new(0.5).expect("ell")), lik())
.with_optimizer(Fixed)
.factor([image.borrow(&s.train_sum)], p.n, &p.y)
.expect("factor");
let cb = bytes_in(|| {
c.predict_covariance(&p.xq, p.q, p.d).expect("covariance");
});
let db = bytes_in(|| {
d.predict_covariance(
[image.borrow(&s.cross_sum)],
[image.borrow(&square_sum)],
p.q,
)
.expect("covariance");
});
out.push(("rbf".to_owned(), db, cb));
let c = coords(KernelSpec::from(RbfArdKernel::new(&ell).expect("ell")));
let d = Gpr::new(ard, lik())
.with_optimizer(Fixed)
.factor([bands.borrow(&train_refs)], p.n, &p.y)
.expect("factor");
let cb = bytes_in(|| {
c.predict_covariance(&p.xq, p.q, p.d).expect("covariance");
});
let db = bytes_in(|| {
d.predict_covariance(
[bands.borrow(&cross_refs)],
[bands.borrow(&square_refs)],
p.q,
)
.expect("covariance");
});
out.push(("rbf_ard".to_owned(), db, cb));
out
}
fn a_covariance_on_supplied_distances_copies_no_query_square() {
ensure_one_rayon_worker();
for (label, supplied, coordinate) in covariance_bytes() {
eprintln!("covariance/{label}: supplied={supplied} coordinate={coordinate} bytes");
assert!(
supplied <= coordinate,
"covariance/{label}: {supplied} bytes on supplied distances, {coordinate} on coordinates"
);
}
}
const MAX_SAVE_BYTES: usize = 16 * 1024;
const SAVE_BYTES_GROWTH_SLACK: usize = 1024;
fn save_bytes(n: usize) -> Vec<(&'static str, usize)> {
const DIMS: usize = 2;
let x = fill_column_major(n, DIMS, SEED);
let mut rng = seeded_rng(SEED ^ 0xA5A5_A5A5_A5A5_A5A5);
let y: Vec<f64> = (0..n).map(|_| open_unit(&mut rng)).collect();
let square = |k: usize| -> Vec<f64> {
(0..n)
.flat_map(|j| (0..n).map(move |i| (i, j)))
.map(|(i, j)| (x[i + k * n] - x[j + k * n]).powi(2))
.collect()
};
let squares: Vec<Vec<f64>> = (0..DIMS).map(square).collect();
let sum: Vec<f64> = (0..n * n)
.map(|at| squares[0][at] + squares[1][at])
.collect();
let refs: Vec<&[f64]> = squares.iter().map(Vec::as_slice).collect();
let lik = || GaussianLikelihood::new(NOISE).expect("noise");
let dir = std::env::temp_dir().join(format!("gprx-alloc-save-{}", std::process::id()));
let counted = |save: &dyn Fn() -> Result<(), GprError>| {
save().expect("warmup save");
let mut result = Ok(());
let bytes = bytes_in(|| result = save());
result.expect("counted save");
bytes
};
let coordinate = Gpr::new(KernelSpec::from(RbfKernel::new(ELL).expect("ell")), lik())
.with_optimizer(Fixed)
.factor(&x, n, DIMS, &y)
.expect("factor");
let image = ScalarDistance::new();
let scalar = Gpr::new(image.kernel(RbfKernel::new(ELL).expect("ell")), lik())
.with_optimizer(Fixed)
.factor([image.borrow(&sum)], n, &y)
.map_err(|(_, e)| e)
.expect("factor");
let (bands, ard) = ArdDistance::from_leaf(RbfArdKernel::new(&[ELL, 2.0 * ELL]).expect("ell"));
let ard = Gpr::new(ard, lik())
.with_optimizer(Fixed)
.factor([bands.borrow(&refs)], n, &y)
.map_err(|(_, e)| e)
.expect("factor");
let out = vec![
("coordinate_rbf", counted(&|| coordinate.save(&dir))),
("supplied_rbf", counted(&|| scalar.save(&dir))),
("supplied_rbf_ard", counted(&|| ard.save(&dir))),
];
std::fs::remove_dir_all(&dir).expect("remove the save directory");
out
}
fn save_bytes_do_not_grow_with_n() {
ensure_one_rayon_worker();
for ((label, small), (_, large)) in save_bytes(64).into_iter().zip(save_bytes(1024)) {
eprintln!("save/{label}: bytes n=64 {small}, n=1024 {large}, cap {MAX_SAVE_BYTES}");
assert!(
large <= MAX_SAVE_BYTES,
"save/{label}: {large} bytes at n=1024, cap={MAX_SAVE_BYTES}; do not raise it without an Issue"
);
assert!(
large <= small + SAVE_BYTES_GROWTH_SLACK,
"save/{label}: {large} bytes at n=1024 and {small} at n=64: a save allocates per point"
);
}
}
macro_rules! checks {
($($name:ident),* $(,)?) => {
[$((stringify!($name), $name as fn())),*]
};
}
const CHECKS: [(&str, fn()); 20] = checks![
mll_and_grad_allocs_after_workspace,
fast_approx_mll_and_grad_allocs_after_workspace,
predict_100_allocs_after_workspace,
mixed_promote_predict_100_bytes_after_workspace,
mixed_reevaluate_predict_100_bytes_after_workspace,
incremental_leaf_step_allocs_after_warmup,
composite_mll_and_grad_allocs_after_workspace,
hessian_allocs_after_warmup,
composite_predict_100_allocs_after_workspace,
sparse_allocs_after_warmup,
sparse_predict_into_allocs_after_warmup,
svgp_adam_step_bytes_do_not_grow_with_n,
svgp_adam_epoch_allocs,
distance_baseline_coordinate_allocs,
online_sgpr_on_supplied_distances_allocates_no_more_than_coordinates,
supplied_distances_allocate_no_more_than_coordinates,
svgp_gradient_with_points_allocates_no_more_than_coordinates,
a_covariance_on_supplied_distances_copies_no_query_square,
save_bytes_do_not_grow_with_n,
arguments_select_as_libtest_does,
];
#[derive(Default)]
struct Args {
filters: Vec<String>,
skip: Vec<String>,
exact: bool,
list: bool,
ignored: bool,
}
impl Args {
fn parse(mut args: impl Iterator<Item = String>) -> Self {
let mut out = Self::default();
while let Some(arg) = args.next() {
match arg.as_str() {
"--exact" => out.exact = true,
"--list" => out.list = true,
"--ignored" => out.ignored = true,
"--skip" => out.skip.extend(args.next()),
"--test-threads" | "--color" | "--format" | "-Z" | "--logfile"
| "--shuffle-seed" => {
let _ = args.next();
}
flag if flag.starts_with("--skip=") => {
out.skip.push(flag["--skip=".len()..].to_owned());
}
flag if flag.starts_with('-') => {}
filter => out.filters.push(filter.to_owned()),
}
}
out
}
fn selects(&self, name: &str) -> bool {
let matches = |pattern: &String| {
if self.exact {
name == pattern
} else {
name.contains(pattern.as_str())
}
};
!self.ignored
&& (self.filters.is_empty() || self.filters.iter().any(matches))
&& !self.skip.iter().any(matches)
}
}
fn main() -> ExitCode {
ensure_one_rayon_worker();
let args = Args::parse(std::env::args().skip(1));
let selected: Vec<_> = CHECKS
.iter()
.filter(|(name, _)| args.selects(name))
.collect();
if args.list {
for (name, _) in &selected {
println!("{name}: test");
}
return ExitCode::SUCCESS;
}
println!("\nrunning {} tests", selected.len());
let mut failed = Vec::new();
for (name, check) in &selected {
let passed = std::panic::catch_unwind(*check).is_ok();
println!("test {name} ... {}", if passed { "ok" } else { "FAILED" });
if !passed {
failed.push(*name);
}
}
if !failed.is_empty() {
println!("\nfailures:");
for name in &failed {
println!(" {name}");
}
}
println!(
"\ntest result: {}. {} passed; {} failed; 0 ignored; 0 measured; {} filtered out\n",
if failed.is_empty() { "ok" } else { "FAILED" },
selected.len() - failed.len(),
failed.len(),
CHECKS.len() - selected.len(),
);
if failed.is_empty() {
ExitCode::SUCCESS
} else {
ExitCode::from(101)
}
}
fn arguments_select_as_libtest_does() {
let parse = |args: &[&str]| Args::parse(args.iter().map(|arg| (*arg).to_owned()));
let names = ["hessian_allocs_after_warmup", "sparse_allocs_after_warmup"];
let picked = |args: &Args| -> Vec<&str> {
names
.iter()
.copied()
.filter(|name| args.selects(name))
.collect()
};
assert_eq!(picked(&parse(&[])), names);
assert_eq!(
picked(&parse(&["hessian"])),
["hessian_allocs_after_warmup"]
);
assert_eq!(picked(&parse(&["--exact", "hessian"])), Vec::<&str>::new());
assert_eq!(
picked(&parse(&["--exact", "sparse_allocs_after_warmup"])),
["sparse_allocs_after_warmup"]
);
for skip in [&["--skip", "hessian"][..], &["--skip=hessian"]] {
assert_eq!(
picked(&parse(skip)),
["sparse_allocs_after_warmup"],
"{skip:?}"
);
}
assert_eq!(picked(&parse(&["--ignored"])), Vec::<&str>::new());
for flags in [
&[
"--test-threads",
"4",
"--shuffle-seed",
"7",
"--color",
"never",
][..],
&["--test-threads=4", "--nocapture", "-q", "--format=terse"],
] {
assert_eq!(picked(&parse(flags)), names, "{flags:?}");
}
assert!(parse(&["--list"]).list);
}