mmtk 0.32.0

MMTk is a framework for the design and implementation of high-performance and portable memory managers.
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

// GITHUB-CI: MMTK_PLAN=all

use lazy_static::lazy_static;

use super::mock_test_prelude::*;
use crate::plan::AllocationSemantics;

lazy_static! {
    static ref MUTATOR: Fixture<MutatorFixture> = Fixture::new();
}

#[test]
pub fn allocate_alignment() {
    with_mockvm(
        default_setup,
        || {
            MUTATOR.with_fixture_mut(|fixture| {
                let min = MockVM::MIN_ALIGNMENT;
                let max = MockVM::MAX_ALIGNMENT;
                info!("Allowed alignment between {} and {}", min, max);
                let mut align = min;
                while align <= max {
                    info!("Test allocation with alignment {}", align);
                    let addr = memory_manager::alloc(
                        &mut fixture.mutator,
                        8,
                        align,
                        0,
                        AllocationSemantics::Default,
                    );
                    assert!(
                        addr.is_aligned_to(align),
                        "Expected allocation alignment {}, returned address is {:?}",
                        align,
                        addr
                    );
                    align *= 2;
                }
            })
        },
        no_cleanup,
    )
}

#[test]
pub fn allocate_offset() {
    with_mockvm(
        default_setup,
        || {
            MUTATOR.with_fixture_mut(|fixture| {
                const OFFSET: usize = 4;
                let min = MockVM::MIN_ALIGNMENT;
                let max = MockVM::MAX_ALIGNMENT;
                info!("Allowed alignment between {} and {}", min, max);
                let mut align = min;
                while align <= max {
                    info!(
                        "Test allocation with alignment {} and offset {}",
                        align, OFFSET
                    );
                    let addr = memory_manager::alloc(
                        &mut fixture.mutator,
                        8,
                        align,
                        OFFSET,
                        AllocationSemantics::Default,
                    );
                    assert!(
                        (addr + OFFSET).is_aligned_to(align),
                        "Expected allocation alignment {}, returned address is {:?}",
                        align,
                        addr
                    );
                    align *= 2;
                }
            });
        },
        no_cleanup,
    )
}