fix: gc tracing non head pointers & better struct parser

Author: Chronostasys

immix/src/allocator/thread_local_allocator.rs

@@ -303,6 +303,7 @@ impl ThreadLocalAllocator {
 
     pub fn big_obj_from_ptr(&mut self, ptr: *mut u8) -> Option<*mut BigObj> {
         for obj in self.big_objs.iter() {
+            // FIXME: O(n); should use a tree
             let start = unsafe { (*obj as *mut u8).add(16) };
             let end = unsafe { (*obj as *mut u8).add((*(*obj)).size) };
             if start <= ptr && end >= ptr {

immix/src/block.rs

@@ -37,6 +37,7 @@ pub trait HeaderExt {
 }
 
 pub trait LineHeaderExt {
+    fn get_is_head(&self) -> bool;
     fn set_is_head(&mut self, is_head: bool);
     fn get_is_used_follow(&self) -> bool;
     fn get_obj_line_size(&self, idx: usize, block: &mut Block) -> usize;
@@ -137,6 +138,10 @@ impl LineHeaderExt for LineHeader {
         line_size
     }
 
+    fn get_is_head(&self) -> bool {
+        self & 0b10000000 == 0b10000000
+    }
+
     fn set_is_head(&mut self, is_head: bool) {
         if is_head {
             *self |= 0b10000000;
@@ -376,6 +381,41 @@ impl Block {
         &mut *(block_start as *mut Self)
     }
 
+    /// # get_head_ptr
+    ///
+    /// A pointer in the graph may not point to the start position of the
+    /// space we allocated for it. Consider the following example:
+    ///
+    /// ```pl
+    ///
+    /// struct A {
+    ///     a: u8;
+    ///     b: u8;
+    /// }
+    ///
+    /// let a = A { a: 1, b: 2 };
+    /// let ptr = &a.b; // where ptr is a pointer to the field b, what we want is a pointer to the struct A
+    /// ```
+    ///
+    /// This function is used to get the pointer to the start position of the space we allocated for the object,
+    /// from a pointer in the graph. e.g. in the above example, we want to get a pointer to the struct A, by
+    /// passing the pointer to the field b.
+    pub unsafe fn get_head_ptr(&mut self, ptr: *mut u8) -> *mut u8 {
+        let mut idx = self.get_line_idx_from_addr(ptr);
+        let mut header = self.get_nth_line_header(idx);
+        // 如果是head，直接返回
+        if header.get_is_head() {
+            return self.get_nth_line(idx);
+        }
+        // 否则往前找到head
+        while !header.get_is_head() {
+            header = self.get_nth_line_header(idx - 1);
+            idx -= 1;
+        }
+        // 返回head的地址
+        self.get_nth_line(idx)
+    }
+
     pub unsafe fn get_line_header_from_addr(&mut self, addr: *mut u8) -> (&mut LineHeader, usize) {
         let idx = self.get_line_idx_from_addr(addr);
         (self.get_nth_line_header(idx), idx)

immix/src/collector.rs

@@ -43,7 +43,6 @@ struct CollectorStatus {
     collect_threshold: usize,
     /// in bytes
     bytes_allocated_since_last_gc: usize,
-    last_gc_time: std::time::SystemTime,
     collecting: bool,
 }
 
@@ -104,7 +103,6 @@ impl Collector {
                 status: RefCell::new(CollectorStatus {
                     collect_threshold: 1024,
                     bytes_allocated_since_last_gc: 0,
-                    last_gc_time: std::time::SystemTime::now(),
                     collecting: false,
                 }),
             }
@@ -222,13 +220,13 @@ impl Collector {
     /// 现在纠正为
     ///
     /// ptr -> new_ptr(forwarded) -> value
-    unsafe fn correct_ptr(&self, ptr: *mut u8) {
+    unsafe fn correct_ptr(&self, ptr: *mut u8, offset: isize) {
         let ptr = ptr as *mut AtomicPtr<*mut u8>;
         let new_ptr = *(*ptr).load(Ordering::SeqCst);
         let ptr = ptr as *mut *mut u8;
         debug_assert!(!new_ptr.is_null());
         log::trace!("gc {} correct ptr {:p} to {:p}", self.id, ptr, new_ptr);
-        *ptr = new_ptr;
+        *ptr = new_ptr.offset(offset);
     }
 
     #[cfg(feature = "llvm_gc_plugin")]
@@ -248,37 +246,39 @@ impl Collector {
             return;
         }
 
-        let mut ptr = *(ptr as *mut *mut u8);
+        let ptr = *(ptr as *mut *mut u8);
         // println!("mark ptr {:p} -> {:p}", father, ptr);
         // mark it if it is in heap
         if self.thread_local_allocator.as_mut().unwrap().in_heap(ptr) {
             // println!("mark ptr succ {:p} -> {:p}", father, ptr);
             let block = Block::from_obj_ptr(ptr);
             let is_candidate = block.is_eva_candidate();
+            let mut head = block.get_head_ptr(ptr);
+            let offset_from_head = ptr.offset_from(head);
             if !is_candidate {
                 block.marked = true;
             } else {
-                let (line_header, _) = block.get_line_header_from_addr(ptr);
+                let (line_header, _) = block.get_line_header_from_addr(head);
                 if line_header.get_forwarded() {
-                    self.correct_ptr(father);
+                    self.correct_ptr(father, offset_from_head);
                     return;
                 }
             }
-            let (line_header, idx) = block.get_line_header_from_addr(ptr);
+            let (line_header, idx) = block.get_line_header_from_addr(head);
             if line_header.get_marked() {
                 return;
             }
             // 若此block是待驱逐对象
             if is_candidate {
-                let atomic_ptr = ptr as *mut AtomicPtr<u8>;
+                let atomic_ptr = head as *mut AtomicPtr<u8>;
                 let old_loaded = (*atomic_ptr).load(Ordering::SeqCst);
-                let obj_line_size = line_header.get_obj_line_size(idx, Block::from_obj_ptr(ptr));
+                let obj_line_size = line_header.get_obj_line_size(idx, Block::from_obj_ptr(head));
                 let new_ptr = self.alloc(obj_line_size * LINE_SIZE, line_header.get_obj_type());
                 if !new_ptr.is_null() {
                     let new_block = Block::from_obj_ptr(new_ptr);
                     let (new_line_header, _) = new_block.get_line_header_from_addr(new_ptr);
                     // 将数据复制到新的地址
-                    core::ptr::copy_nonoverlapping(ptr, new_ptr, obj_line_size * LINE_SIZE);
+                    core::ptr::copy_nonoverlapping(head, new_ptr, obj_line_size * LINE_SIZE);
                     // core::ptr::copy_nonoverlapping(line_header as * const u8, new_line_header as * mut u8, line_size);
 
                     // 线程安全性说明
@@ -293,16 +293,16 @@ impl Collector {
                         .is_ok()
                     {
                         // 成功驱逐
-                        log::trace!("gc {}: eva {:p} to {:p}", self.id, ptr, new_ptr);
+                        log::trace!("gc {}: eva {:p} to {:p}", self.id, head, new_ptr);
                         new_line_header.set_marked(true);
                         line_header.set_forwarded(true);
                         new_block.marked = true;
-                        ptr = new_ptr;
-                        self.correct_ptr(father);
+                        head = new_ptr;
+                        self.correct_ptr(father, offset_from_head);
                     } else {
                         // 期间别的线程驱逐了它
                         spin_until!(line_header.get_forwarded());
-                        self.correct_ptr(father);
+                        self.correct_ptr(father, offset_from_head);
                         return;
                     }
                 }
@@ -311,7 +311,7 @@ impl Collector {
             let obj_type = line_header.get_obj_type();
             match obj_type {
                 ObjectType::Atomic => {}
-                _ => (*self.queue).push((ptr, obj_type)),
+                _ => (*self.queue).push((head, obj_type)),
             }
             return;
         }
@@ -550,7 +550,6 @@ impl Collector {
         }
         status.collecting = true;
         status.bytes_allocated_since_last_gc = 0;
-        status.last_gc_time = std::time::SystemTime::now();
         drop(status);
         // evacuation pre process
         // 这个过程要在完成safepoint同步之前完成，因为在驱逐的情况下

src/ast/diag.rs

@@ -146,6 +146,8 @@ define_error!(
     EXPECT_ARRAY_TYPE = "expect array type",
     EXPECT_INT_VALUE = "expect int value",
     METHODS_MUST_HAVE_BODY = "methods must have body",
+    INVALID_STRUCT_INIT = "invalid struct initialization",
+    REDUNDANT_COMMA = "REDUNDANT comma",
 );
 macro_rules! define_warn {
     ($(

src/ast/node/types.rs

@@ -18,6 +18,7 @@ use crate::ast::pltype::get_type_deep;
 use crate::ast::pltype::ClosureType;
 use crate::ast::pltype::{ARRType, Field, GenericType, PLType, STType};
 use crate::ast::tokens::TokenType;
+use crate::ast::traits::CustomType;
 use indexmap::IndexMap;
 
 use internal_macro::node;
@@ -606,14 +607,15 @@ impl Node for StructInitFieldNode {
         ctx: &'b mut Ctx<'a>,
         builder: &'b BuilderEnum<'a, '_>,
     ) -> NodeResult {
+        ctx.push_semantic_token(self.id.range(), SemanticTokenType::PROPERTY, 0);
         self.exp.emit(ctx, builder)
     }
 }
 
-#[node(comment)]
+#[node]
 pub struct StructInitNode {
     pub typename: Box<TypeNodeEnum>,
-    pub fields: Vec<Box<StructInitFieldNode>>, // TODO: comment db and salsa comment struct
+    pub fields: Vec<Box<NodeEnum>>, // TODO: comment db and salsa comment struct
 }
 
 impl PrintTrait for StructInitNode {
@@ -658,41 +660,50 @@ impl Node for StructInitNode {
         ctx.save_if_comment_doc_hover(self.typename.range(), Some(sttype.doc.clone()));
         ctx.run_in_type_mod_mut(&mut sttype, |ctx, sttype| {
             for fieldinit in self.fields.iter_mut() {
-                let field_id_range = fieldinit.id.range;
-                let field_exp_range = fieldinit.exp.range();
-                let field = sttype.fields.get(&fieldinit.id.name);
-                if field.is_none() {
-                    ctx.if_completion(self.range, || sttype.get_completions(ctx));
-                    return Err(
-                        ctx.add_diag(field_id_range.new_err(ErrorCode::STRUCT_FIELD_NOT_FOUND))
-                    );
-                }
-                let field = field.unwrap();
-                let v = fieldinit.emit(ctx, builder)?.get_value();
-                idx += 1;
-                ctx.emit_comment_highlight(&self.comments[idx - 1]);
-                if v.is_none() {
-                    return Err(ctx.add_diag(field_exp_range.new_err(ErrorCode::EXPECT_VALUE)));
-                }
-                let v = v.unwrap();
-                let value = ctx.try_load2var(field_exp_range, v.get_value(), builder)?;
-                let value_pltype = v.get_ty();
-                ctx.protect_generic_context(&sttype.generic_map, |ctx| {
-                    if !field
-                        .typenode
-                        .eq_or_infer(ctx, value_pltype.clone(), builder)?
-                        .eq
-                    {
-                        return Err(ctx.add_diag(
-                            fieldinit
-                                .range
-                                .new_err(ErrorCode::STRUCT_FIELD_TYPE_NOT_MATCH),
-                        ));
+                if let NodeEnum::STInitField(fieldinit) = &mut **fieldinit {
+                    let field_id_range = fieldinit.id.range;
+                    let field_exp_range = fieldinit.exp.range();
+                    let field = sttype.fields.get(&fieldinit.id.name);
+                    if field.is_none() {
+                        ctx.if_completion(self.range, || sttype.get_completions(ctx));
+                        return Err(
+                            ctx.add_diag(field_id_range.new_err(ErrorCode::STRUCT_FIELD_NOT_FOUND))
+                        );
+                    }
+                    let field = field.unwrap();
+                    let v = fieldinit.emit(ctx, builder)?.get_value();
+                    idx += 1;
+                    if v.is_none() {
+                        return Err(ctx.add_diag(field_exp_range.new_err(ErrorCode::EXPECT_VALUE)));
+                    }
+                    let v = v.unwrap();
+                    let value = ctx.try_load2var(field_exp_range, v.get_value(), builder)?;
+                    let value_pltype = v.get_ty();
+                    ctx.protect_generic_context(&sttype.generic_map, |ctx| {
+                        if !field
+                            .typenode
+                            .eq_or_infer(ctx, value_pltype.clone(), builder)?
+                            .eq
+                        {
+                            return Err(ctx.add_diag(
+                                fieldinit
+                                    .range()
+                                    .new_err(ErrorCode::STRUCT_FIELD_TYPE_NOT_MATCH),
+                            ));
+                        }
+                        Ok(())
+                    })?;
+                    field_init_values.push((field.index, value));
+                    ctx.send_if_go_to_def(field_id_range, field.range, sttype.get_path());
+                    ctx.set_field_refs(pltype.clone(), field, field_id_range);
+                } else if let NodeEnum::Err(fieldinit) = &mut **fieldinit {
+                    if !fieldinit.src.contains(':') {
+                        ctx.if_completion(fieldinit.range(), || sttype.get_completions(ctx));
                     }
-                    Ok(())
-                })?;
-                field_init_values.push((field.index, value));
-                ctx.set_field_refs(pltype.clone(), field, field_id_range);
+                    let _ = fieldinit.emit(ctx, builder);
+                } else {
+                    unreachable!()
+                }
             }
             if !sttype.generic_map.is_empty() {
                 if sttype.need_gen_code() {
@@ -709,9 +720,6 @@ impl Node for StructInitNode {
             Ok(())
         })?;
 
-        if self.fields.len() < self.comments.len() {
-            ctx.emit_comment_highlight(&self.comments[idx]);
-        }
         let struct_pointer = builder.alloc("initstruct", &pltype.borrow(), ctx, None); //alloc(ctx, tp, "initstruct");
         field_init_values.iter().for_each(|(index, value)| {
             let fieldptr = builder