save

notJoon · Nov 24, 2023 · 5165d9e · 5165d9e
1 parent eab3cd2
commit 5165d9e
Show file tree

Hide file tree

Showing 7 changed files with 77 additions and 34 deletions.
diff --git a/src/gc.rs b/src/gc.rs
@@ -1,11 +1,13 @@
 use std::fmt;
 
-use crate::{controller::PIController, vm::VM};
+use crate::{controller::PIController, vm::VirtualMachine};
 
 pub trait GarbageCollector {
-    fn collect(&self, vm: &mut VM);
+    fn collect(&self, vm: &mut VirtualMachine);
     fn ty(&self) -> GCType;
     fn new_instance(&self) -> Box<dyn GarbageCollector>;
+    fn adjust_confidence(&mut self, vm: &mut VirtualMachine);
+    fn trigger_gc(&mut self, vm: &mut VirtualMachine);
 }
 
 pub struct TriColorGC {
@@ -40,6 +42,6 @@ pub struct MarkAndSweep {
 
 // impl GarbageCollector for MarkAndSweep {
 //     fn collect(&self, vm: &mut VM) {
-        
+
 //     }
-// }
+// }
diff --git a/src/heap.rs b/src/heap.rs
@@ -0,0 +1,6 @@
+use std::collections::BTreeSet;
+
+// #[derive(Debug, PartialEq, Clone, Default)]
+// pub struct Heap {
+//     pub roots: BTreeSet<>
+// }
diff --git a/src/lib.rs b/src/lib.rs
@@ -3,3 +3,4 @@ pub mod mem;
 pub mod object;
 pub mod vm;
 pub mod gc;
+pub mod heap;
diff --git a/src/object.rs b/src/object.rs
@@ -1,7 +1,5 @@
 use core::fmt;
-use std::cell::RefCell;
 use std::default;
-use std::rc::Rc;
 
 use crate::gc::TriColor;
 
@@ -22,14 +20,14 @@ impl fmt::Display for TypeValue {
 pub struct Object {
     pub ident: String,
     pub value: Option<TypeValue>,
-    pub reference: Vec<Rc<RefCell<Object>>>,
+    pub reference: Vec<Object>,
     pub marked: TriColor,
 }
 
 pub trait ObjectTrait {
     fn new(ident: String, value: TypeValue) -> Self;
     fn add_reference(&mut self, object: Object) -> usize;
-    fn delete_reference(&mut self, object: Rc<RefCell<Object>>) -> usize;
+    fn delete_reference(&mut self, object: Object) -> usize;
     fn len(&self) -> usize;
     fn is_empty(&self) -> bool;
     fn to_string(&self) -> String;
@@ -47,12 +45,12 @@ impl ObjectTrait for Object {
     }
 
     fn add_reference(&mut self, object: Object) -> usize {
-        self.reference.push(Rc::new(RefCell::new(object)));
+        self.reference.push(object);
         self.reference.len()
     }
 
-    fn delete_reference(&mut self, object: Rc<RefCell<Object>>) -> usize {
-        self.reference.retain(|x| !Rc::ptr_eq(x, &object));
+    fn delete_reference(&mut self, object: Object) -> usize {
+        self.reference.retain(|x| x != &object);
         self.reference.len()
     }
 
@@ -87,11 +85,3 @@ impl default::Default for Object {
         }
     }
 }
-
-// pub trait ObjectMarker {
-//     fn mark_from_root(&self, vm: &mut VM) {
-//         for obj in &vm.stack {
-//             obj.co
-//         }
-//     }
-// }
diff --git a/src/stack.rs b/src/stack.rs
diff --git a/src/vm.rs b/src/vm.rs
@@ -1,8 +1,11 @@
 use core::fmt;
 
-use crate::object::{Object, TypeValue};
+use crate::{
+    gc::TriColor,
+    object::{Object, TypeValue},
+};
 
-#[derive(Debug, PartialEq, Default)]
+#[derive(Debug, PartialEq, Default, Clone)]
 pub enum GCStatus {
     #[default]
     Idle,
@@ -23,10 +26,12 @@ pub enum OpCode {
     Halt,
     Pop,
     Push(TypeValue),
+    Mark,
+    Sweep,
 }
 
-#[derive(Debug, PartialEq, Default)]
-pub struct VM {
+#[derive(Debug, PartialEq, Default, Clone)]
+pub struct VirtualMachine {
     pub stack: Vec<Object>,
     pub op_codes: Vec<OpCode>,
     pub max_stack_size: usize,
@@ -49,9 +54,11 @@ pub trait VMTrait {
     fn len(&self) -> usize;
     fn is_empty(&self) -> bool;
     fn to_string(&self) -> String;
+
+    fn mark(&mut self);
 }
 
-impl VMTrait for VM {
+impl VMTrait for VirtualMachine {
     fn new(max_stack_size: usize, threshold: f64) -> Result<Self, VMError> {
         if threshold <= 0.0 || threshold >= 100.0 {
             return Err(VMError::InvalidRangeOfThreshold);
@@ -110,6 +117,41 @@ impl VMTrait for VM {
             self.gc_status
         )
     }
+
+    fn mark(&mut self) {
+        self.op_codes.push(OpCode::Mark);
+        let mut mark_stack = Vec::new();
+
+        while let Some(mut obj) = self.stack.pop() {
+            if obj.marked == TriColor::White {
+                obj.marked = TriColor::Gray;
+                mark_stack.push(obj.clone());
+            }
+
+            if obj.reference.len() > 0 {
+                let mut ref_obj = obj.reference.pop().unwrap();
+                if ref_obj.marked == TriColor::White {
+                    ref_obj.marked = TriColor::Gray;
+                    mark_stack.push(ref_obj.clone());
+                }
+                obj.reference.push(ref_obj);
+            }
+        }
+
+        while let Some(mut obj) = mark_stack.pop() {
+            if obj.marked == TriColor::Gray {
+                obj.marked = TriColor::Black;
+            }
+
+            if obj.reference.len() > 0 {
+                let mut ref_obj = obj.reference.pop().unwrap();
+                if ref_obj.marked == TriColor::Gray {
+                    ref_obj.marked = TriColor::Black;
+                }
+                obj.reference.push(ref_obj);
+            }
+        }
+    }
 }
 
 impl fmt::Display for VMError {
@@ -141,6 +183,8 @@ impl fmt::Display for OpCode {
             OpCode::Push(ref i) => write!(f, "Push: {}", i),
             OpCode::Pop => write!(f, "Pop"),
             OpCode::Halt => write!(f, "Halt"),
+            OpCode::Mark => write!(f, "Mark"),
+            OpCode::Sweep => write!(f, "Sweep"),
         }
     }
-}
+}
diff --git a/tests/vm_test.rs b/tests/vm_test.rs
@@ -2,15 +2,15 @@
 mod vm_tests {
     use gc_simulator::{
         object::{TypeValue, Object, ObjectTrait},
-        vm::{VMError, VMTrait, VM, OpCode},
+        vm::{VMError, VMTrait, VirtualMachine, OpCode},
     };
 
     static THRESHOLD: f64 = 0.75;
 
     #[test]
     fn test_new_vm() {
         let max_stack_size = 10;
-        let vm = VM::new(max_stack_size, THRESHOLD).unwrap();
+        let vm = VirtualMachine::new(max_stack_size, THRESHOLD).unwrap();
 
         assert_eq!(vm.max_stack_size, max_stack_size);
         assert_eq!(vm.stack, vec![]);
@@ -21,7 +21,7 @@ mod vm_tests {
     #[test]
     fn test_max_stack_size_exceed_max_int() {
         let max_stack_size = usize::MAX;
-        let vm = VM::new(max_stack_size, THRESHOLD).unwrap();
+        let vm = VirtualMachine::new(max_stack_size, THRESHOLD).unwrap();
 
         assert_eq!(vm.max_stack_size, max_stack_size);
         assert_eq!(vm.stack, vec![]);
@@ -32,7 +32,7 @@ mod vm_tests {
     #[test]
     fn test_push_objects_to_vm() {
         let max_stack_size = 10;
-        let mut vm = VM::new(max_stack_size, THRESHOLD).unwrap();
+        let mut vm = VirtualMachine::new(max_stack_size, THRESHOLD).unwrap();
 
         for i in 0..max_stack_size-1 {
             let value = Object::new(
@@ -48,7 +48,7 @@ mod vm_tests {
     #[test]
     fn test_stack_overflow() {
         let max_stack_size = 10;
-        let mut vm = VM::new(max_stack_size, THRESHOLD).unwrap();
+        let mut vm = VirtualMachine::new(max_stack_size, THRESHOLD).unwrap();
 
         for i in 0..max_stack_size {
             let value = Object::new(
@@ -69,7 +69,7 @@ mod vm_tests {
     #[test]
     fn test_pop() {
         let max_stack_size = 10;
-        let mut vm = VM::new(max_stack_size, THRESHOLD).unwrap();
+        let mut vm = VirtualMachine::new(max_stack_size, THRESHOLD).unwrap();
 
         for i in 0..max_stack_size {
             let value = Object::new(
@@ -95,7 +95,7 @@ mod vm_tests {
     #[test]
     fn stack_underflow() {
         let max_stack_size = 10;
-        let mut vm = VM::new(max_stack_size, THRESHOLD).unwrap();
+        let mut vm = VirtualMachine::new(max_stack_size, THRESHOLD).unwrap();
 
         assert_eq!(
             vm.pop().unwrap_err(), 
@@ -106,7 +106,7 @@ mod vm_tests {
     #[test]
     fn test_op_code() {
         let max_stack_size = 10;
-        let mut vm = VM::new(max_stack_size, THRESHOLD).unwrap();
+        let mut vm = VirtualMachine::new(max_stack_size, THRESHOLD).unwrap();
 
         let value = Object::new(
             String::from("test"), 
@@ -123,7 +123,7 @@ mod vm_tests {
     #[test]
     fn test_vm_debug_string() {
         let max_stack_size = 10;
-        let mut vm = VM::new(max_stack_size, THRESHOLD).unwrap();
+        let mut vm = VirtualMachine::new(max_stack_size, THRESHOLD).unwrap();
 
         let value = Object::new(
             String::from("test"),