Benchmark Rust code (#933)

This PR allows benchmarking mmtk-core code in DummyVM. It uses
`criterion`, which is a popular framework to benchmark with a stable
Rust toolchain. This PR just introduces code and two benchmarks that
specifically test our allocation code in Rust and our SFT read access.
This PR does not include those benchmarks in the CI.

Author: qinsoon

vmbindings/dummyvm/Cargo.toml

@@ -7,7 +7,9 @@ edition = "2021"
 [lib]
 name = "mmtk_dummyvm"
 # be careful - LTO is only allowed for certain crate types
-crate-type = ["cdylib"]
+# We know that cdylib should work for LTO.
+# We keep rlib here as we need to use the crate from benches.
+crate-type = ["cdylib", "rlib"]
 
 [profile.release]
 lto = true
@@ -20,10 +22,21 @@ atomic_refcell = "0.1.7"
 atomic = "0.4.6"
 log = "0.4"
 
+[dev-dependencies]
+criterion = "0.4"
+
+[[bench]]
+name = "main"
+harness = false
+
 [features]
 default = []
 is_mmtk_object = ["mmtk/is_mmtk_object"]
 malloc_counted_size = ["mmtk/malloc_counted_size"]
 malloc_mark_sweep = ["mmtk/malloc_mark_sweep"]
 vo_bit = ["mmtk/vo_bit"]
 extreme_assertions = ["mmtk/extreme_assertions"]
+
+# Feature to control which benchmarks to run. See benches/main.rs
+bench_sft = []
+bench_alloc = []

vmbindings/dummyvm/benches/bench_alloc.rs

@@ -0,0 +1,18 @@
+use criterion::{criterion_group, Criterion};
+
+use mmtk::plan::AllocationSemantics;
+use mmtk_dummyvm::api;
+use mmtk_dummyvm::test_fixtures::MutatorFixture;
+
+fn alloc(c: &mut Criterion) {
+    println!("Init MMTK in alloc bench");
+    // 1GB so we are unlikely to OOM
+    let fixture = MutatorFixture::create_with_heapsize(1 << 30);
+    c.bench_function("alloc", |b| {
+        b.iter(|| {
+            let _addr = api::mmtk_alloc(fixture.mutator, 8, 8, 0, AllocationSemantics::Default);
+        })
+    });
+}
+
+criterion_group!(benches, alloc);

vmbindings/dummyvm/benches/bench_sft.rs

@@ -0,0 +1,20 @@
+use criterion::{black_box, criterion_group, Criterion};
+
+use mmtk::plan::AllocationSemantics;
+use mmtk::vm::ObjectModel;
+use mmtk_dummyvm::api;
+use mmtk_dummyvm::test_fixtures::FixtureContent;
+use mmtk_dummyvm::test_fixtures::MutatorFixture;
+
+fn sft(c: &mut Criterion) {
+    println!("Init MMTK in sft bench");
+    let fixture = MutatorFixture::create();
+    let addr = api::mmtk_alloc(fixture.mutator, 8, 8, 0, AllocationSemantics::Default);
+    let obj = mmtk_dummyvm::object_model::VMObjectModel::address_to_ref(addr);
+
+    c.bench_function("sft read", |b| {
+        b.iter(|| api::mmtk_is_in_mmtk_spaces(black_box(obj)))
+    });
+}
+
+criterion_group!(benches, sft);

vmbindings/dummyvm/benches/main.rs

@@ -0,0 +1,15 @@
+use criterion::criterion_main;
+
+// As we can only initialize one MMTk instance, we have to run each benchmark separately.
+// Filtering like `cargo bench -- sft` won't work, as it still evalutes all the benchmark groups (which initialize MMTk).
+// We can use conditional compilation, and run with `cargo bench --features bench_sft`. The features are defined in the dummy VM crate.
+
+#[cfg(feature = "bench_sft")]
+mod bench_sft;
+#[cfg(feature = "bench_sft")]
+criterion_main!(bench_sft::benches);
+
+#[cfg(feature = "bench_alloc")]
+mod bench_alloc;
+#[cfg(feature = "bench_alloc")]
+criterion_main!(bench_alloc::benches);

vmbindings/dummyvm/src/lib.rs

@@ -14,6 +14,8 @@ pub mod object_model;
 pub mod reference_glue;
 pub mod scanning;
 
+pub mod test_fixtures;
+
 mod edges;
 #[cfg(test)]
 mod tests;

vmbindings/dummyvm/src/tests/fixtures/mod.rs renamed to vmbindings/dummyvm/src/test_fixtures.rs

@@ -43,6 +43,12 @@ impl<T: FixtureContent> Fixture<T> {
     }
 }
 
