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

61
src/ty/internal/attrset.rs
View File

@@ -1,11 +1,10 @@
use std::cell::RefCell;
use std::sync::Arc;
use std::rc::Rc;
use derive_more::Constructor;
use rpds::HashTrieMapSync;
use rpds::HashTrieMap;
use crate::error::Result;
use crate::vm::VM;
use crate::vm::{Env, VM};
use super::super::common::Symbol;
use super::super::public as p;
@@ -13,13 +12,13 @@ use super::{ToPublic, Value};
#[derive(Debug, Constructor, Clone, PartialEq)]
pub struct AttrSet<'vm> {
data: HashTrieMapSync<Symbol, Value<'vm>>,
data: HashTrieMap<Symbol, Value<'vm>>,
}
impl<'vm> AttrSet<'vm> {
pub fn empty() -> Self {
AttrSet {
data: HashTrieMapSync::new_sync(),
data: HashTrieMap::new(),
}
}
@@ -34,14 +33,22 @@ impl<'vm> AttrSet<'vm> {
self.data.insert_mut(sym, val);
}
pub fn select(&self, sym: Symbol) -> Option<Value<'vm>> {
pub fn select(&self, sym: &Symbol) -> Option<Value<'vm>> {
self.data.get(&sym).cloned()
}
pub fn has_attr(&self, sym: Symbol) -> bool {
pub fn has_attr(&self, sym: &Symbol) -> bool {
self.data.get(&sym).is_some()
}
pub fn capture(&mut self, env: Rc<Env<'vm>>) {
self.data = self
.data
.into_iter()
.map(|(k, v)| (k.clone(), match v.clone() { x @ Value::ThunkRef(thunk) => { thunk.capture(env.clone()); x }, x => x }))
.collect();
}
pub fn update(mut self, other: AttrSet<'vm>) -> AttrSet<'vm> {
for (k, v) in other.data.iter() {
self.push_attr_force(k.clone(), v.clone())
@@ -50,17 +57,17 @@ impl<'vm> AttrSet<'vm> {
}
pub fn update_rec(mut self, other: RecAttrSet<'vm>) -> AttrSet<'vm> {
for (k, v) in other.data.borrow().iter() {
for (k, v) in other.data.map.borrow().iter() {
self.push_attr_force(k.clone(), v.clone())
}
self
}
pub fn into_inner(self) -> HashTrieMapSync<Symbol, Value<'vm>> {
pub fn into_inner(self) -> HashTrieMap<Symbol, Value<'vm>> {
self.data
}
pub fn as_inner(&self) -> &HashTrieMapSync<Symbol, Value<'vm>> {
pub fn as_inner(&self) -> &HashTrieMap<Symbol, Value<'vm>> {
&self.data
}
@@ -92,37 +99,37 @@ impl ToPublic for AttrSet<'_> {
#[derive(Debug, Constructor, Clone, PartialEq)]
pub struct RecAttrSet<'vm> {
data: Arc<RefCell<HashTrieMapSync<Symbol, Value<'vm>>>>,
data: Rc<Env<'vm>>
}
impl<'vm> RecAttrSet<'vm> {
pub fn empty() -> Self {
RecAttrSet {
data: Arc::default(),
data: Rc::default(),
}
}
pub fn push_attr_force(&mut self, sym: Symbol, val: Value<'vm>) {
self.data.borrow_mut().insert_mut(sym, val);
self.data.insert(sym, val);
}
pub fn push_attr(&mut self, sym: Symbol, val: Value<'vm>) {
if self.data.borrow().get(&sym).is_some() {
if self.data.lookup(&sym).is_some() {
todo!()
}
self.data.borrow_mut().insert_mut(sym, val);
self.data.insert(sym, val);
}
pub fn select(&self, sym: Symbol) -> Option<Value<'vm>> {
self.data.borrow().get(&sym).cloned()
pub fn select(&self, sym: &Symbol) -> Option<Value<'vm>> {
self.data.lookup(sym)
}
pub fn has_attr(&self, sym: Symbol) -> bool {
self.data.borrow().get(&sym).is_some()
pub fn has_attr(&self, sym: &Symbol) -> bool {
self.data.lookup(sym).is_some()
}
pub fn update(mut self, other: RecAttrSet<'vm>) -> RecAttrSet<'vm> {
for (k, v) in other.data.borrow().iter() {
for (k, v) in other.data.map.borrow().iter() {
self.push_attr_force(k.clone(), v.clone())
}
self
@@ -131,6 +138,7 @@ impl<'vm> RecAttrSet<'vm> {
pub fn update_normal(self, other: AttrSet<'vm>) -> AttrSet<'vm> {
let map = self
.data
.map
.borrow()
.into_iter()
.map(|(k, v)| (k.clone(), v.clone()))
@@ -142,17 +150,18 @@ impl<'vm> RecAttrSet<'vm> {
new
}
pub fn into_inner(self) -> HashTrieMapSync<Symbol, Value<'vm>> {
self.data.borrow().clone()
pub fn into_inner(self) -> Rc<Env<'vm>> {
self.data
}
pub fn from_inner(data: Arc<RefCell<HashTrieMapSync<Symbol, Value<'vm>>>>) -> Self {
pub fn from_inner(data: Rc<Env<'vm>>) -> Self {
RecAttrSet { data }
}
pub fn force_deep(&mut self, vm: &VM<'vm>) -> Result<()> {
let mut map: Vec<_> = self
.data
.map
.borrow()
.into_iter()
.map(|(k, v)| (k.clone(), v.clone()))
@@ -161,7 +170,7 @@ impl<'vm> RecAttrSet<'vm> {
.map(|(_, v)| v.force_deep(vm).map(|_| ()))
.find(|v| v.is_err())
.map_or(Ok(()), |err| err)?;
*self.data.borrow_mut() = map.into_iter().collect();
*self.data.map.borrow_mut() = map.into_iter().collect();
Ok(())
}
}
@@ -169,7 +178,7 @@ impl<'vm> RecAttrSet<'vm> {
impl ToPublic for RecAttrSet<'_> {
fn to_public(self, vm: &VM) -> p::Value {
p::Value::AttrSet(p::AttrSet::new(
self.data
self.data.map
.borrow()
.iter()
.map(|(sym, value)| (sym.clone(), value.clone().to_public(vm)))

9
src/ty/internal/func.rs
View File

@@ -54,14 +54,14 @@ impl<'vm> Func<'vm> {
let env = self.env.get().unwrap().clone().released();
match &self.param {
Ident(ident) => env.enter(HashTrieMap::new_sync().insert(ident.clone().into(), arg)),
Ident(ident) => env.enter(HashTrieMap::new().insert(ident.clone().into(), arg)),
Formals {
formals,
ellipsis,
alias,
} => {
let arg = arg.unwrap_attr_set();
let mut new = HashTrieMap::new_sync();
let mut new = HashTrieMap::new();
if !ellipsis
&& arg
.as_inner()
@@ -73,11 +73,12 @@ impl<'vm> Func<'vm> {
todo!()
}
for (formal, default) in formals {
let formal = formal.clone().into();
let arg = arg
.select(formal.clone().into())
.select(&formal)
.or_else(|| default.map(|idx| Value::ThunkRef(vm.get_thunk(idx))))
.unwrap();
new.insert_mut(formal.clone().into(), arg);
new.insert_mut(formal, arg);
}
if let Some(alias) = alias {
new.insert_mut(alias.clone().into(), Value::AttrSet(arg));

32
src/ty/internal/mod.rs
View File

@@ -1,5 +1,5 @@
use std::cell::RefCell;
use std::sync::Arc;
use std::rc::Rc;
use derive_more::{IsVariant, Unwrap};
@@ -32,7 +32,7 @@ pub trait ToPublic {
#[derive(Debug, Clone)]
pub struct Thunk<'vm> {
pub thunk: RefCell<_Thunk<'vm>>,
pub env: RefCell<Option<Arc<Env<'vm>>>>,
pub env: RefCell<Option<Rc<Env<'vm>>>>,
}
#[derive(Debug, IsVariant, Unwrap, Clone)]
@@ -54,7 +54,7 @@ impl<'vm> Thunk<'vm> {
self.thunk.borrow().clone().unwrap_code()
}
pub fn capture(&self, env: Arc<Env<'vm>>) {
pub fn capture(&self, env: Rc<Env<'vm>>) {
*self.env.borrow_mut() = Some(env);
}
@@ -137,7 +137,7 @@ pub enum ValueAsMut<'v, 'vm: 'v> {
}
impl<'v, 'vm: 'v> Value<'vm> {
pub fn as_ref(&'vm self) -> ValueAsRef<'v, 'vm> {
pub fn as_ref(&'v self) -> ValueAsRef<'v, 'vm> {
use Value::*;
use ValueAsRef as R;
match self {
@@ -154,7 +154,7 @@ impl<'v, 'vm: 'v> Value<'vm> {
}
}
pub fn as_mut(&'vm mut self) -> ValueAsMut<'v, 'vm> {
pub fn as_mut(&'v mut self) -> ValueAsMut<'v, 'vm> {
use Value::*;
use ValueAsMut as M;
match self {
@@ -379,13 +379,13 @@ impl<'vm> Value<'vm> {
}
}
pub fn select(&mut self, sym: Symbol) -> Result<&mut Self> {
pub fn select(&mut self, sym: &Symbol) -> Result<&mut Self> {
let val = match self {
Value::AttrSet(attrs) => attrs
.select(sym.clone())
.select(sym)
.ok_or_else(|| Error::EvalError(format!("{sym:?} not found"))),
Value::RecAttrSet(attrs) => attrs
.select(sym.clone())
.select(sym)
.ok_or_else(|| Error::EvalError(format!("{sym:?} not found"))),
Value::Catchable(_) => return Ok(self),
_ => Err(Error::EvalError(format!(
@@ -397,10 +397,10 @@ impl<'vm> Value<'vm> {
Ok(self)
}
pub fn select_with_default(&mut self, sym: Symbol, default: Value<'vm>) -> Result<&mut Self> {
pub fn select_with_default(&mut self, sym: &Symbol, default: Value<'vm>) -> Result<&mut Self> {
let val = match self {
Value::AttrSet(attrs) => attrs.select(sym.clone()).unwrap_or(default),
Value::RecAttrSet(attrs) => attrs.select(sym.clone()).unwrap_or(default),
Value::AttrSet(attrs) => attrs.select(sym).unwrap_or(default),
Value::RecAttrSet(attrs) => attrs.select(sym).unwrap_or(default),
Value::Catchable(_) => return Ok(self),
_ => {
return Err(Error::EvalError(format!(
@@ -413,7 +413,7 @@ impl<'vm> Value<'vm> {
Ok(self)
}
pub fn has_attr(&mut self, sym: Symbol) -> &mut Self {
pub fn has_attr(&mut self, sym: &Symbol) -> &mut Self {
if let Value::AttrSet(attrs) = self {
let val = VmConst(Const::Bool(attrs.has_attr(sym)));
*self = val;
@@ -440,6 +440,9 @@ impl<'vm> Value<'vm> {
if let Value::Thunk(thunk) = self {
let value = thunk.force(vm)?;
*self = value
} else if let Value::ThunkRef(thunk) = self {
let value = thunk.force(vm)?;
*self = value
}
Ok(self)
}
@@ -451,6 +454,11 @@ impl<'vm> Value<'vm> {
let _ = value.force_deep(vm)?;
*self = value;
}
Value::ThunkRef(thunk) => {
let mut value = thunk.force(vm)?;
let _ = value.force_deep(vm)?;
*self = value;
}
Value::List(list) => list.force_deep(vm)?,
Value::AttrSet(attrs) => attrs.force_deep(vm)?,
Value::RecAttrSet(attrs) => attrs.force_deep(vm)?,