Add memory limits to gc tests (#313)

examples/gc/allocating-in-nested-functions/program.cac

@@ -1,11 +1,17 @@
 # 10000 nested function calls, each of which allocates 128B on the heap
 
+foreign get_current_heap_space: [] -> Int;
+foreign cassert : [Bool] -> Unit;
+
+let memoryLimit = 16 * 1024;
+
 let struct_128 = {
     a=1, b=2, c=3, d=4, e=5, f=6, g=7, h=8,
     i=9, j=10, k=11, l=12, m=13, n=14, o=15, p=16
 };
 
 let allocateRecursively = [depth: Int] -> Int => (
+    cassert[(get_current_heap_space[] <= memoryLimit)];
     if (depth == 0) then return 0
     else (
         let newPtr = $struct_128;

examples/gc/allocation-of-structures/program.cac

@@ -1,3 +1,8 @@
+foreign get_current_heap_space: [] -> Int;
+foreign cassert : [Bool] -> Unit;
+
+let memoryLimit = 60 * 1024;
+
 let struct_128 = {
     a=1, b=2, c=3, d=4, e=5, f=6, g=7, h=8,
     i=9, j=10, k=11, l=12, m=13, n=14, o=15, p=16
@@ -10,6 +15,7 @@ let struct_512 = {
 let i = 0;
 let ref = $struct_512;
 while i < 10000 do (
+    cassert[(get_current_heap_space[] <= memoryLimit)];
     ref = $struct_512;
     @ref;
     i=i+1;

examples/gc/assignment-to-reference-in-loop/program.cac

@@ -1,6 +1,12 @@
+foreign get_current_heap_space: [] -> Int;
+foreign cassert : [Bool] -> Unit;
+
+let memoryLimit = 4 * 1024;
+
 let i = 0;
 let ref: &Int = $1;
 while i < 1000000 do (
+    cassert[(get_current_heap_space[] <= memoryLimit)];
     ref = $1; # reassigning pointer should mark memory as unreachable
     i=i+1;
 );

examples/gc/different-liveness/program.cac

@@ -1,3 +1,8 @@
+foreign get_current_heap_space: [] -> Int;
+foreign cassert : [Bool] -> Unit;
+
+let memoryLimit = 4 * 1024;
+
 let ref1 = $1;
 let ref2 = $1;
 let ref3 = $1;
@@ -9,6 +14,7 @@ let ref8 = $1;
 
 let i = 0;
 while i < 1000000 do (
+    cassert[(get_current_heap_space[] <= memoryLimit)];
     ref1 = $1;
     if i%4 == 0 then (ref2 = $1;);
     if i%4 == 1 then (ref3 = $1;);

examples/gc/multiple-references/program.cac

@@ -1,3 +1,8 @@
+foreign get_current_heap_space: [] -> Int;
+foreign cassert : [Bool] -> Unit;
+
+let memoryLimit = 16 * 1024;
+
 let struct_128 = {
     a=1, b=2, c=3, d=4, e=5, f=6, g=7, h=8,
     i=9, j=10, k=11, l=12, m=13, n=14, o=15, p=16
@@ -12,6 +17,7 @@ let ptr5 = $struct_128;
 let i = 0;
 
 while i < 10000 do (     # we are counting number of references to each segment of memory:
+    cassert[(get_current_heap_space[] <= memoryLimit)];
     let temp1 = ptr1;   # (r1=2), r2=1, r3=1, r4=1, r5=1
     let temp2 = ptr2;   # r1=2, (r2=2), r3=1, r4=1, r5=1
     ptr2 = $struct_128; # r1=2, r2=1, r3=1, r4=1, r5=1, (r6=1)

examples/gc/nested-references/program.cac

@@ -1,3 +1,8 @@
+foreign get_current_heap_space: [] -> Int;
+foreign cassert : [Bool] -> Unit;
+
+let memoryLimit = 4 * 1024;
+
 let struct_32 = {
     a=1, b=2, c=3, d=4
 };
@@ -7,6 +12,7 @@ let nested_ref = $$$$$$$$$$struct_32;
 let i = 0;
 
 while i < 100000 do (
+    cassert[(get_current_heap_space[] <= memoryLimit)];
     nested_ref=$$$$$$$$$$struct_32; # reassigning of pointer should free the memory at its subfields
     @@@nested_ref=$$$$$$$struct_32;
     @@@@@@nested_ref=$$$$struct_32;

examples/gc/overlapping-frames/program.cac

@@ -1,3 +1,8 @@
+foreign get_current_heap_space: [] -> Int;
+foreign cassert : [Bool] -> Unit;
+
+let memoryLimit = 4 * 1024;
+
 foreign randint : [Int, Int] -> Int;
 foreign cassert : [Bool] -> Unit;
 
@@ -25,7 +30,10 @@ let g = [a: &Int, b: &Int] -> Int => (
 );
 
 let i = 0;
+let a = $1;
+let b = $1;
 while i < 10000 do (
+    cassert[(get_current_heap_space[] <= memoryLimit)];
     i = i + 1;
     let a = $randint[100, 110];
     let b = $randint[0, 1000];
@@ -36,4 +44,7 @@ while i < 10000 do (
         let should_be_large = g[a, b];
         cassert[(should_be_large >= 100)];
     );
-);
+);
+
+i = @a;
+i = @b;

examples/gc/recursively-allocating-structs/program.cac

@@ -1,13 +1,19 @@
 # 1000 nested function calls (in 2 variants), each of which allocates 128B on the heap
 # each call uses info allocated on a child call
 
+foreign get_current_heap_space: [] -> Int;
+foreign cassert : [Bool] -> Unit;
+
+let memoryLimit = 4 * 1024;
+
 let struct_64 = {
     a=$1, b=$2, c=$3, d=$4, e=$5, f=$6, g=$7, h=$8
 };
 
 let allocateAndIncrement = [depth: Int] -> {
     a:&Int, b:&Int, c:&Int, d:&Int, e:&Int, f:&Int, g:&Int, h:&Int
 } => (
+    cassert[(get_current_heap_space[] <= memoryLimit)];
     if (depth == 0) then struct_64
     else (
         let previousStr = allocateAndIncrement[depth - 1];
@@ -32,6 +38,7 @@ let allocateAndCopy = [depth: Int, ptr: &{
 }] -> &{
     a:&Int, b:&Int, c:&Int, d:&Int, e:&Int, f:&Int, g:&Int, h:&Int
 } => (
+    cassert[(get_current_heap_space[] <= memoryLimit)];
     if (depth == 0) then ptr
     else (
         let previousPtr = allocateAndCopy[depth - 1, ptr];

examples/gc/references-in-fields/program.cac

@@ -1,3 +1,8 @@
+foreign get_current_heap_space: [] -> Int;
+foreign cassert : [Bool] -> Unit;
+
+let memoryLimit = 4 * 1024;
+
 let struct_32 = {
     a=1, b=2, c=3, d=4
 };
@@ -13,6 +18,7 @@ let struct_of_ref = {
 let i = 0;
 
 while i < 100000 do (
+    cassert[(get_current_heap_space[] <= memoryLimit)];
     struct_of_ref.r1 = $struct_32;
     struct_of_ref.r2 = $struct_32;
     struct_of_ref.r3 = $struct_32;
@@ -22,6 +28,7 @@ while i < 100000 do (
 );
 
 while i < 100000 do ( # we should also free memory when reassigning whole struct
+    cassert[(get_current_heap_space[] <= memoryLimit)];
     struct_of_ref = {r1=$struct_32, r2=$struct_32, r3=$struct_32, r4=$struct_32, r5=$struct_32};
     i = i+1;
 );

examples/gc/simple-allocation-in-function/program.cac

@@ -1,3 +1,8 @@
+foreign get_current_heap_space: [] -> Int;
+foreign cassert : [Bool] -> Unit;
+
+let memoryLimit = 4 * 1024;
+
 let empty = []->Unit=>();
 
 let f = [a: Int] -> Unit => (
@@ -8,6 +13,7 @@ let f = [a: Int] -> Unit => (
 
 let i : Int = 0;
 while (i < 1000000) do (
+    cassert[(get_current_heap_space[] <= memoryLimit)];
     f[i];
     i = i + 1;
 );

examples/gc/simple/program.cac

@@ -1,4 +1,8 @@
+foreign get_current_heap_space: [] -> Int;
+foreign cassert : [Bool] -> Unit;
+
+let memoryLimit = 4 * 1024;
+
 let x = $1;
 
-# this program is made te ensure that memory limit is enough to run
-# code with (almost) no allocations
+cassert[(get_current_heap_space[] <= memoryLimit)];

examples/gc/stack-references/program.cac

@@ -1,3 +1,8 @@
+foreign get_current_heap_space: [] -> Int;
+foreign cassert : [Bool] -> Unit;
+
+let memoryLimit = 4 * 1024;
+
 let struct_16 = {
     a=1, b=2
 };
@@ -17,6 +22,7 @@ let ptr9 = $struct_16;
 let i = 0;
 
 while i < 100000 do (
+    cassert[(get_current_heap_space[] <= memoryLimit)];
     ptr0 = $struct_16;
     ptr1 = $struct_16;
     ptr2 = $struct_16;

lib_cacophony/gc/gc.cpp

@@ -9,7 +9,7 @@
 #endif
 
 static ll getObjectSize(ll *outline) {
-    return 8 * (1 + *outline);
+    return sizeof(ll*) * (1 + *outline);
 }
 
 void memoryManager::createNewPage(int size) {
@@ -19,6 +19,17 @@ void memoryManager::createNewPage(int size) {
     ll *ptr = static_cast<ll*>(malloc(size));
     auto page = memoryPage{size, 0, ptr};
     allocated_pages.push_back(page);
+    occupied_memory += size;
+}
+
+// This step is performed during cleanup, where allocated_pages is being modified, therefore no need to modify it here.
+void memoryManager::deallocatePage(memoryPage page) {
+    occupied_memory -= page.size;
+    free(page.ptr);
+}
+
+ll memoryManager::getOccupiedMemory() {
+    return occupied_memory;
 }
 
 ll* memoryManager::allocateMemory(int size) {
@@ -55,21 +66,18 @@ std::unordered_map<ll*, ll*> memoryManager::cleanup(std::set<ll*> &alive_objects
     std::swap(pages_to_process, allocated_pages);
     std::set<ll*> processed_pages;
 
-    auto traversePage = [&](memoryPage page, auto && handler /* action to perform on each object */) {
-        for (auto it = page.ptr + 1; it < page.ptr + page.occupied / sizeof(ll*); ) {
-            handler(it);
-            ll *outline = reinterpret_cast<ll*>(*(it - 1));
-            it += (*outline + 1);
+    auto traverseAliveObjectsOnPage = [&](memoryPage page, auto && handler /* action to perform on each object */) {
+        for (auto it = alive_objects.lower_bound(page.ptr+1); it != alive_objects.end() && *it < page.ptr + page.size / sizeof(ll*); it++) {
+            handler(*it);
         }
-
     };
     for (auto &page : pages_to_process) {
-        bool is_page_untouched = true;
-        traversePage(page, [&](ll* ptr) {
-            if (alive_objects.find(ptr) == alive_objects.end())
-                is_page_untouched = false;
+        int alive_memory_size = 0;
+        traverseAliveObjectsOnPage(page, [&](ll* ptr) {
+            ll *outline = reinterpret_cast<ll*>(*(ptr - 1));
+            alive_memory_size += getObjectSize(outline);
         });
-        if (is_page_untouched) {
+        if (alive_memory_size == page.occupied) {
             allocated_pages.push_back(page);
             processed_pages.insert(page.ptr);
         }
@@ -80,16 +88,15 @@ std::unordered_map<ll*, ll*> memoryManager::cleanup(std::set<ll*> &alive_objects
             continue;
 
         std::vector<ll*> alive_objects_on_page;
-        traversePage(page, [&](ll* ptr) {
-            if (alive_objects.find(ptr) != alive_objects.end())
-                alive_objects_on_page.push_back(ptr);
+        traverseAliveObjectsOnPage(page, [&](ll* ptr) {
+            alive_objects_on_page.push_back(ptr);
         });
         if (alive_objects_on_page.empty()) {
             // Deallocate empty page or store it for later usage
             if (free_page == nullptr)
                 free_page = &page;
             else
-                free(page.ptr);
+                deallocatePage(page);
             continue;
         }
         if(allocated_pages.empty()) {
@@ -99,9 +106,7 @@ std::unordered_map<ll*, ll*> memoryManager::cleanup(std::set<ll*> &alive_objects
             } else 
                 createNewPage(MEMORY_BLOCK_SIZE);
         }
-        traversePage(page, [&](ll* ptr) {
-            if (alive_objects.find(ptr) == alive_objects.end()) 
-                return;
+        traverseAliveObjectsOnPage(page, [&](ll* ptr) {
             ll *outline = reinterpret_cast<ll*>(*(ptr - 1));
             int size = getObjectSize(outline);
             memoryPage *last_page = nullptr;
@@ -123,10 +128,10 @@ std::unordered_map<ll*, ll*> memoryManager::cleanup(std::set<ll*> &alive_objects
         if (free_page == nullptr) 
             free_page = &page;
         else
-            free(page.ptr);
+            deallocatePage(page);
     }
     if (free_page != nullptr)
-        free(free_page->ptr);
+        deallocatePage(*free_page);
     // Last page can be empty, but we don't free it, as it may be useful in next cleanup to have clean page to copy into.
 
     if(LOG_GC) {

lib_cacophony/gc/gc.h

@@ -102,6 +102,10 @@ extern "C" {
         memset(object_ptr, 0, 8 * **(object_ptr - 1));
         return object_ptr;
     }
+
+    ll get_current_heap_space() {
+        return memory_manager.getOccupiedMemory();
+    }
 }
 
 #endif /* GC_LIB_H */