swiper: use free list for allocation in old gen

dinfuehr · Jan 5, 2024 · 7bd9532 · 7bd9532
1 parent 974ee7a
commit 7bd9532
Show file tree

Hide file tree

Showing 3 changed files with 61 additions and 10 deletions.
diff --git a/dora-runtime/src/gc/freelist.rs b/dora-runtime/src/gc/freelist.rs
@@ -110,6 +110,12 @@ impl FreeList {
 
         self.classes[SIZE_CLASS_HUGE.idx()].find(size)
     }
+
+    pub fn clear(&mut self) {
+        for cls in &mut self.classes {
+            cls.head = FreeSpace::null();
+        }
+    }
 }
 
 struct FreeListClass {

diff --git a/dora-runtime/src/gc/swiper/full.rs b/dora-runtime/src/gc/swiper/full.rs
@@ -186,10 +186,7 @@ impl<'a> FullCollector<'a> {
         for page in self.old_protected.pages() {
             let live = self.compute_live_on_page(page);
 
-            if live == 0 {
-                self.card_table.reset_page(page);
-                self.old_protected.free_page(page);
-            } else {
+            if live > 0 {
                 old_evacuated_pages.push((page, live));
             }
         }
@@ -247,6 +244,8 @@ impl<'a> FullCollector<'a> {
     }
 
     fn sweep(&mut self) {
+        self.old_protected.clear_freelist();
+
         let old_evacuated_set: HashSet<Page> =
             HashSet::from_iter(self.old_evacuated_pages.iter().map(|pair| pair.0));
 
@@ -257,7 +256,21 @@ impl<'a> FullCollector<'a> {
                 continue;
             }
 
-            self.sweep_page(page);
+            let (live, free_regions) = self.sweep_page(page);
+
+            if live == 0 {
+                self.old_protected.free_page(page);
+            } else {
+                for free_region in free_regions {
+                    fill_region_with(self.vm, free_region.start, free_region.end, true);
+
+                    self.old_protected.add_to_freelist(
+                        self.vm,
+                        free_region.start,
+                        free_region.size(),
+                    );
+                }
+            }
         }
 
         self.large_space.remove_objects(|object_start| {
@@ -280,10 +293,12 @@ impl<'a> FullCollector<'a> {
         });
     }
 
-    fn sweep_page(&mut self, page: Page) {
+    fn sweep_page(&mut self, page: Page) -> (usize, Vec<Region>) {
         let region = page.object_area();
         let mut scan = region.start;
         let mut free_start = region.start;
+        let mut live = 0;
+        let mut free_regions = Vec::new();
 
         while scan < region.end {
             let object = scan.to_obj();
@@ -295,21 +310,30 @@ impl<'a> FullCollector<'a> {
                 let object_end = scan.offset(object_size);
 
                 if object.header().is_marked() {
-                    self.handle_free_region(free_start, scan);
+                    self.handle_free_region(&mut free_regions, free_start, scan);
                     object.header().unmark();
                     free_start = object_end;
+                    live += object_size;
                 }
 
                 scan = object_end
             }
         }
 
-        self.handle_free_region(free_start, scan);
+        self.handle_free_region(&mut free_regions, free_start, scan);
         assert_eq!(scan, region.end);
+
+        (live, free_regions)
     }
 
-    fn handle_free_region(&mut self, start: Address, end: Address) {
-        fill_region_with(self.vm, start, end, true);
+    fn handle_free_region(&mut self, free_regions: &mut Vec<Region>, start: Address, end: Address) {
+        assert!(start <= end);
+
+        if start == end {
+            return;
+        }
+
+        free_regions.push(Region::new(start, end));
     }
 
     fn release_evacuated_pages(&mut self) {

diff --git a/dora-runtime/src/gc/swiper/old.rs b/dora-runtime/src/gc/swiper/old.rs
@@ -143,6 +143,14 @@ impl OldGenProtected {
         self.top = self.current_limit;
     }
 
+    pub fn clear_freelist(&mut self) {
+        self.freelist.clear();
+    }
+
+    pub fn add_to_freelist(&mut self, vm: &VM, start: Address, size: usize) {
+        self.freelist.add(vm, start, size);
+    }
+
     pub fn allocate(&mut self, vm: &VM, old: &OldGen, size: usize) -> Option<Address> {
         if let Some(address) = self.raw_alloc(size) {
             fill_region_with(vm, self.top, self.current_limit, false);
@@ -153,6 +161,19 @@ impl OldGenProtected {
         fill_region_with(vm, self.top, self.current_limit, false);
         old.update_crossing(self.top, self.current_limit);
 
+        let free_space = self.freelist.alloc(size);
+
+        if free_space.is_non_null() {
+            self.top = free_space.addr();
+            self.current_limit = self.top.offset(free_space.size());
+
+            let address = self.raw_alloc(size).expect("allocation failed");
+
+            fill_region_with(vm, self.top, self.current_limit, false);
+            old.update_crossing(self.top, self.current_limit);
+            return Some(address);
+        }
+
         if !old.can_add_page() {
             return None;
         }