Move sweep_fn from a field in each page to the PageSet. #15.

Author: jorendorff

src/heap.rs

@@ -263,12 +263,11 @@ impl<'h> HeapSession<'h> {
     fn get_page_set<'a, T: IntoHeapAllocation<'h> + 'a>(&'a mut self) -> PageSetRef<'a, 'h, T> {
         let key = heap_type_id::<T>();
         let heap: *mut Heap = self.heap;
-        let page_ref =
-            self.heap
+        self.heap
             .page_sets
             .entry(key)
-            .or_insert_with(|| unsafe { PageSet::new(heap) });
-        unsafe { page_ref.unchecked_downcast_mut() }
+            .or_insert_with(|| unsafe { PageSet::new::<T>(heap) })
+            .downcast_mut()
     }
 
     pub fn set_page_limit<T: IntoHeapAllocation<'h>>(&mut self, limit: Option<usize>) {

src/pages.rs

@@ -50,7 +50,6 @@ pub struct PageHeader {
     mark_bits: BitVec,
     allocated_bits: BitVec,
     mark_fn: unsafe fn(UntypedPointer, &mut MarkingTracer),
-    sweep_fn: unsafe fn(&mut PageHeader),
     freelist: *mut (),
 }
 
@@ -73,10 +72,6 @@ impl PageHeader {
         (self.mark_fn)(ptr, tracer);
     }
 
-    pub unsafe fn sweep(&mut self) {
-        (self.sweep_fn)(self);
-    }
-
     pub fn type_id(&self) -> usize {
         self.mark_fn as usize
     }
@@ -268,7 +263,6 @@ impl PageBox {
                         mark_bits: BitVec::from_elem(capacity, false),
                         allocated_bits: BitVec::from_elem(capacity, false),
                         mark_fn: mark_entry_point::<T>,
-                        sweep_fn: sweep_entry_point::<T>,
                         freelist: ptr::null_mut(),
                     },
                     allocations: PhantomData,
@@ -310,6 +304,8 @@ impl Drop for PageBox {
 pub struct PageSet {
     heap: *mut Heap,
 
+    sweep_fn: unsafe fn(&mut PageHeader),
+
     /// The collection of pages.
     ///
     /// All pages in this collection have matching `.heap`, `.mark_fn`, and
@@ -326,25 +322,25 @@ impl PageSet {
     /// # Safety
     ///
     /// Safe as long as `heap` is a valid pointer.
-    pub unsafe fn new(heap: *mut Heap) -> PageSet {
+    pub unsafe fn new<'h, T: IntoHeapAllocation<'h>>(heap: *mut Heap) -> PageSet {
         PageSet {
             heap,
+            sweep_fn: sweep_entry_point::<T>,
             pages: vec![],
             limit: None
         }
     }
 
     /// Downcast to a typed PageSetRef.
     ///
-    /// # Safety
+    /// # Panics
     ///
-    /// The actual allocation type of this page set must be T.
-    pub unsafe fn unchecked_downcast_mut<'a, 'h, T>(&'a mut self) -> PageSetRef<'a, 'h, T>
+    /// If T is not the actual allocation type for this page set.
+    pub fn downcast_mut<'a, 'h, T>(&'a mut self) -> PageSetRef<'a, 'h, T>
     where
         T: IntoHeapAllocation<'h> + 'a
     {
-        // The assertion only covers the case where we have at least one page.
-        assert!(self.pages.is_empty() || self.pages[0].downcast_mut::<T>().is_some());
+        assert_eq!(self.sweep_fn as *const (), sweep_entry_point::<T> as *const ());
 
         PageSetRef {
             pages: self,
@@ -371,7 +367,7 @@ impl PageSet {
     /// Safe to call only as the final part of GC.
     pub unsafe fn sweep(&mut self) {
         for page in &mut self.pages {
-            page.sweep();
+            (self.sweep_fn)(page);
         }
     }