Replace FragmentedMapper with TwoLevelMmapper (#1337)

This PR replaces `FragmentedMapper` with `TwoLevelMmapper`.

`TwoLevelMmapper` does not use hash tables. It is also lock-free when
looking up `MapState` entries, and also lock-free when lazily
initializing slabs. It is intended to eliminate the pathological case of
`FragmentedMapper` where a hash collision can result in a long-distance
linear scan and many locking operations.

Fixes: #1336

Author: wks

benches/mock_bench/mmapper.rs

@@ -0,0 +1,72 @@
+pub use criterion::Criterion;
+
+use mmtk::{
+    memory_manager,
+    util::{test_util::fixtures::*, Address},
+};
+
+pub fn bench(c: &mut Criterion) {
+    let mut fixture = MutatorFixture::create_with_heapsize(1 << 30);
+
+    let regular = memory_manager::alloc(
+        &mut fixture.mutator,
+        40,
+        0,
+        0,
+        mmtk::AllocationSemantics::Default,
+    );
+
+    let large = memory_manager::alloc(
+        &mut fixture.mutator,
+        40,
+        0,
+        0,
+        mmtk::AllocationSemantics::Los,
+    );
+
+    let low = unsafe { Address::from_usize(42usize) };
+    let high = unsafe { Address::from_usize(usize::MAX - 1024usize) };
+
+    c.bench_function("is_mapped_regular", |b| {
+        b.iter(|| {
+            let is_mapped = regular.is_mapped();
+            assert!(is_mapped);
+        })
+    });
+
+    c.bench_function("is_mapped_large", |b| {
+        b.iter(|| {
+            let is_mapped = large.is_mapped();
+            assert!(is_mapped);
+        })
+    });
+
+    c.bench_function("is_mapped_low", |b| {
+        b.iter(|| {
+            let is_mapped = low.is_mapped();
+            assert!(!is_mapped);
+        })
+    });
+
+    c.bench_function("is_mapped_high", |b| {
+        b.iter(|| {
+            let is_mapped = high.is_mapped();
+            assert!(!is_mapped);
+        })
+    });
+
+    // The following bench involves large address ranges and cannot run on 32-bit machines.
+    #[cfg(target_pointer_width = "64")]
+    c.bench_function("is_mapped_seq", |b| {
+        b.iter(|| {
+            use mmtk::util::heap::vm_layout::BYTES_IN_CHUNK;
+            let start = regular.as_usize();
+            let num_chunks = 16384usize;
+            let end = start + num_chunks * BYTES_IN_CHUNK;
+            for addr_usize in (start..end).step_by(BYTES_IN_CHUNK) {
+                let addr = unsafe { Address::from_usize(addr_usize) };
+                let _is_mapped = addr.is_mapped();
+            }
+        })
+    });
+}

benches/mock_bench/mod.rs

@@ -2,6 +2,7 @@ use criterion::Criterion;
 
 pub mod alloc;
 pub mod internal_pointer;
+pub mod mmapper;
 pub mod sft;
 
 // As we can only initialize one MMTk instance, we have to run each benchmark in a separate process.
@@ -26,6 +27,7 @@ pub fn bench(c: &mut Criterion) {
         Ok(bench) => match bench.as_str() {
             "alloc" => alloc::bench(c),
             "internal_pointer" => internal_pointer::bench(c),
+            "mmapper" => mmapper::bench(c),
             "sft" => sft::bench(c),
             _ => panic!("Unknown benchmark {:?}", bench),
         },

src/util/heap/layout/mod.rs

@@ -5,7 +5,7 @@ mod mmapper;
 pub use self::mmapper::Mmapper;
 mod byte_map_mmapper;
 #[cfg(target_pointer_width = "64")]
-mod fragmented_mapper;
+mod two_level_mmapper;
 
 mod map;
 pub(crate) use self::map::CreateFreeListResult;
@@ -37,7 +37,7 @@ pub fn create_mmapper() -> Box<dyn Mmapper + Send + Sync> {
 #[cfg(target_pointer_width = "64")]
 pub fn create_mmapper() -> Box<dyn Mmapper + Send + Sync> {
     // TODO: ByteMapMmapper for 39-bit or less virtual space
-    Box::new(fragmented_mapper::FragmentedMapper::new())
+    Box::new(two_level_mmapper::TwoLevelMmapper::new())
 }
 
 use crate::util::Address;