+impl<T: FixtureContent> Default for Fixture<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 /// SerialFixture ensures all `with_fixture()` calls will be executed serially.
 pub struct SerialFixture<T: FixtureContent> {
     content: Mutex<Option<Box<T>>>,
@@ -85,6 +91,12 @@ impl<T: FixtureContent> SerialFixture<T> {
     }
 }
 
+impl<T: FixtureContent> Default for SerialFixture<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 pub struct SingleObject {
     pub objref: ObjectReference,
 }
@@ -171,8 +183,13 @@ pub struct MutatorFixture {
 impl FixtureContent for MutatorFixture {
     fn create() -> Self {
         const MB: usize = 1024 * 1024;
-        // 1MB heap
-        mmtk_init(MB);
+        Self::create_with_heapsize(MB)
+    }
+}
+
+impl MutatorFixture {
+    pub fn create_with_heapsize(size: usize) -> Self {
+        mmtk_init(size);
         mmtk_initialize_collection(VMThread::UNINITIALIZED);
         // Make sure GC does not run during test.
         mmtk_disable_collection();

vmbindings/dummyvm/src/tests/allocate_align_offset.rs

@@ -1,7 +1,7 @@
 // GITHUB-CI: MMTK_PLAN=all
 
 use crate::api;
-use crate::tests::fixtures::{MutatorFixture, SerialFixture};
+use crate::test_fixtures::{MutatorFixture, SerialFixture};
 use crate::DummyVM;
 use log::info;
 use mmtk::plan::AllocationSemantics;

vmbindings/dummyvm/src/tests/barrier_slow_path_assertion.rs

@@ -4,8 +4,8 @@
 // Run the test with any plan that uses object barrier, and we also need both VO bit and extreme assertions.
 
 use crate::object_model::OBJECT_REF_OFFSET;
-use crate::tests::fixtures::FixtureContent;
-use crate::tests::fixtures::MMTKSingleton;
+use crate::test_fixtures::FixtureContent;
+use crate::test_fixtures::MMTKSingleton;
 use crate::{api::*, edges};
 use atomic::Atomic;
 use mmtk::util::{Address, ObjectReference};

vmbindings/dummyvm/src/tests/conservatism.rs

@@ -3,7 +3,7 @@
 
 use crate::api::*;
 use crate::object_model::OBJECT_REF_OFFSET;
-use crate::tests::fixtures::{Fixture, SingleObject};
+use crate::test_fixtures::{Fixture, SingleObject};
 use mmtk::util::constants::LOG_BITS_IN_WORD;
 use mmtk::util::is_mmtk_object::VO_BIT_REGION_SIZE;
 use mmtk::util::*;

vmbindings/dummyvm/src/tests/edges_test.rs

@@ -8,7 +8,7 @@ use mmtk::{
 
 use crate::{
     edges::{DummyVMEdge, OffsetEdge, TaggedEdge},
-    tests::fixtures::{Fixture, TwoObjects},
+    test_fixtures::{Fixture, TwoObjects},
 };
 
 #[cfg(target_pointer_width = "64")]