imxyy1soope1/nixjit
1
0
Fork 0
Code Issues Pull Requests Actions Projects 1 Releases Activity

feat: lots of optimization

Browse Source 
* allocate vm stack on the stack
* use Rc instead of Arc
* optimize recursive attribute set
This commit is contained in:
imxyy_soope_
2025-05-11 12:57:29 +08:00
parent 07b486848f
commit 05e82d4021
12 changed files with 137 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
src/vm/env.rs
View File

@@ -1,15 +1,15 @@
use std::cell::RefCell;
use std::sync::Arc;
use std::rc::Rc;
use rpds::HashTrieMapSync;
use rpds::HashTrieMap;
use crate::ty::common::Symbol;
use crate::ty::internal::Value;
#[derive(Debug, Default)]
#[derive(Debug, Default, PartialEq)]
pub struct Env<'vm> {
last: RefCell<Option<Arc<Env<'vm>>>>,
map: Arc<RefCell<HashTrieMapSync<Symbol, Value<'vm>>>>,
last: RefCell<Option<Rc<Env<'vm>>>>,
pub map: RefCell<HashTrieMap<Symbol, Value<'vm>>>,
}
impl Clone for Env<'_> {
@@ -19,16 +19,16 @@ impl Clone for Env<'_> {
self.last
.borrow()
.clone()
.map(|e| Arc::new(e.as_ref().clone())),
.map(|e| Rc::new(e.as_ref().clone())),
),
map: Arc::new(RefCell::new(self.map.borrow().clone())),
map: RefCell::new(self.map.borrow().clone()),
}
}
}
#[derive(Debug, Clone)]
pub struct CapturedEnv<'vm> {
env: Arc<Env<'vm>>,
env: Rc<Env<'vm>>,
}
impl<'vm> Env<'vm> {
@@ -36,15 +36,15 @@ impl<'vm> Env<'vm> {
Env::default()
}
pub fn lookup(&self, symbol: Symbol) -> Option<Value<'vm>> {
self.map.borrow().get(&symbol).cloned()
pub fn lookup(&self, symbol: &Symbol) -> Option<Value<'vm>> {
self.map.borrow().get(symbol).cloned()
}
pub fn insert(&self, symbol: Symbol, value: Value<'vm>) {
self.map.borrow_mut().insert_mut(symbol, value);
}
pub fn enter(&self, new: HashTrieMapSync<Symbol, Value<'vm>>) {
pub fn enter(&self, new: HashTrieMap<Symbol, Value<'vm>>) {
let mut map = self.map.borrow().clone();
for (k, v) in new.iter() {
map.insert_mut(k.clone(), v.clone());
@@ -53,17 +53,23 @@ impl<'vm> Env<'vm> {
last: self.last.clone(),
map: self.map.clone(),
};
*self.last.borrow_mut() = Some(Arc::new(last));
*self.last.borrow_mut() = Some(Rc::new(last));
*self.map.borrow_mut() = map;
}
pub fn enter_rec(&self) -> Arc<RefCell<HashTrieMapSync<Symbol, Value<'vm>>>> {
pub fn enter_rec(self: &mut Rc<Self>, new: Rc<Env<'vm>>) {
let last = (*self.last.borrow_mut()).take();
*self = new;
*self.last.borrow_mut() = last;
}
pub fn new_rec(self: Rc<Self>) -> Rc<Self> {
let last = Env {
last: self.last.clone(),
map: self.map.clone(),
};
*self.last.borrow_mut() = Some(Arc::new(last));
self.map.clone()
*self.last.borrow_mut() = Some(Rc::new(last));
self.clone()
}
pub fn leave(&self) {
@@ -73,17 +79,17 @@ impl<'vm> Env<'vm> {
*self.map.borrow_mut() = map;
}
pub fn captured(self: Arc<Self>) -> CapturedEnv<'vm> {
pub fn captured(self: Rc<Self>) -> CapturedEnv<'vm> {
CapturedEnv { env: self }
}
}
impl<'vm> CapturedEnv<'vm> {
pub fn lookup(&self, symbol: Symbol) -> Option<Value<'vm>> {
pub fn lookup(&self, symbol: &Symbol) -> Option<Value<'vm>> {
self.env.lookup(symbol)
}
pub fn released(self) -> Arc<Env<'vm>> {
Arc::new(self.env.as_ref().clone())
pub fn released(self) -> Rc<Env<'vm>> {
Rc::new(self.env.as_ref().clone())
}
}

