beamr 0.3.13

A Rust runtime with the BEAM's execution model, targeting Gleam
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

//! End-to-end GC pressure tests for interpreter heap checks.

use std::{collections::HashMap, time::Instant};

use beamr::{
    atom::Atom,
    interpreter::{ExecutionResult, run},
    loader::Instruction,
    loader::decode::compact::Operand,
    module::Module,
    process::{ExitReason, Process},
    term::{Term, boxed::Cons},
};

fn module(code: Vec<Instruction>) -> Module {
    let label_index = code
        .iter()
        .enumerate()
        .filter_map(|(i, instr)| {
            if let Instruction::Label { label } = instr {
                Some((*label, i))
            } else {
                None
            }
        })
        .collect();
    Module {
        name: Atom::OK,
        generation: 0,
        exports: HashMap::new(),
        label_index,
        code,
        literals: Vec::new(),
        resolved_imports: Vec::new(),
        lambdas: Vec::new(),
        string_table: Vec::new(),
        line_info: Vec::new(),
    }
}

#[test]
fn interpreter_survives_10_000_allocations_under_gc_pressure() {
    let mut code = vec![Instruction::Move {
        source: Operand::Atom(None),
        destination: Operand::X(0),
    }];
    for value in 0..10_000 {
        code.push(Instruction::TestHeap {
            heap_need: Operand::Unsigned(2),
            live: Operand::Unsigned(1),
        });
        code.push(Instruction::PutList {
            head: Operand::Integer(value),
            tail: Operand::X(0),
            destination: Operand::X(0),
        });
    }
    code.push(Instruction::Return);
    let module = module(code);
    let mut process = Process::new(1, 2_048);
    process.reset_reductions(100_000);
    process.heap_mut().set_max_capacity(32_768);

    let start = Instant::now();
    let result = run(&mut process, &module);

    assert_eq!(result, Ok(ExecutionResult::Exited(ExitReason::Normal)));
    assert!(start.elapsed().as_secs_f64() < 5.0);
    assert_eq!(list_len(process.x_reg(0)), 10_000);
    assert!(process.heap().old_used() > 0);
}

fn list_len(mut term: Term) -> usize {
    let mut len = 0;
    while term.is_list() {
        let cons = Cons::new(term).expect("valid cons cell");
        len += 1;
        term = cons.tail();
    }
    assert!(term.is_nil());
    len
}