oximo 0.6.0

A Rust algebraic modeling library for solving optimization problems
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

use criterion::Criterion;

#[cfg(feature = "_benchmark-enzyme")]
use super::common::{pair, sizes};

#[cfg(feature = "_benchmark-enzyme")]
/// Measure Enzyme evaluator classification and parameter-refresh preprocessing.
pub fn bench(criterion: &mut Criterion) {
    use std::hint::black_box;

    use criterion::{BenchmarkId, Throughput};
    use oximo_autodiff::benchmark_support;

    // Measures initial FunctionSlot classification for LP, QCP, and NLP rows.
    let mut classify = criterion.benchmark_group("preprocessing/enzyme_classification");
    for (kind, degree) in [("lp", 1), ("qcp", 2), ("nlp", 3)] {
        for (size, rows) in sizes(benchmark_support::THRESHOLD) {
            let model = benchmark_support::model(rows, degree);
            pair(
                &mut classify,
                &format!("{kind}/{size}/{rows}"),
                rows,
                &model,
                benchmark_support::classify,
            );
        }
    }
    classify.finish();

    // Measures reclassification of existing slots during evaluator refresh.
    let mut refresh = criterion.benchmark_group("preprocessing/enzyme_refresh");
    for (kind, degree) in [("lp", 1), ("qcp", 2), ("nlp", 3)] {
        for (size, rows) in sizes(benchmark_support::THRESHOLD) {
            let model = benchmark_support::model(rows, degree);
            let mut serial = benchmark_support::Refresh::new(&model);
            let mut parallel = benchmark_support::Refresh::new(&model);
            let case = format!("{kind}/{size}/{rows}");
            refresh.throughput(Throughput::Elements(rows as u64));
            refresh.bench_function(BenchmarkId::new(&case, "serial"), |bencher| {
                bencher.iter(|| black_box(serial.run(&model, false)));
            });
            refresh.bench_function(
                BenchmarkId::new(&case, format!("parallel-{}t", rayon::current_num_threads())),
                |bencher| {
                    bencher.iter(|| black_box(parallel.run(&model, true)));
                },
            );
        }
    }
    refresh.finish();
}

#[cfg(not(feature = "_benchmark-enzyme"))]
/// Leave the Enzyme groups absent unless the nightly-only feature is enabled.
pub fn bench(_criterion: &mut Criterion) {}