41
src/vm/mod.rs
View File

@@ -1,5 +1,5 @@
use std::cell::OnceCell;
use std::sync::Arc;
use std::rc::Rc;
use crate::builtins::env;
use crate::bytecode::{BinOp, OpCode, OpCodes, Program, UnOp};
@@ -65,11 +65,11 @@ impl<'vm> VM<'vm> {
unsafe { &*(&self.funcs[idx] as *const _) }
}
pub fn eval(&self, opcodes: OpCodes, env: Arc<Env<'vm>>) -> Result<Value<'vm>> {
pub fn eval(&self, opcodes: OpCodes, env: Rc<Env<'vm>>) -> Result<Value<'vm>> {
let mut stack = Stack::<STACK_SIZE>::new();
let mut iter = opcodes.into_iter();
while let Some(opcode) = iter.next() {
let jmp = self.single_op(opcode, &mut stack, env.clone())?;
let jmp = self.single_op(opcode, &mut stack, &env)?;
for _ in 0..jmp {
iter.next().unwrap();
}
@@ -85,15 +85,16 @@ impl<'vm> VM<'vm> {
&self,
opcode: OpCode,
stack: &'s mut Stack<'vm, CAP>,
env: Arc<Env<'vm>>,
env: &Rc<Env<'vm>>,
) -> Result<usize>
{
match opcode {
OpCode::Illegal => panic!("illegal opcode"),
OpCode::Const { value } => stack.push(Value::Const(value))?,
OpCode::LoadThunk { idx } => {
self.thunks[idx].capture(env);
stack.push(Value::Thunk(self.thunks[idx].clone()))?
let thunk = self.get_thunk(idx);
thunk.capture(env.clone());
stack.push(Value::ThunkRef(self.get_thunk(idx)))?
}
OpCode::LoadValue { idx } => {
stack.push(self.get_thunk(idx).force(self)?)?;
@@ -123,7 +124,7 @@ impl<'vm> VM<'vm> {
}
OpCode::Func { idx } => {
let func = self.get_func(idx);
func.env.get_or_init(|| env.captured());
func.env.get_or_init(|| env.clone().captured());
stack.push(Value::Func(func))?;
}
OpCode::UnOp { op } => {
@@ -167,13 +168,13 @@ impl<'vm> VM<'vm> {
OpCode::AttrSet => {
stack.push(Value::AttrSet(AttrSet::empty()))?;
}
OpCode::RecAttrSet => {
let new = env.enter_rec();
stack.push(Value::RecAttrSet(RecAttrSet::new(new)))?;
}
OpCode::FinalizeRec => {
env.enter(stack.tos()?.clone().unwrap_attr_set().into_inner());
stack.tos_mut()?.as_mut().unwrap_attr_set().capture(env.clone());
},
OpCode::PushStaticAttr { name } => {
let val = stack.pop();
stack.tos_mut()?.push_attr(Symbol::new(name), val);
stack.tos_mut()?.push_attr(Symbol::new(name.clone()), val);
}
OpCode::PushDynamicAttr => {
let val = stack.pop();
@@ -183,21 +184,21 @@ impl<'vm> VM<'vm> {
stack.tos_mut()?.push_attr(sym, val);
}
OpCode::Select { sym } => {
stack.tos_mut()?.force(self)?.select(Symbol::new(sym))?;
stack.tos_mut()?.force(self)?.select(&Symbol::new(sym))?;
}
OpCode::SelectOrDefault { sym } => {
let default = stack.pop();
stack
.tos_mut()?
.force(self)?
.select_with_default(Symbol::new(sym), default)?;
.select_with_default(&Symbol::new(sym), default)?;
}
OpCode::SelectDynamic => {
let mut val = stack.pop();
val.force(self)?;
val.coerce_to_string();
let sym = val.unwrap_const().unwrap_string().into();
stack.tos_mut()?.force(self)?.select(sym)?;
stack.tos_mut()?.force(self)?.select(&sym)?;
}
OpCode::SelectDynamicOrDefault => {
let default = stack.pop();
@@ -208,26 +209,26 @@ impl<'vm> VM<'vm> {
stack
.tos_mut()?
.force(self)?
.select_with_default(sym, default)?;
.select_with_default(&sym, default)?;
}
OpCode::HasAttr { sym } => {
stack.tos_mut()?.force(self)?.has_attr(Symbol::new(sym));
stack.tos_mut()?.force(self)?.has_attr(&Symbol::new(sym));
}
OpCode::HasDynamicAttr => {
let mut val = stack.pop();
val.coerce_to_string();
let sym = val.unwrap_const().unwrap_string().into();
stack.tos_mut()?.force(self)?.has_attr(sym);
stack.tos_mut()?.force(self)?.has_attr(&sym);
}
OpCode::LookUp { sym } => {
let sym = Symbol::new(sym);
stack.push(
env.lookup(Symbol::new(sym.clone()))
env.lookup(&sym)
.ok_or_else(|| Error::EvalError(format!(r#""{sym}" not found"#)))?,
)?;
}
OpCode::EnterEnv => match stack.pop() {
Value::AttrSet(attrs) => env.enter(attrs.into_inner()),
Value::RecAttrSet(attrs) => env.enter(attrs.into_inner()),
_ => unreachable!(),
},
OpCode::LeaveEnv => {

17
src/vm/stack.rs
View File

@@ -7,7 +7,8 @@ use crate::ty::internal::Value;
pub const STACK_SIZE: usize = 8 * 1024 / size_of::<Value>();
pub struct Stack<'vm, const CAP: usize> {
items: Box<[MaybeUninit<Value<'vm>>; CAP]>,
// items: Box<[MaybeUninit<Value<'vm>>; CAP]>,
items: [MaybeUninit<Value<'vm>>; CAP],
top: usize,
}
@@ -24,11 +25,7 @@ macro_rules! into {
impl<'vm, const CAP: usize> Stack<'vm, CAP> {
pub fn new() -> Self {
Stack {
items: (0..CAP)
.map(|_| MaybeUninit::uninit())
.collect::<Box<_>>()
.try_into()
.unwrap(),
items: [const { MaybeUninit::uninit() }; CAP],
top: 0,
}
}
@@ -55,6 +52,14 @@ impl<'vm, const CAP: usize> Stack<'vm, CAP> {
unsafe { replace(item, MaybeUninit::uninit()).assume_init() }
}
pub fn tos(&self) -> Result<&Value<'vm>> {
if self.top == 0 {
panic!("stack empty")
} else {
Ok(into!(&self.items[self.top - 1]))
}
}
pub fn tos_mut(&mut self) -> Result<&mut Value<'vm>> {
if self.top == 0 {
panic!("stack empty")

4
src/vm/test.rs
View File

@@ -3,7 +3,7 @@ extern crate test;
use test::{Bencher, black_box};
use ecow::EcoString;
use rpds::{ht_map_sync, vector_sync};
use rpds::{ht_map, vector_sync};
use crate::compile::compile;
use crate::ir::downgrade;
@@ -64,7 +64,7 @@ macro_rules! list {
macro_rules! attrs {
($($x:tt)*) => (
Value::AttrSet(AttrSet::new(ht_map_sync!{$($x)*}))
Value::AttrSet(AttrSet::new(ht_map!{$($x)*}))
)
}