Add (nonfunctional) LoxString

remove big files

Author: Darksecond

lox-gc/src/heap.rs

@@ -1,7 +1,7 @@
 use std::cell::Cell;
 
-/*
 struct MemoryMap {
+    size: usize,
     data: *mut u8,
 }
 
@@ -12,6 +12,7 @@ impl MemoryMap {
             let data = std::alloc::alloc(layout);
 
             Self {
+                size,
                 data,
             }
         }
@@ -21,7 +22,15 @@ impl MemoryMap {
         self.data
     }
 }
-*/
+
+impl Drop for MemoryMap {
+    fn drop(&mut self) {
+        let layout = std::alloc::Layout::array::<u8>(self.size).unwrap().align_to(4096).unwrap();
+        unsafe {
+            std::alloc::dealloc(self.data, layout);
+        }
+    }
+}
 
 /// Returns the number of pages needed for `n` bytes (rounding up).
 const fn bytes_to_pages(n: usize) -> usize {
@@ -37,17 +46,18 @@ const fn bytes_to_pages(n: usize) -> usize {
 struct PdIdx(u32);
 
 struct AddrSpace {
-    mem: mmap::MemoryMap,
+    //mem: mmap::MemoryMap,
+    mem: MemoryMap,
 
     used_pds: Cell<u32>,
 }
 
 impl AddrSpace {
     const PAGE_BYTES: usize = 4096;
 
-    const DATA_BYTES: usize = 4 * 1024 * 1024 * 1024; // 4G
+    //const DATA_BYTES: usize = 4 * 1024 * 1024 * 1024; // 4G
     //const DATA_BYTES: usize = 64 * 1024 * 1024; // 64MB
-    //const DATA_BYTES: usize = 32 * 1024 * 1024; // 32MB
+    const DATA_BYTES: usize = 32 * 1024 * 1024; // 32MB
     const DATA_PAGES: usize = Self::DATA_BYTES / Self::PAGE_BYTES;
 
     const PD_PAGES: usize = bytes_to_pages(Self::DATA_PAGES * std::mem::size_of::<PageDescriptor>());
@@ -63,9 +73,10 @@ impl AddrSpace {
 
     /// Constructs a new [`AddrSpace`]. This will return `None` on error.
     pub fn create() -> Option<Self> {
-        use mmap::*;
+        //use mmap::*;
 
-        let mem = MemoryMap::new(Self::TOTAL_BYTES, &[MapOption::MapReadable, MapOption::MapWritable]).ok()?;
+        //let mem = MemoryMap::new(Self::TOTAL_BYTES, &[MapOption::MapReadable, MapOption::MapWritable]).ok()?;
+        let mem = self::MemoryMap::new(Self::TOTAL_BYTES);
 
         Some(Self {
             mem,
@@ -659,8 +670,8 @@ impl Heap {
             },
         };
 
-        //println!("page {:?}", page.idx);
         let index = page.take_next_block().expect("Full page in free list");
+        //println!("page {:?} {:?} {} {:?}", size_class, page.idx, index, size_class.block_bytes());
 
         if page.is_full() {
             //println!("full {:?}", page.idx);

lox-vm/src/array.rs

@@ -43,6 +43,30 @@ impl<T> Array<T> where T: Copy {
     }
 }
 
+impl<T> Array<T> where T: Clone {
+    //TODO rewrite.
+    pub fn extend_from_slice(&mut self, other: &[T]) {
+        for elem in other {
+            self.push(elem.clone());
+        }
+    }
+}
+
+impl<T> Clone for Array<T> {
+    fn clone(&self) -> Self {
+        unsafe {
+            let ptr = lox_gc::alloc(std::alloc::Layout::array::<T>(self.cap).unwrap()) as *mut T;
+            std::ptr::copy_nonoverlapping(self.ptr.as_ptr(), ptr, self.cap);
+
+            Self {
+                cap: self.cap,
+                len: self.len,
+                ptr: NonNull::new_unchecked(ptr),
+            }
+        }
+    }
+}
+
 impl<T> Array<T> {
     pub fn new() -> Self {
         assert!(mem::size_of::<T>() != 0, "must not be ZST");
@@ -127,15 +151,20 @@ impl<T> Array<T> {
         assert!(new_layout.size() <= isize::MAX as usize, "Allocation too large");
 
         let new_ptr = if self.cap == 0 {
-            unsafe { lox_gc::alloc(new_layout) }
+            let new_ptr = unsafe { lox_gc::alloc(new_layout) };
+            dbg!(new_layout, new_ptr);
+            new_ptr
         } else {
             //TODO We copy more than we need to.
             let old_layout = Layout::array::<T>(self.cap).unwrap();
             let old_ptr = self.ptr.as_ptr() as *mut u8;
             let new_ptr = unsafe { lox_gc::alloc(new_layout) };
+            dbg!(new_layout, old_layout.size(), old_ptr, new_ptr);
+
             unsafe {
-                ptr::copy_nonoverlapping(old_ptr, new_ptr, old_layout.size());
+                ptr::copy(old_ptr, new_ptr, old_layout.size());
             }
+
             new_ptr
         };
 

lox-vm/src/lib.rs

@@ -12,7 +12,10 @@ mod stack;
 mod ops;
 mod fiber;
 mod table;
+
+//TODO Move to lox-gc
 mod array;
+mod string;
 
 use lox_bytecode::bytecode::Module;
 use runtime::Runtime;

lox-vm/src/memory.rs

@@ -16,9 +16,13 @@ pub use class::*;
 pub use native_function::*;
 pub use bound_method::*;
 
+use crate::string::LoxString;
+
 pub fn print(value: crate::gc::Gc<()>, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     if value.is::<String>() {
         write!(f, "{}", value.cast::<String>().as_str())
+    } else if value.is::<LoxString>() {
+        write!(f, "{}", value.cast::<LoxString>().as_str())
     } else if value.is::<Closure>() {
         write!(f, "<fn {}>", value.cast::<Closure>().function.name)
     } else if value.is::<BoundMethod>() {

lox-vm/src/memory/import.rs

@@ -6,13 +6,14 @@ use lox_bytecode::bytecode;
 use crate::table::Table;
 use crate::value::Value;
 use crate::array::Array;
+use crate::string::LoxString;
 
 pub struct Import {
     pub name: String,
     module: Module,
     globals: UnsafeCell<Table>,
     symbols: Array<Symbol>,
-    strings: Array<Gc<String>>,
+    strings: Array<Gc<LoxString>>,
 }
 
 unsafe impl Trace for Import {
@@ -40,10 +41,15 @@ impl Import {
             interner.intern(identifier)
         }).collect();
 
-        let strings = module.strings.iter().map(|value| {
-            lox_gc::manage(value.clone().into())
+        println!("HERE");
+        let strings: Array<Gc<LoxString>> = module.strings.iter().map(|value| {
+            lox_gc::manage(value.into())
         }).collect();
 
+        for value in strings.iter() {
+            println!("STR {}", value);
+        }
+
         Self {
             name: name.into(),
             module,
@@ -81,7 +87,7 @@ impl Import {
     }
 
     #[inline]
-    pub(crate) fn string(&self, index: ConstantIndex) -> Gc<String> {
+    pub(crate) fn string(&self, index: ConstantIndex) -> Gc<LoxString> {
         unsafe {
             *self.strings.get_unchecked(index)
         }

lox-vm/src/runtime.rs

@@ -8,6 +8,7 @@ use super::memory::*;
 use super::interner::{Symbol, Interner};
 use super::gc::{Gc, Trace, Tracer};
 use crate::fiber::Fiber;
+use crate::string::LoxString;
 use std::collections::HashMap;
 
 #[derive(PartialEq, Eq, Copy, Clone)]
@@ -119,9 +120,9 @@ impl Runtime {
 
     #[cold]
     pub fn concat(&self, a: Value, b: Value) -> Signal {
-        if a.is_object_of_type::<String>() && b.is_object_of_type::<String>() {
-            let a = a.as_object().cast::<String>();
-            let b = b.as_object().cast::<String>();
+        if a.is_object_of_type::<LoxString>() && b.is_object_of_type::<LoxString>() {
+            let a = a.as_object().cast::<LoxString>();
+            let b = b.as_object().cast::<LoxString>();
             self.push_string(format!("{}{}", a.as_str(), b.as_str()));
             return Signal::More;
         }
@@ -248,9 +249,9 @@ impl Runtime {
     }
 
     #[cold]
-    pub fn push_string(&self, string: impl Into<String>) {
+    pub fn push_string(&self, string: impl Into<LoxString>) {
         let string = string.into();
-        let root: Gc<String> = self.manage(string.into());
+        let root: Gc<LoxString> = self.manage(string);
         self.fiber.with_stack(|stack| {
             stack.push(Value::from_object(root.erase()));
         });

lox-vm/src/string.rs

@@ -0,0 +1,131 @@
+use crate::array::Array;
+use std::ops::{Deref, DerefMut};
+use std::str;
+use std::borrow::{Borrow, BorrowMut};
+use std::fmt;
+use std::hash::Hash;
+use lox_gc::{Trace, Tracer};
+
+pub struct LoxString {
+    vec: Array<u8>,
+}
+
+impl LoxString {
+    pub fn new() -> Self {
+        Self {
+            vec: Array::new(),
+        }
+    }
+
+    pub fn as_bytes(&self) -> &[u8] {
+        &self.vec
+    }
+
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self {
+            vec: Array::with_capacity(capacity),
+        }
+    }
+
+    pub fn as_str(&self) -> &str {
+        self
+    }
+
+    pub fn push_str(&mut self, string: &str) {
+        self.vec.extend_from_slice(string.as_bytes());
+    }
+}
+
+unsafe impl Trace for LoxString {
+    fn trace(&self, _tracer: &mut Tracer) {
+        self.vec.mark();
+    }
+}
+
+impl PartialEq<LoxString> for LoxString {
+    fn eq(&self, other: &LoxString) -> bool {
+        PartialEq::eq(&self[..], &other[..])
+    }
+
+    fn ne(&self, other: &LoxString) -> bool {
+        PartialEq::ne(&self[..], &other[..])
+    }
+}
+
+impl From<String> for LoxString {
+    fn from(value: String) -> Self {
+        let mut str = LoxString::with_capacity(value.len());
+        str.push_str(&value);
+        str
+    }
+}
+
+impl From<&String> for LoxString {
+    fn from(value: &String) -> Self {
+        let mut str = LoxString::with_capacity(value.len());
+        str.push_str(value);
+        str
+    }
+}
+
+impl fmt::Debug for LoxString {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&**self, f)
+    }
+}
+
+impl fmt::Display for LoxString {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&**self, f)
+    }
+}
+
+impl Hash for LoxString {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        (&**self).hash(state)
+    }
+}
+
+impl Default for LoxString {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Deref for LoxString {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        unsafe { str::from_utf8_unchecked(&self.vec) }
+    }
+}
+
+impl DerefMut for LoxString {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        unsafe { str::from_utf8_unchecked_mut(&mut self.vec) }
+    }
+}
+
+impl AsRef<str> for LoxString {
+    fn as_ref(&self) -> &str {
+        self
+    }
+}
+
+impl Borrow<str> for LoxString {
+    fn borrow(&self) -> &str {
+        &self[..]
+    }
+}
+
+impl BorrowMut<str> for LoxString {
+    fn borrow_mut(&mut self) -> &mut str {
+        &mut self[..]
+    }
+}
+
+impl AsRef<[u8]> for LoxString {
+    fn as_ref(&self) -> &[u8] {
+        self.as_bytes()
+    }
+}

lox-vm/src/value.rs

@@ -122,8 +122,12 @@ impl From<bool> for Value {
 impl PartialEq for Value {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
+        use crate::string::LoxString;
+
         if self.is_number() && other.is_number() {
             self.as_number() == other.as_number()
+        } else if self.is_object_of_type::<LoxString>() && other.is_object_of_type::<LoxString>() {
+            &*self.as_object().cast::<LoxString>() == &*other.as_object().cast::<LoxString>()
         } else if self.is_object() && other.is_object() {
             self.as_object() == other.as_object()
         } else {

simple.lox

@@ -1 +1,2 @@
 print "a" + "b";
+print "a"+"b" == "a"+"b";