Run binding tests with extreme_assertions (#392)

* Add may_trace_duplicate_edges to PlanConstraints. Duplicate edge check in extreme_assertions won't run for some plans.
* Add side metadata sanity for PageProtect. 
* Add a warning when extreme_assertions is enabled.
* Allow longer timeout for binding tests
* Add comments for how to create a plan constructor

Author: qinsoon

.github/workflows/post-review-ci.yml

@@ -52,7 +52,7 @@ jobs:
   # JikesRVM
   jikesrvm-binding-test:
     runs-on: ubuntu-18.04
-    timeout-minutes: 60
+    timeout-minutes: 90
     if: contains(github.event.pull_request.labels.*.name, 'PR-testing')
     steps:
       - name: Checkout MMTk Core
@@ -183,7 +183,7 @@ jobs:
   # OpenJDK
   openjdk-binding-test:
     runs-on: ubuntu-18.04
-    timeout-minutes: 120
+    timeout-minutes: 240
     if: contains(github.event.pull_request.labels.*.name, 'PR-testing')
     steps:
       - name: Checkout MMTk Core

docs/tutorial/code/mygc_semispace/global.rs

@@ -202,6 +202,8 @@ impl<VM: VMBinding> MyGC<VM> {
             common: CommonPlan::new(vm_map, mmapper, options, heap, &MYGC_CONSTRAINTS, global_metadata_specs.clone()),
         };
 
+        // Use SideMetadataSanity to check if each spec is valid. This is also needed for check
+        // side metadata in extreme_assertions.
         let mut side_metadata_sanity_checker = SideMetadataSanity::new();
         res.common.verify_side_metadata_sanity(&mut side_metadata_sanity_checker);
         res.copyspace0.verify_side_metadata_sanity(&mut side_metadata_sanity_checker);

src/memory_manager.rs

@@ -71,6 +71,8 @@ pub fn gc_init<VM: VMBinding>(mmtk: &'static mut MMTK<VM>, heap_size: usize) {
     mmtk.plan
         .gc_init(heap_size, &crate::VM_MAP, &mmtk.scheduler);
     info!("Initialized MMTk with {:?}", mmtk.options.plan);
+    #[cfg(feature = "extreme_assertions")]
+    warn!("The feature 'extreme_assertions' is enabled. MMTk will run expensive run-time checks. Slow performance should be expected.");
 }
 
 /// Request MMTk to create a mutator for the given thread. For performance reasons, A VM should

src/plan/gencopy/global.rs

@@ -265,6 +265,8 @@ impl<VM: VMBinding> GenCopy<VM> {
             next_gc_full_heap: AtomicBool::new(false),
         };
 
+        // Use SideMetadataSanity to check if each spec is valid. This is also needed for check
+        // side metadata in extreme_assertions.
         {
             let mut side_metadata_sanity_checker = SideMetadataSanity::new();
             res.common

src/plan/global.rs

@@ -160,6 +160,17 @@ pub fn create_plan<VM: VMBinding>(
 ///
 /// The global instance defines and manages static resources
 /// (such as memory and virtual memory resources).
+///
+/// Constructor:
+///
+/// For the constructor of a new plan, there are a few things the constructor _must_ do
+/// (please check existing plans and see what they do in the constructor):
+/// 1. Create a HeapMeta, and use this HeapMeta to initialize all the spaces.
+/// 2. Create a vector of all the side metadata specs with `SideMetadataContext::new_global_specs()`,
+///    the parameter is a vector of global side metadata specs that are specific to the plan.
+/// 3. Initialize all the spaces the plan uses with the heap meta, and the global metadata specs vector.
+/// 4. Create a `SideMetadataSanity` object, and invoke verify_side_metadata_sanity() for each space (or
+///    invoke verify_side_metadata_sanity() in `CommonPlan`/`BasePlan` for the spaces in the common/base plan).
 pub trait Plan: 'static + Sync + Downcast {
     type VM: VMBinding;
 

src/plan/marksweep/global.rs

@@ -40,6 +40,7 @@ pub const MS_CONSTRAINTS: PlanConstraints = PlanConstraints {
     gc_header_bits: 2,
     gc_header_words: 0,
     num_specialized_scans: 1,
+    may_trace_duplicate_edges: true,
     ..PlanConstraints::default()
 };
 
@@ -150,6 +151,8 @@ impl<VM: VMBinding> MarkSweep<VM> {
             ),
         };
 
+        // Use SideMetadataSanity to check if each spec is valid. This is also needed for check
+        // side metadata in extreme_assertions.
         {
             let mut side_metadata_sanity_checker = SideMetadataSanity::new();
             res.common

src/plan/nogc/global.rs

@@ -139,6 +139,8 @@ impl<VM: VMBinding> NoGC<VM> {
             ),
         };
 
+        // Use SideMetadataSanity to check if each spec is valid. This is also needed for check
+        // side metadata in extreme_assertions.
         let mut side_metadata_sanity_checker = SideMetadataSanity::new();
         res.base
             .verify_side_metadata_sanity(&mut side_metadata_sanity_checker);

src/plan/pageprotect/global.rs

@@ -148,7 +148,7 @@ impl<VM: VMBinding> PageProtect<VM> {
         let mut heap = HeapMeta::new(HEAP_START, HEAP_END);
         let global_metadata_specs = SideMetadataContext::new_global_specs(&[]);
 
-        PageProtect {
+        let ret = PageProtect {
             space: LargeObjectSpace::new(
                 "los",
                 true,
@@ -168,6 +168,19 @@ impl<VM: VMBinding> PageProtect<VM> {
                 &CONSTRAINTS,
                 global_metadata_specs,
             ),
+        };
+
+        // Use SideMetadataSanity to check if each spec is valid. This is also needed for check
+        // side metadata in extreme_assertions.
+        {
+            use crate::util::metadata::side_metadata::SideMetadataSanity;
+            let mut side_metadata_sanity_checker = SideMetadataSanity::new();
+            ret.common
+                .verify_side_metadata_sanity(&mut side_metadata_sanity_checker);
+            ret.space
+                .verify_side_metadata_sanity(&mut side_metadata_sanity_checker);
         }
+
+        ret
     }
 }

src/plan/plan_constraints.rs

@@ -19,6 +19,10 @@ pub struct PlanConstraints {
     /// Size (in bytes) beyond which copied objects must be copied to the LOS.
     /// This depends on the copy allocator.
     pub max_non_los_copy_bytes: usize,
+    /// Some plans may allow benign race for testing mark bit, and this will lead to trace the same edges
+    /// multiple times. If a plan allows tracing duplicate edges, we will not run duplicate edge check
+    /// in extreme_assertions.
+    pub may_trace_duplicate_edges: bool,
     pub barrier: BarrierSelector,
     // the following seems unused for now
     pub needs_linear_scan: bool,
@@ -39,6 +43,7 @@ impl PlanConstraints {
             needs_linear_scan: SUPPORT_CARD_SCANNING || LAZY_SWEEP,
             needs_concurrent_workers: false,
             generate_gc_trace: false,
+            may_trace_duplicate_edges: false,
             needs_forward_after_liveness: false,
             barrier: BarrierSelector::NoBarrier,
         }

src/plan/semispace/global.rs

@@ -187,6 +187,8 @@ impl<VM: VMBinding> SemiSpace<VM> {
             ),
         };
 
+        // Use SideMetadataSanity to check if each spec is valid. This is also needed for check
+        // side metadata in extreme_assertions.
         {
             let mut side_metadata_sanity_checker = SideMetadataSanity::new();
             res.common