lds-rs 0.1.10

Low-Discrepancy Sequence (LDS) Generator in Rust
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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

//! Memory usage profiling for lds-gen generators.
//!
//! Prints stack sizes (via size_of) and heap usage (via dhat).
//!
//! Run:
//!   cargo run --example profile_memory
//!
//! dhat writes `dhat-heap.json` at exit; view with:
//!   cargo install dhat-view  &&  dhat-view dhat-heap.json

use std::mem::size_of;

use dhat::{HeapStats, Profiler};
use lds_rs::sphere_n::{Sphere3, SphereGen, SphereN};
use lds_rs::{Circle, Disk, Halton, HaltonN, Sphere, Sphere3Hopf, VdCorput};

#[global_allocator]
static ALLOC: dhat::Alloc = dhat::Alloc;

fn main() {
    let _profiler = Profiler::new_heap();

    println!("=== Stack size per struct (bytes) ===\n");

    println!("  VdCorput:    {:>4}", size_of::<VdCorput>());
    println!("  Halton:      {:>4}", size_of::<Halton>());
    println!("  Circle:      {:>4}", size_of::<Circle>());
    println!("  Disk:        {:>4}", size_of::<Disk>());
    println!("  Sphere:      {:>4}", size_of::<Sphere>());
    println!("  Sphere3Hopf: {:>4}", size_of::<Sphere3Hopf>());
    println!("  HaltonN:     {:>4}", size_of::<HaltonN>());
    println!("  Sphere3:     {:>4}", size_of::<Sphere3>());
    println!("  SphereN:     {:>4}", size_of::<SphereN>());
    println!();

    // ------------------------------------------------------------------
    // Heap: exercise all the generators and observe allocations
    // ------------------------------------------------------------------
    println!("=== Generating samples (heap actively tracked) ===\n");

    let mut vgen = VdCorput::new(2);
    vgen.reseed(0);
    for _ in 0..1000 {
        let _ = vgen.pop();
    }

    let mut hgen = Halton::new([2, 3]);
    hgen.reseed(0);
    for _ in 0..500 {
        let _ = hgen.pop();
    }

    let mut cgen = Circle::new(2);
    cgen.reseed(0);
    for _ in 0..500 {
        let _ = cgen.pop();
    }

    let mut dgen = Disk::new([2, 3]);
    dgen.reseed(0);
    for _ in 0..500 {
        let _ = dgen.pop();
    }

    let mut sgen = Sphere::new([2, 3]);
    sgen.reseed(0);
    for _ in 0..500 {
        let _ = sgen.pop();
    }

    let mut h3gen = Sphere3Hopf::new([2, 3, 5]);
    h3gen.reseed(0);
    for _ in 0..500 {
        let _ = h3gen.pop();
    }

    // Sphere3 — exercise both instances to verify shared tables
    let mut sp3_1: Box<dyn SphereGen> = Box::new(Sphere3::new(&[2, 3, 5]));
    sp3_1.reseed(0);
    let mut sp3_2: Box<dyn SphereGen> = Box::new(Sphere3::new(&[5, 7, 11]));
    sp3_2.reseed(0);
    for _ in 0..500 {
        let _ = sp3_1.pop();
        let _ = sp3_2.pop();
    }

    // SphereN with 3 levels (n=3) — verify Arc sharing between instances
    let mut spn_1: Box<dyn SphereGen> = Box::new(SphereN::new(&[2, 3, 5, 7]));
    spn_1.reseed(0);
    let mut spn_2: Box<dyn SphereGen> = Box::new(SphereN::new(&[5, 7, 11, 13]));
    spn_2.reseed(0);
    for _ in 0..500 {
        let _ = spn_1.pop();
        let _ = spn_2.pop();
    }

    // HaltonN
    let bases = &[2, 3, 5, 7, 11, 13];
    let mut hn = HaltonN::new(bases);
    hn.reseed(0);
    for _ in 0..500 {
        let _ = hn.pop();
    }

    let stats = HeapStats::get();
    println!("=== dhat HeapStats ===\n");
    println!(
        "  Total bytes allocated (cumulative): {:>10}",
        stats.total_bytes
    );
    println!(
        "  Total blocks allocated (cumulative): {:>10}",
        stats.total_blocks
    );
    println!(
        "  Max bytes live at any point:        {:>10}",
        stats.max_bytes
    );
    println!(
        "  Current bytes in use:               {:>10}",
        stats.curr_bytes
    );
    println!(
        "  Current blocks in use:              {:>10}",
        stats.curr_blocks
    );
    println!();
    println!("dhat-heap.json written at exit. View with `dhat-view dhat-heap.json`.");
}