Grow the heap if need be (#186)

Fix #162

compiler_tests.py

···
     def test_match_heap_variant(self) -> None:
         self.assertEqual(self._run("f #bar 1 . f = | # bar 1 -> 3 | # foo () -> 4"), "3\n")
 
+    @unittest.skipIf("STATIC_HEAP" in os.environ.get("CFLAGS", ""), "Can't grow heap in static heap mode")
+    def test_heap_growth(self) -> None:
+        self.assertEqual(
+            self._run(
+                """
+countdown 1000
+. countdown =
+| 0 -> []
+| n -> n >+ countdown (n - 1)
+"""
+            ),
+            "[" + ", ".join(str(i) for i in range(1000, 0, -1)) + "]\n",
+        )
+
 
 if __name__ == "__main__":
     unittest.main()

runtime.c

···
   uintptr_t limit;
   uintptr_t from_space;
   uintptr_t to_space;
-  size_t size;
+  struct space space;
 };
 
 static uintptr_t align(uintptr_t val, uintptr_t alignment) {
···
             space.size, kPageSize);
     abort();
   }
-  heap->size = space.size;
+  heap->space = space;
   heap->to_space = heap->hp = space.start;
   heap->from_space = heap->limit = heap->hp + space.size / 2;
 }
···
   heap->hp = heap->from_space;
   heap->from_space = heap->to_space;
   heap->to_space = heap->hp;
-  heap->limit = heap->hp + heap->size / 2;
+  heap->limit = heap->hp + heap->space.size / 2;
 }
 
 struct object* heap_tag(uintptr_t addr) {
···
     struct gc_obj* obj = (struct gc_obj*)scan;
     scan += align_size(trace_heap_object(obj, heap, visit_field));
   }
+  // TODO(max): If we have < 25% heap utilization, shrink the heap
 #ifndef NDEBUG
   // Zero out the rest of the heap for debugging
   memset((void*)scan, 0, heap->limit - scan);
···
 #endif
 #define ALLOCATOR __attribute__((__malloc__))
 
-static NEVER_INLINE ALLOCATOR struct object* allocate_slow_path(
-    struct gc_heap* heap, size_t size) {
-  // size is already aligned
+#ifndef STATIC_HEAP
+static NEVER_INLINE void heap_grow(struct gc_heap* heap) {
+  struct space old_space = heap->space;
+  struct space new_space = make_space(old_space.size * 2);
+  init_heap(heap, new_space);
   collect(heap);
-  if (UNLIKELY(heap->limit - heap->hp < size)) {
-    fprintf(stderr, "out of memory\n");
-    abort();
-  }
-  uintptr_t addr = heap->hp;
-  uintptr_t new_hp = align_size(addr + size);
-  heap->hp = new_hp;
-  return heap_tag(addr);
+  destroy_space(old_space);
 }
+#endif
 
 bool is_power_of_two(uword x) { return (x & (x - 1)) == 0; }
 
···
 
 bool obj_has_tag(struct gc_obj* obj, byte tag) { return obj_tag(obj) == tag; }
 
+static NEVER_INLINE void allocate_slow_path(struct gc_heap* heap, uword size) {
+#ifndef STATIC_HEAP
+  heap_grow(heap);
+#endif
+  // size is already aligned
+  if (UNLIKELY(heap->limit - heap->hp < size)) {
+    fprintf(stderr, "out of memory\n");
+    abort();
+  }
+}
+
 static ALWAYS_INLINE ALLOCATOR struct object* allocate(struct gc_heap* heap,
                                                        uword tag, uword size) {
   assert(is_aligned(size, 1 << kPrimaryTagBits) && "need 3 bits for tagging");
   uintptr_t addr = heap->hp;
   uintptr_t new_hp = align_size(addr + size);
   if (UNLIKELY(heap->limit < new_hp)) {
-    return allocate_slow_path(heap, size);
+    allocate_slow_path(heap, size);
+    addr = heap->hp;
+    new_hp = align_size(addr + size);
   }
   heap->hp = new_hp;
   ((struct gc_obj*)addr)->tag = make_tag(tag, size);
···
   as_variant(variant)->value = value;
 }
 
-#define MAX_HANDLES 1024
+#define MAX_HANDLES 4096
 
 struct handle_scope {
   struct object*** base;