Multipage Deallocator

fs/hayleyfs/balloc.rs

@@ -260,19 +260,21 @@ impl PageAllocator for Option<PerCpuPageAllocator> {
 
     fn dealloc_data_page_list(&self, pages: &DataPageListWrapper<Clean, Free>) -> Result<()> {
         if let Some(allocator) = self {
-            let mut page_list = pages.get_page_list_cursor();
-            let mut page = page_list.current();
-            while page.is_some() {
-                // janky syntax to deal with the fact that page_list.current() returns an Option
-                if let Some(page) = page {
-                    // TODO: refactor to avoid acquiring lock on every iteration
-                    allocator.dealloc_page(page.get_page_no())?;
-                    page_list.move_next();
-                } else {
-                    unreachable!()
-                }
-                page = page_list.current();
-            }
+            let page_list = pages.get_page_list_cursor();
+            // let mut page = page_list.current();
+            // while page.is_some() {
+            //     // janky syntax to deal with the fact that page_list.current() returns an Option
+            //     if let Some(page) = page {
+            //         // TODO: refactor to avoid acquiring lock on every iteration
+            //         allocator.dealloc_page(page.get_page_no())?;
+            //         page_list.move_next();
+            //     } else {
+            //         unreachable!()
+            //     }
+            //     page = page_list.current();
+            // }
+            // Ok(())
+            allocator.dealloc_multiple_page(page_list)?; 
             Ok(())
         } else {
             pr_info!("ERROR: page allocator is uninitialized\n");
@@ -292,6 +294,7 @@ impl PageAllocator for Option<PerCpuPageAllocator> {
 
     fn dealloc_dir_page_list(&self, pages: &DirPageListWrapper<Clean, Free>) -> Result<()> {
         if let Some(allocator) = self {
+            let page_list = pages.get_page_list_cursor();
             let mut page_list = pages.get_page_list_cursor();
             let mut page = page_list.current();
             while page.is_some() {
@@ -343,6 +346,83 @@ impl PerCpuPageAllocator {
             Ok(())
         }
     }
+
+
+    fn dealloc_multiple_page(&self, mut page_list : Cursor<'_, Box<LinkedPage>>) -> Result<()> {
+        // hash map to store free list lock for every cpu
+        let mut cpu_free_list_map : RBTree<usize, Vec<PageNum>> = RBTree::new(); 
+
+
+        let mut page = page_list.current(); // head of page list
+
+        let mut num_pages = 0; 
+
+        // get a list of pages #s for each cpu
+        while page.is_some() {
+            if let Some(page) = page {
+                pr_info!("Page: {}", page.get_page_no());
+
+                let cpu : usize = ((page.get_page_no() - self.start) / self.pages_per_cpu).try_into()?;
+
+                if matches!(cpu_free_list_map.get(&cpu), None) {
+                    cpu_free_list_map.try_insert(cpu, Vec::new())?; 
+                }
+
+                // add cpu page to vector (vector is mutable)
+                let cpu_page_vec : &mut Vec<PageNum> = cpu_free_list_map.get_mut(&cpu).unwrap();
+
+                cpu_page_vec.try_push(page.get_page_no())?; 
+
+                page_list.move_next();
+            }
+            page = page_list.current(); 
+            num_pages += 1; 
+        }
+
+        pr_info!("Num Pages in List: {}", num_pages); 
+
+        // add pages to corresponding free list in ascending cpu # order
+        for (cpu, page_nos) in cpu_free_list_map.iter() {
+
+            let free_list = Arc::clone(&self.free_lists[*cpu]);
+            let mut free_list = free_list.lock();
+            let old_free_pages = free_list.free_pages; 
+
+            for page_no in page_nos.iter() {
+
+                free_list.free_pages += 1;
+                let res = free_list.list.try_insert(*page_no, ());
+
+                // unwrap the error so we can get at the option
+                let res = match res {
+                    Ok(res) => res,
+                    Err(e) => {
+                        pr_info!(
+                            "ERROR: failed to insert {:?} into page allocator at CPU {:?}, error {:?}\n",
+                            page_no,
+                            cpu,
+                            e
+                        );
+                        return Err(e);
+                    }
+                 };
+
+                // check that the page was not already present in the tree. CAUSING ERRORS DUE TO TYPE ANNOTATION ISSUES
+                if res.is_some() {
+                    pr_info!(
+                        "ERROR: page {:?} was already in the allocator at CPU {:?}\n",
+                        page_no,
+                        cpu
+                    );
+                    return Err(EINVAL); 
+                }
+                pr_info!("Cpu: {} Freed: {}", cpu, page_no);
+                pr_info!("Pages Added: {}", free_list.free_pages - old_free_pages); 
+            }
+        }
+
+        return Ok(()); 
+    }
 }
 
 // placeholder page descriptor that can represent either a dir or data page descriptor
@@ -2365,4 +2445,4 @@ impl<Op> DataPageListWrapper<InFlight, Op> {
             pages: self.pages,
         }
     }
-}
+}