Merge pull request #331 from Pivot-Studio/feat/libc

feat: core lib improvments & multiple bug fixes

Author: Chronostasys

Cargo.lock

@@ -22,7 +22,7 @@ rowan = "0.15"
 dissimilar = "1.0"
 stderrlog = "0.5"
 log = "0.4"
-clap = { version = "4.1", features = ["derive", "unstable-styles"] }
+clap = { version = "4.4", features = ["derive", "string"] }
 colored = "2.0"
 serde = "1.0"
 lsp-types = { branch = "master", features = ["proposed"], git = "https://github.com/Pivot-Studio/lsp-types" }
@@ -35,7 +35,7 @@ enum_dispatch = "0.3"
 threadpool = {version = "1.8", optional = true}
 dunce = "1.0"
 toml = "0.7"
-ariadne = "0.2"
+ariadne = {version = "0.3", features = []}
 dyn-fmt = "0.3"
 petgraph = "0.6"
 kagari = { path = "./kagari" }
@@ -104,3 +104,5 @@ codegen-units = 1
 [dev-dependencies]
 expect-test = "1.4.1"
 
+[build-dependencies]
+vergen = "7.3.2"

Cargo.toml

@@ -0,0 +1,8 @@
+// build.rs
+
+use vergen::{vergen, Config};
+fn main() {
+    let mut cfg = Config::default();
+    *cfg.sysinfo_mut().name_mut() = false;
+    vergen(cfg).expect("Fail to generate version info");
+}

build.rs

@@ -145,8 +145,9 @@ void PLImmixGCPrinter::finishAssembly(Module &M, GCModuleInfo &Info, AsmPrinter
       continue;
     }
 
-    if (GV->isManifestConstant()) // skip constants
+    if (isa<GlobalVariable>(GV) && cast<GlobalVariable>(GV)->isConstant()) // skip constants
     {
+      // printf("skip %s\n", GV->getName().bytes());
       continue;
     }
 
@@ -156,6 +157,7 @@ void PLImmixGCPrinter::finishAssembly(Module &M, GCModuleInfo &Info, AsmPrinter
     {
       continue;
     }
+    // printf("%s\n", GV->getName().bytes());
 
     ii++;
   }
