wip: obj size in side table

Author: wenyuzhao

ix/src/block.rs

@@ -14,6 +14,7 @@ use crate::{pool::Pool, ImmixAllocator};
 use super::Address;
 
 const OBJS_IN_BLOCK: usize = Block::BYTES / MIN_ALIGNMENT;
+const LINES_IN_BLOCK: usize = (1 << 15) >> Line::LOG_BYTES;
 
 #[repr(C)]
 pub struct BlockMeta {
@@ -26,8 +27,9 @@ pub struct BlockMeta {
     // pub group: u8,
     // head_cell: Address,
     // pub owner: &'static Pool,
-    // pub obj_size: [AtomicU8; OBJS_IN_BLOCK],
-    pub line_marks: [AtomicU8; 8],
+    pub obj_size: [AtomicU8; OBJS_IN_BLOCK],
+    /// Num. dead objects per line.
+    pub line_liveness: [AtomicU8; LINES_IN_BLOCK],
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -85,28 +87,29 @@ impl Block {
     pub fn get_next_available_lines(self, search_start: Line) -> Option<Range<Line>> {
         let start_cursor = search_start.get_index_within_block();
         let mut cursor = start_cursor;
+        unreachable!()
         // Find start
-        while cursor < self.line_marks.len() {
-            let mark = self.line_marks[cursor].load(Ordering::SeqCst);
-            if mark == 0 {
-                break;
-            }
-            cursor += 1;
-        }
-        if cursor == self.line_marks.len() {
-            return None;
-        }
-        let start = Line::from_address(self.data_start() + cursor * Line::BYTES);
-        // Find limit
-        while cursor < self.line_marks.len() {
-            let mark = self.line_marks[cursor].load(Ordering::SeqCst);
-            if mark != 0 {
-                break;
-            }
-            cursor += 1;
-        }
-        let end = Line::from_address(self.data_start() + cursor * Line::BYTES);
-        Some(start..end)
+        // while cursor < self.line_marks.len() {
+        //     let mark = self.line_marks[cursor].load(Ordering::SeqCst);
+        //     if mark == 0 {
+        //         break;
+        //     }
+        //     cursor += 1;
+        // }
+        // if cursor == self.line_marks.len() {
+        //     return None;
+        // }
+        // let start = Line::from_address(self.data_start() + cursor * Line::BYTES);
+        // // Find limit
+        // while cursor < self.line_marks.len() {
+        //     let mark = self.line_marks[cursor].load(Ordering::SeqCst);
+        //     if mark != 0 {
+        //         break;
+        //     }
+        //     cursor += 1;
+        // }
+        // let end = Line::from_address(self.data_start() + cursor * Line::BYTES);
+        // Some(start..end)
     }
 }
 

ix/src/immix_space.rs

@@ -1,3 +1,5 @@
+use std::sync::atomic::Ordering;
+
 use super::{page_resource::BlockPageResource, Allocator, Space, SpaceId};
 use crate::{
     block::{self, Block, Line},
@@ -19,7 +21,7 @@ pub struct ImmixSpace {
     pub(crate) pool: Pool,
 }
 
-const SIZE_ENCODING_SHIFT: usize = 56;
+// const SIZE_ENCODING_SHIFT: usize = 56;
 
 impl Space for ImmixSpace {
     const MAX_ALLOCATION_SIZE: usize = (256 - 1) * MIN_ALIGNMENT;
@@ -43,7 +45,9 @@ impl Space for ImmixSpace {
     }
 
     fn get_layout(ptr: Address) -> Layout {
-        let words = ptr.as_usize() >> SIZE_ENCODING_SHIFT;
+        let block = Block::containing(ptr);
+        let index = (ptr - block.start()) >> LOG_MIN_ALIGNMENT;
+        let words = block.obj_size[index].load(Ordering::Relaxed) as usize;
         let size = words << LOG_MIN_ALIGNMENT;
         mallockit::println!("get_layout {ptr:?} {words} {size}");
         Layout::from_size_align(size, MIN_ALIGNMENT).unwrap()
@@ -224,10 +228,13 @@ impl Allocator for ImmixAllocator {
             Some(result)
         }?;
         let words = layout.size() >> LOG_MIN_ALIGNMENT;
+        let block = Block::containing(result);
+        let index = (result - block.start()) >> LOG_MIN_ALIGNMENT;
+        block.obj_size[index].store(words as u8, Ordering::Relaxed);
         // mallockit::println!("alloc {result:?} {words} {layout:?}");
-        result = Address::from_usize(result.as_usize() | (words << SIZE_ENCODING_SHIFT));
+        // result = Address::from_usize(result.as_usize() | (words << SIZE_ENCODING_SHIFT));
         // mallockit::println!("alloc -> {result:?} {words} {layout:?}");
-        let v = unsafe { result.load::<usize>() };
+        // let v = unsafe { result.load::<usize>() };
         // mallockit::println!("alloc -> {v:?}");
         return Some(result);
     }