Skip to main content

bench/
bench.rs

1use std::sync::atomic::AtomicBool;
2use std::time::Instant;
3
4use rand::Rng;
5use spin_sim::config::*;
6use spin_sim::{run_sweep_parallel, Lattice, Realization};
7
8const L: usize = 128;
9const N_TEMPS: usize = 16;
10const N_REPLICAS: usize = 2;
11const N_SWEEPS: usize = 50;
12const N_REALIZATIONS: usize = 100;
13
14fn main() {
15    let lattice = Lattice::new(vec![L, L]);
16    let n_spins = lattice.n_spins;
17    let n_neighbors = lattice.n_neighbors;
18
19    let temps: Vec<f32> = (0..N_TEMPS)
20        .map(|i| 0.1 * (50.0f32).powf(i as f32 / (N_TEMPS - 1) as f32))
21        .collect();
22
23    let n_pairs = N_REPLICAS / 2;
24    let n_systems = N_REPLICAS * N_TEMPS;
25    let rngs_per_real = n_systems + N_TEMPS * n_pairs;
26
27    let mut rng = rand::thread_rng();
28    let mut realizations = Vec::with_capacity(N_REALIZATIONS);
29    for r in 0..N_REALIZATIONS {
30        let couplings: Vec<f32> = (0..n_spins * n_neighbors)
31            .map(|_| if rng.gen::<bool>() { 1.0 } else { -1.0 })
32            .collect();
33        let base_seed = 42 + (r * rngs_per_real) as u64;
34        realizations.push(Realization::new(
35            &lattice, couplings, &temps, N_REPLICAS, base_seed,
36        ));
37    }
38
39    let interrupted = AtomicBool::new(false);
40
41    let config = SimConfig {
42        n_sweeps: N_SWEEPS,
43        warmup_sweeps: 0,
44        sweep_mode: SweepMode::Metropolis,
45        cluster_update: None,
46        pt_interval: Some(1),
47        overlap_cluster: Some(OverlapClusterConfig {
48            interval: 1,
49            modes: vec![OverlapClusterBuildMode::Cmr],
50            cluster_mode: ClusterMode::Sw,
51            collect_stats: false,
52            snapshot_interval: None,
53        }),
54        autocorrelation_max_lag: None,
55        sequential: false,
56        equilibration_diagnostic: false,
57    };
58
59    println!(
60        "Lattice: {}x{}  |  Temps: {}  |  Replicas: {}  |  Sweeps: {}  |  Realizations: {}",
61        L, L, N_TEMPS, N_REPLICAS, N_SWEEPS, N_REALIZATIONS
62    );
63    println!("Config: bimodal, CMR, SW overlap, PT every sweep");
64    println!("{}", "-".repeat(70));
65
66    let t0 = Instant::now();
67    run_sweep_parallel(
68        &lattice,
69        &mut realizations,
70        N_REPLICAS,
71        N_TEMPS,
72        &config,
73        &interrupted,
74        &|| {},
75    )
76    .unwrap();
77    let elapsed = t0.elapsed().as_secs_f64();
78
79    let per_sweep = elapsed / N_SWEEPS as f64 * 1000.0;
80    println!("Total: {:.3} s  |  {:.3} ms/sweep", elapsed, per_sweep);
81}