Incremental GC

default.nix

@@ -361,12 +361,7 @@ rec {
       (test_subdir dir deps).overrideAttrs (args: {
           EXTRA_MOC_ARGS = "--sanity-checks";
       });
-
-    compacting_gc_subdir = dir: deps:
-      (test_subdir dir deps).overrideAttrs (args: {
-          EXTRA_MOC_ARGS = "--compacting-gc";
-      });
-
+
     generational_gc_subdir = dir: deps:
       (test_subdir dir deps).overrideAttrs (args: {
           EXTRA_MOC_ARGS = "--generational-gc";
@@ -382,6 +377,10 @@ rec {
           EXTRA_MOC_ARGS = "--sanity-checks --generational-gc";
       });
 
+    snty_incremental_gc_subdir = dir: deps:
+      (test_subdir dir deps).overrideAttrs (args: {
+          EXTRA_MOC_ARGS = "--sanity-checks --incremental-gc";
+      });
 
     perf_subdir = dir: deps:
       (test_subdir dir deps).overrideAttrs (args: {
@@ -498,6 +497,7 @@ rec {
       drun-dbg   = snty_subdir "run-drun"   [ moc nixpkgs.drun ];
       drun-compacting-gc = snty_compacting_gc_subdir "run-drun" [ moc nixpkgs.drun ] ;
       drun-generational-gc = snty_generational_gc_subdir "run-drun" [ moc nixpkgs.drun ] ;
+      drun-incremental-gc = snty_incremental_gc_subdir "run-drun" [ moc nixpkgs.drun ] ;
       fail       = test_subdir "fail"       [ moc ];
       repl       = test_subdir "repl"       [ moc ];
       ld         = test_subdir "ld"         ([ mo-ld ] ++ ldTestDeps);

doc/md/compiler-ref.md

@@ -34,6 +34,7 @@ You can use the following options with the `moc` command.
 | `-help`,`--help`                          | Displays usage information.                                                                                                                           |
 | `--hide-warnings`                         | Hides compiler warnings.                                                                                                                              |
 | `-Werror`                                 | Treat warnings as errors.                                                                                                                             |
+| `--incremental-gc`                        | Use incremental GC                                                                                                                                    |
 | `--idl`                                   | Compile binary and emit Candid IDL specification to `.did` file.                                                                                      |
 | `-i`                                      | Runs the compiler in an interactive read–eval–print loop (REPL) shell so you can evaluate program execution (implies -r).                             |
 | `--map`                                   | Outputs a JavaScript source map.                                                                                                                      |

rts/motoko-rts-tests/src/continuation_table.rs

@@ -1,9 +1,12 @@
+use std::array::from_fn;
+
 use crate::memory::TestMemory;
 
 use motoko_rts::continuation_table::{
     continuation_count, recall_continuation, remember_continuation,
 };
-use motoko_rts::types::{Value, Words};
+use motoko_rts::memory::alloc_blob;
+use motoko_rts::types::{size_of, Array, Blob, Bytes, Value, Words};
 
 pub unsafe fn test() {
     println!("Testing continuation table ...");
@@ -13,36 +16,35 @@ pub unsafe fn test() {
     const N: usize = 2000; // >256, to exercise `double_continuation_table`
 
     // Array will be doubled 3 times, so 256 + 512 + 1024 + 2048 = 3840 words, plus each array will
-    // have 2 word header.
-    let mut heap = TestMemory::new(Words(3848));
+    // have an array header. Also add the set of N pointers to empty blobs.
+    let mut heap = TestMemory::new(Words(
+        3840 + 4 * size_of::<Array>().to_bytes().as_u32()
+            + N as u32 * size_of::<Blob>().to_bytes().as_u32(),
+    ));
+
+    let pointers: [Value; N] = from_fn(|_| alloc_blob(&mut heap, Bytes(0)));
 
     let mut references: [u32; N] = [0; N];
     for i in 0..N {
-        references[i] = remember_continuation(
-            &mut heap,
-            Value::from_raw(((i as u32) << 2).wrapping_sub(1)),
-        );
+        references[i] = remember_continuation(&mut heap, pointers[i]);
         assert_eq!(continuation_count(), (i + 1) as u32);
     }
 
     for i in 0..N / 2 {
         let c = recall_continuation(references[i]);
-        assert_eq!(c.get_raw(), (i << 2).wrapping_sub(1) as u32);
+        assert_eq!(c.get_ptr(), pointers[i].get_ptr());
         assert_eq!(continuation_count(), (N - i - 1) as u32);
     }
 
     for i in 0..N / 2 {
-        references[i] = remember_continuation(
-            &mut heap,
-            Value::from_raw(((i as u32) << 2).wrapping_sub(1)),
-        );
+        references[i] = remember_continuation(&mut heap, pointers[i]);
         assert_eq!(continuation_count(), (N / 2 + i + 1) as u32);
     }
 
     for i in (0..N).rev() {
         assert_eq!(
-            recall_continuation(references[i]).get_raw(),
-            (i << 2).wrapping_sub(1) as u32,
+            recall_continuation(references[i]).get_ptr(),
+            pointers[i].get_ptr(),
         );
         assert_eq!(continuation_count(), i as u32);
     }