@@ -167,7 +169,20 @@ void PLImmixGCPrinter::finishAssembly(Module &M, GCModuleInfo &Info, AsmPrinter
   {
     AP.OutStreamer.get()->AddComment("global address");
     const GlobalValue *GV = &*GI;
-    if (GV->getName().contains("llvm."))
+    if (GV->getName().contains("llvm.")) // skip magic variables e.g. @llvm.global_ctors
+    {
+      continue;
+    }
+
+    if (isa<GlobalVariable>(GV) && cast<GlobalVariable>(GV)->isConstant()) // skip constants
+    {
+      // printf("skip %s\n", GV->getName().bytes());
+      continue;
+    }
+
+    if (GV->getName().startswith("_IMMIX_GC_MAP") ||
+        GV->getName().contains("_@IMMIX_OBJTYPE_") ||
+        GV->getName().startswith(".str")) // skip generated globals
     {
       continue;
     }

immix/llvm/plimmixprinter.cpp

@@ -1,6 +1,8 @@
+use std::cell::RefCell;
+
 use parking_lot::ReentrantMutex;
 
-use crate::{bigobj::BigObj, mmap::Mmap, round_n_up, ALIGN};
+use crate::{bigobj::BigObj, mmap::Mmap, round_n_up, ALIGN, BIG_OBJ_ALIGN};
 
 pub struct BigObjAllocator {
     mmap: Mmap,
@@ -9,6 +11,7 @@ pub struct BigObjAllocator {
     heap_end: *mut u8,
     unused_chunks: Vec<*mut BigObj>,
     lock: ReentrantMutex<()>,
+    commited_to: RefCell<*mut u8>,
 }
 
 impl BigObjAllocator {
@@ -17,6 +20,7 @@ impl BigObjAllocator {
         Self {
             current: mmap.aligned(ALIGN),
             heap_start: mmap.aligned(ALIGN),
+            commited_to: RefCell::new(mmap.aligned(ALIGN)),
             heap_end: mmap.end(),
             mmap,
             unused_chunks: Vec::new(),
@@ -41,8 +45,16 @@ impl BigObjAllocator {
         if next >= heap_end {
             panic!("big object mmap out of memory");
         }
+        unsafe {
+            let end = current.add(size);
+            let offset = current.align_offset(ALIGN);
+            let dest = *self.commited_to.borrow();
 
-        self.mmap.commit(current, size);
+            if end > dest && !self.mmap.commit(dest, size - offset) {
+                panic!("big object mmap out of memory");
+            }
+            self.commited_to.replace(end.add(end.align_offset(ALIGN)));
+        }
 
         // self.current = next;
         let obj = BigObj::new(current, size);
@@ -51,7 +63,7 @@ impl BigObjAllocator {
     }
 
     pub fn get_chunk(&mut self, size: usize) -> *mut BigObj {
-        let size = round_n_up!(size + 16, ALIGN); // 16 is the size of BigObj
+        let size = round_n_up!(size + 16, BIG_OBJ_ALIGN); // 16 is the size of BigObj
         let _lock = self.lock.lock();
         for i in 0..self.unused_chunks.len() {
             let unused_obj = self.unused_chunks[i];

immix/src/allocator/big_obj_allocator.rs

@@ -46,7 +46,7 @@ impl GlobalAllocator {
     ///
     /// size is the max heap size
     pub fn new(size: usize) -> Self {
-        let mmap = Mmap::new(size);
+        let mmap = Mmap::new(size * 3 / 4);
 
         // mmap.commit(mmap.aligned(), BLOCK_SIZE);
 
@@ -57,7 +57,7 @@ impl GlobalAllocator {
             mmap,
             free_blocks: Vec::new(),
             lock: ReentrantMutex::new(()),
-            big_obj_allocator: BigObjAllocator::new(size),
+            big_obj_allocator: BigObjAllocator::new(size / 4),
             last_get_block_time: std::time::Instant::now(),
             mem_usage_flag: 0,
             round: 0,

immix/src/allocator/global_allocator.rs

@@ -276,9 +276,9 @@ impl ThreadLocalAllocator {
             self.unavailable_blocks.push(new_block);
         } else {
             // new_block未被用完，将它加入recyclable blocks
-            unsafe {
-                debug_assert!((*new_block).find_first_hole().is_some());
-            }
+            // unsafe {
+            //     debug_assert!((*new_block).find_first_hole().is_some());
+            // }
             self.recyclable_blocks.push_back(new_block);
         }
         re
@@ -357,14 +357,14 @@ impl ThreadLocalAllocator {
                 let block = *block;
                 if (*block).marked {
                     total_used += (*block).correct_header(mark_histogram);
-                    let (line, hole) = (*block).get_available_line_num_and_holes();
+                    let (line, _) = (*block).get_available_line_num_and_holes();
                     if line > 0 {
-                        debug_assert!(
-                            (*block).find_first_hole().is_some(),
-                            "line {}, hole {}",
-                            line,
-                            hole
-                        );
+                        // debug_assert!(
+                        //     (*block).find_first_hole().is_some(),
+                        //     "line {}, hole {}",
+                        //     line,
+                        //     hole
+                        // );
                         recyclable_blocks.push_back(block);
                     } else {
                         unavailable_blocks.push(block);

immix/src/allocator/thread_local_allocator.rs

@@ -1,4 +1,4 @@
-use crate::consts::ALIGN;
+use crate::BIG_OBJ_ALIGN;
 
 // big obj struct
 #[derive(Debug)]
@@ -19,8 +19,8 @@ impl BigObj {
     pub fn new(at: *mut u8, size: usize) -> &'static mut Self {
         unsafe {
             let ptr = at as *mut Self;
-            debug_assert!(ptr as usize % ALIGN == 0);
-            debug_assert!(size % ALIGN == 0);
+            debug_assert!(ptr as usize % BIG_OBJ_ALIGN == 0);
+            debug_assert!(size % BIG_OBJ_ALIGN == 0);
             ptr.write(Self {
                 header: 0b10000000,
                 size, // size of [[ obj_st |     data     ]]

immix/src/bigobj.rs

@@ -57,8 +57,8 @@ pub struct Block {
     line_map: [LineHeader; NUM_LINES_PER_BLOCK],
     /// 第一个hole的起始行号
     cursor: usize,
-    /// 第一个hole的长度（行数
-    limit: usize,
+    // /// 第一个hole的长度（行数
+    // limit: usize,
     /// 是否被标记
     pub marked: bool,
     /// 洞的数量
@@ -166,7 +166,6 @@ impl Block {
             ptr.write(Self {
                 line_map: [0; NUM_LINES_PER_BLOCK],
                 cursor: 3, // 跳过前三行，都用来放metadata。浪费一点空间（metadata从0.8%->1.2%）
-                limit: (NUM_LINES_PER_BLOCK - 3),
                 marked: false,
                 hole_num: 1,
                 available_line_num: NUM_LINES_PER_BLOCK - 3,
@@ -184,7 +183,6 @@ impl Block {
     pub fn show(&self) {
         println!("size: {}", self.get_size());
         println!("first_hole_line_idx: {}", self.cursor);
-        println!("first_hole_line_len: {}", self.limit);
         println!("marked: {}", self.marked);
         println!("hole_num: {}", self.hole_num);
         println!("available_line_num: {}", self.available_line_num);
@@ -213,7 +211,6 @@ impl Block {
     }
     pub fn reset_header(&mut self) {
         self.cursor = 3;
-        self.limit = NUM_LINES_PER_BLOCK - 3;
         self.line_map = [0; NUM_LINES_PER_BLOCK];
         self.marked = false;
         self.hole_num = 1;
@@ -270,17 +267,14 @@ impl Block {
         if len > 0 {
             if first_hole_line_len == 0 {
                 first_hole_line_idx = idx - len;
-                first_hole_line_len = len;
             }
             holes += 1;
         }
 
         self.cursor = first_hole_line_idx;
-        self.limit = first_hole_line_len;
         self.marked = false;
         self.hole_num = holes;
         self.eva_target = false;
-        // println!("holes: {}, first_idx: {} , first_len: {} {:?}", holes,first_hole_line_idx,first_hole_line_len,self.line_map.iter().map(|&x| x & 1).collect::<Vec<_>>());
         if let Some(count) = (*mark_histogram).get_mut(&self.hole_num) {
             *count += marked_num;
         } else {
@@ -325,32 +319,16 @@ impl Block {
                 }
                 len = 0;
             }
-            // self.show();
-            // panic!("prev_hole: {:?}, idx: {}, len: {}, size_line: {}", prev_hole, idx, len, size_line);
+
             idx += 1;
         }
-        // panic!("xxx");
 
         if len >= size_line {
             return Some((idx - len, len));
         }
         None
     }
 
-    /// # find_first_hole
-    ///
-    /// Find the first hole in the block.
-    ///
-    /// Return the start line index and the length of the hole (u8, u8).
-    ///
-    /// If no hole found, return `None`.
-    pub fn find_first_hole(&self) -> Option<(usize, usize)> {
-        if self.limit == 0 {
-            return None;
-        }
-        (self.cursor, self.limit).into()
-    }
-
     /// # get_nth_line
     ///
     /// get the line at nth index as * mut u8
@@ -477,21 +455,17 @@ impl Block {
             // 设置起始line header的obj_type
             let header = self.line_map.get_mut(start).unwrap();
             *header |= (obj_type as u8) << 2 | 0b10000000;
-            // header.set_obj_type(obj_type);
-            // header.set_is_head(true);
+
             // 更新first_hole_line_idx和first_hole_line_len
             if start == self.cursor {
                 self.cursor += line_size;
-                self.limit -= line_size;
+                // self.limit -= line_size;
             }
-            if self.limit == 0 {
-                if let Some((idx, len)) = self.find_next_hole((self.cursor, self.limit), 1) {
-                    self.cursor = idx;
-                    self.limit = len;
-                } else {
-                    self.hole_num -= 1;
-                    return Some((start, false));
-                }
+            if let Some((idx, _)) = self.find_next_hole((self.cursor, 0), 1) {
+                self.cursor = idx;
+            } else {
+                self.hole_num -= 1;
+                return Some((start, false));
             }
             if self.cursor > start + len && len == line_size {
                 // 正好匹配，那么减少一个hole
@@ -512,8 +486,8 @@ mod tests {
         unsafe {
             let mut ga = GlobalAllocator::new(1024 * 1024 * 1024);
             let block = &mut *ga.get_block();
-            // 第一个hole应该是从第三行开始，长度是253
-            assert_eq!(block.find_first_hole(), Some((3, 253)));
+            // // 第一个hole应该是从第三行开始，长度是253
+            // assert_eq!(block.find_first_hole(), Some((3, 253)));
             // 标记hole隔一行之后的第一行为已使用
             let header = block.get_nth_line_header(4);
             header.set_used(true);
@@ -535,7 +509,7 @@ mod tests {
             let block = &mut *ga.get_block();
             // 设置第5行已被使用
             block.get_nth_line_header(5).set_used(true);
-            block.limit = 2;
+            // block.limit = 2;
             block.hole_num = 2;
             // 从第三行开始分配，长度为128
             // 分配前：
@@ -566,7 +540,7 @@ mod tests {
             assert_eq!(start, 3);
             // assert_eq!(newcursor, Some(block.get_nth_line(4)));
             assert_eq!(block.cursor, 4);
-            assert_eq!(block.limit, 1);
+            // assert_eq!(block.limit, 1);
             let l = block.get_nth_line_header(3).get_obj_type();
             assert_eq!(l, crate::block::ObjectType::Atomic);
             // 从第4行开始分配，长度为129
@@ -585,15 +559,15 @@ mod tests {
             // ......
             assert_eq!(block.alloc(129, crate::block::ObjectType::Atomic), None);
             assert_eq!(block.cursor, 4);
-            assert_eq!(block.limit, 1);
+            // assert_eq!(block.limit, 1);
 
             block.cursor = 6;
-            block.limit = 250;
+            // block.limit = 250;
             let (start, newcursor) = block
                 .alloc((256 - 6) * LINE_SIZE, crate::block::ObjectType::Complex)
                 .expect("cannot alloc new line");
             block.cursor = 4;
-            block.limit = 1;
+            // block.limit = 1;
             // 从第6行开始分配，长度为256-6
             // 分配后：
             // --------
@@ -613,7 +587,7 @@ mod tests {
             assert_eq!(start, 6);
             assert_eq!(newcursor, false);
             assert_eq!(block.cursor, 4);
-            assert_eq!(block.limit, 1);
+            // assert_eq!(block.limit, 1);
             let (start, newcursor) = block
                 .alloc(128, crate::block::ObjectType::Atomic)
                 .expect("cannot alloc new line");
@@ -634,7 +608,7 @@ mod tests {
             assert_eq!(start, 4);
             assert_eq!(newcursor, false);
             // assert_eq!(block.first_hole_line_idx, 255); 这个时候没hole了，此值无意义，len为0
-            assert_eq!(block.limit, 0);
+            // assert_eq!(block.limit, 0);
 
             // test big alloc
             let obj = ga.get_big_obj(BLOCK_SIZE);