Added all files

Author: meister

dummyvm/Cargo.toml

@@ -0,0 +1,43 @@
+[package]
+name = "mmtk_dummyvm"
+version = "0.0.1"
+authors = [" <>"]
+edition = "2021"
+
+[lib]
+name = "mmtk_dummyvm"
+# be careful - LTO is only allowed for certain crate types
+# 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
+
+[dependencies]
+mmtk = { path = "../../", version = "*" }
+libc = "0.2"
+lazy_static = "1.1"
+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"]
+nogc_lock_free=["mmtk/nogc_lock_free"]
+
+# Feature to control which benchmarks to run. See benches/main.rs
+bench_sft = []
+bench_alloc = []

dummyvm/api/mmtk.h

@@ -0,0 +1,125 @@
+// This is an example of native API for the single instance MMTk.
+
+// Note: the mmtk core does not directly provide this API. However, it provides
+// a similar multi-instance Rust API.  A VM binding should write their own C
+// header file (possibly based on this example with their own extension and
+// modification), and expose the Rust API based on their native API.
+
+#ifndef MMTK_H
+#define MMTK_H
+
+#include <stdbool.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void* MMTk_Mutator;
+
+// Initialize an MMTk instance
+extern void mmtk_init(size_t heap_size);
+
+// Request MMTk to create a new mutator for the given `tls` thread
+extern MMTk_Mutator mmtk_bind_mutator(void* tls);
+
+// Reclaim mutator that is no longer needed
+extern void mmtk_destroy_mutator(MMTk_Mutator mutator);
+
+// Flush mutator local state
+extern void mmtk_flush_mutator(MMTk_Mutator mutator);
+
+// Initialize MMTk scheduler and GC workers
+extern void mmtk_initialize_collection(void* tls);
+
+// Allow MMTk to perform a GC when the heap is full
+extern void mmtk_enable_collection();
+
+// Disallow MMTk to perform a GC when the heap is full
+extern void mmtk_disable_collection();
+
+// Allocate memory for an object
+extern void* mmtk_alloc(MMTk_Mutator mutator,
+                        size_t size,
+                        size_t align,
+                        size_t offset,
+                        int allocator);
+
+// Slowpath allocation for an object
+extern void* mmtk_alloc_slow(MMTk_Mutator mutator,
+                             size_t size,
+                             size_t align,
+                             size_t offset,
+                             int allocator);
+
+// Perform post-allocation hooks or actions such as initializing object metadata
+extern void mmtk_post_alloc(MMTk_Mutator mutator,
+                            void* refer,
+                            int bytes,
+                            int allocator);
+
+// Return if the object pointed to by `ref` is live
+extern bool mmtk_is_live_object(void* ref);
+
+// Return if the object pointed to by `ref` is in mapped memory
+extern bool mmtk_is_mapped_object(void* ref);
+
+// Return if the address pointed to by `addr` is in mapped memory
+extern bool mmtk_is_mapped_address(void* addr);
+
+// Return if object pointed to by `object` will never move
+extern bool mmtk_will_never_move(void* object);
+
+// Process an MMTk option. Return true if option was processed successfully
+extern bool mmtk_process(char* name, char* value);
+
+// Process MMTk options. Return true if all options were processed successfully
+extern bool mmtk_process_bulk(char* options);
+
+// Sanity only. Scan heap for discrepancies and errors
+extern void mmtk_scan_region();
+
+// Request MMTk to trigger a GC. Note that this may not actually trigger a GC
+extern void mmtk_handle_user_collection_request(void* tls);
+
+// Run the main loop for the GC controller thread. Does not return
+extern void mmtk_start_control_collector(void* tls, void* worker);
+
+// Run the main loop for a GC worker. Does not return
+extern void mmtk_start_worker(void* tls, void* worker);
+
+// Return the current amount of free memory in bytes
+extern size_t mmtk_free_bytes();
+
+// Return the current amount of used memory in bytes
+extern size_t mmtk_used_bytes();
+
+// Return the current amount of total memory in bytes
+extern size_t mmtk_total_bytes();
+
+// Return the starting address of MMTk's heap
+extern void* mmtk_starting_heap_address();
+
+// Return the ending address of MMTk's heap
+extern void* mmtk_last_heap_address();
+
+// Add a reference to the list of weak references
+extern void mmtk_add_weak_candidate(void* ref);
+
+// Add a reference to the list of soft references
+extern void mmtk_add_soft_candidate(void* ref);
+
+// Add a reference to the list of phantom references
+extern void mmtk_add_phantom_candidate(void* ref);
+
+// Generic hook to allow benchmarks to be harnessed
+extern void mmtk_harness_begin(void* tls);
+
+// Generic hook to allow benchmarks to be harnessed
+extern void mmtk_harness_end();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // MMTK_H

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);

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);

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);

dummyvm/src/active_plan.rs

@@ -0,0 +1,25 @@
+use crate::DummyVM;
+use mmtk::util::opaque_pointer::*;
+use mmtk::vm::ActivePlan;
+use mmtk::Mutator;
+
+pub struct VMActivePlan {}
+
+impl ActivePlan<DummyVM> for VMActivePlan {
+    fn number_of_mutators() -> usize {
+        unimplemented!()
+    }
+
+    fn is_mutator(_tls: VMThread) -> bool {
+        // FIXME
+        true
+    }
+
+    fn mutator(_tls: VMMutatorThread) -> &'static mut Mutator<DummyVM> {
+        unimplemented!()
+    }
+
+    fn mutators<'a>() -> Box<dyn Iterator<Item = &'a mut Mutator<DummyVM>> + 'a> {
+        unimplemented!()
+    }
+}