Skip to main content

memory/
memory.rs

1//! Report heap/RSS usage for grammars, generated output and the worker pool.
2//!
3//! This example reads `/proc/self/status`, so it is intended for Linux. Run it
4//! in release mode for realistic allocator behaviour:
5//!
6//! ```text
7//! cargo run --release --example memory
8//! ```
9
10use std::fs;
11
12use resrap_rs::{Resrap, ResrapMT, templates};
13
14fn status(field: &str) -> u64 {
15    let Ok(text) = fs::read_to_string("/proc/self/status") else {
16        return 0;
17    };
18    for line in text.lines() {
19        if let Some(value) = line.strip_prefix(field) {
20            return value
21                .trim()
22                .trim_end_matches("kB")
23                .trim()
24                .parse()
25                .unwrap_or(0);
26        }
27    }
28    0
29}
30
31fn report(label: &str) {
32    println!(
33        "{label:<42} RSS {:>8} KiB   peak {:>8} KiB",
34        status("VmRSS:"),
35        status("VmHWM:")
36    );
37}
38
39fn main() {
40    report("baseline");
41
42    let mut resrap = Resrap::new();
43    for lang in templates::Lang::ALL {
44        templates::load(&mut resrap, lang).unwrap();
45    }
46    report("all 10 templates loaded");
47
48    let outputs: Vec<String> = (0..10_000)
49        .map(|i| resrap.generate_with_seeded("c", "program", i % 97 + 1, 200))
50        .collect();
51    let output_bytes: usize = outputs.iter().map(String::len).sum();
52    report("10,000 outputs retained (C, 200 tokens)");
53    println!(
54        "  retained output: {:.1} MiB, average {:.0} B/output",
55        output_bytes as f64 / (1024.0 * 1024.0),
56        output_bytes as f64 / outputs.len() as f64
57    );
58
59    drop(outputs);
60    report("outputs dropped");
61
62    let mut mt = ResrapMT::new(8, 4096);
63    templates::load(&mut mt, "c").unwrap();
64    mt.start_resrap();
65    let channel = mt.get_code_channel();
66
67    let jobs = 10_000;
68    for i in 0..jobs {
69        mt.generate_with_seeded(
70            &format!("job-{i}"),
71            "c",
72            "program",
73            (i as u64) % 97 + 1,
74            200,
75        )
76        .unwrap();
77    }
78    report("MT results buffered, consumer idle");
79
80    let mut received = 0usize;
81    for _ in 0..jobs {
82        received += channel.recv().unwrap().code.len();
83    }
84    report("MT results drained");
85    println!(
86        "  received output: {:.1} MiB",
87        received as f64 / (1024.0 * 1024.0)
88    );
89
90    drop(channel);
91    mt.shutdown_resrap();
92    drop(mt);
93    report("MT instance dropped");
94    // Run the long-output case last: large allocations can change glibc's
95    // mmap threshold and make later RSS figures depend on allocator history.
96    let long = resrap.generate_with_seeded("c", "program", 7, 1_000_000);
97    report("one 1M-token output retained");
98    println!(
99        "  retained output: {:.1} MiB",
100        long.len() as f64 / (1024.0 * 1024.0)
101    );
102    drop(long);
103    report("1M-token output dropped");
104}