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

fix: thunk & function

Browse Source
This commit is contained in:
imxyy_soope_
2025-05-15 11:11:11 +08:00
parent bcb6c48cfa
commit 2293b9e2de
10 changed files with 76 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -42,23 +42,18 @@ impl<'vm> AttrSet<'vm> {
self.data.get(&sym).is_some()
}
pub fn capture(&mut self, env: Rc<Env<'vm>>) {
self.data = self
pub fn capture(&mut self, env: &Rc<Env<'vm>>) {
self
.data
.into_iter()
.map(|(k, v)| {
(
k.clone(),
.iter()
.for_each(|(_, v)| {
match v.clone() {
x @ Value::ThunkRef(thunk) => {
Value::Thunk(ref thunk) => {
thunk.capture(env.clone());
x
}
x => x,
},
)
_ => ()
}
})
.collect();
}
pub fn update(mut self, other: AttrSet<'vm>) -> AttrSet<'vm> {
@@ -83,7 +78,7 @@ impl<'vm> AttrSet<'vm> {
&self.data
}
pub fn force_deep(&mut self, vm: &VM<'vm, '_>) -> Result<()> {
pub fn force_deep(&mut self, vm: &'vm VM<'_>) -> Result<()> {
let mut map: Vec<_> = self
.data
.into_iter()
@@ -170,7 +165,7 @@ impl<'vm> RecAttrSet<'vm> {
RecAttrSet { data }
}
pub fn force_deep(&mut self, vm: &VM<'vm, '_>) -> Result<()> {
pub fn force_deep(&mut self, vm: &'vm VM<'_>) -> Result<()> {
let mut map: Vec<_> = self
.data
.map

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

@@ -1,14 +1,15 @@
use std::cell::OnceCell;
use std::rc::Rc;
use ecow::EcoString;
use itertools::Itertools;
use rpds::HashTrieMap;
use derive_more::Constructor;
use crate::bytecode::OpCodes;
use crate::bytecode::Func as BFunc;
use crate::error::Result;
use crate::ir;
use crate::ty::internal::Value;
use crate::vm::{CapturedEnv, Env, VM};
use crate::ty::internal::{Thunk, Value};
use crate::vm::{Env, VM};
#[derive(Debug, Clone)]
pub enum Param {
@@ -40,24 +41,23 @@ impl From<ir::Param> for Param {
}
}
pub type JITFunc<'vm> = unsafe extern "C" fn(vm: *mut VM<'vm, '_>, *mut Env<'vm>, *mut Value<'vm>) -> Value<'vm>;
pub type JITFunc<'vm> = unsafe extern "C" fn(vm: *mut VM<'_>, *mut Env<'vm>, *mut Value<'vm>) -> Value<'vm>;
#[derive(Debug, Clone)]
#[derive(Debug, Clone, Constructor)]
pub struct Func<'vm> {
pub env: OnceCell<CapturedEnv<'vm>>,
pub param: Param,
pub opcodes: OpCodes,
pub func: &'vm BFunc,
pub env: Rc<Env<'vm>>,
pub compiled: Option<JITFunc<'vm>>
}
impl<'vm> Func<'vm> {
pub fn call(&'vm self, vm: &VM<'vm, '_>, arg: Value<'vm>) -> Result<Value<'vm>> {
pub fn call(self, vm: &'vm VM<'_>, arg: Value<'vm>) -> Result<Value<'vm>> {
use Param::*;
let env = self.env.get().unwrap().clone().released();
let env = Rc::new(self.env.as_ref().clone());
match &self.param {
Ident(ident) => env.enter(HashTrieMap::new().insert(ident.clone().into(), arg)),
match self.func.param.clone() {
Ident(ident) => env.enter(HashTrieMap::new().insert(ident.into(), arg)),
Formals {
formals,
ellipsis,
@@ -79,7 +79,7 @@ impl<'vm> Func<'vm> {
let formal = formal.clone().into();
let arg = arg
.select(&formal)
.or_else(|| default.map(|idx| Value::ThunkRef(vm.get_thunk(idx))))
.or_else(|| default.map(|idx| Value::Thunk(Thunk::new(vm.get_thunk(idx)))))
.unwrap();
new.insert_mut(formal, arg);
}
@@ -90,7 +90,7 @@ impl<'vm> Func<'vm> {
}
}
vm.eval(self.opcodes.clone(), env)
vm.eval(self.func.opcodes.clone(), env)
}
}

2
src/ty/internal/list.rs
View File

@@ -30,7 +30,7 @@ impl<'vm> List<'vm> {
self
}
pub fn force_deep(&mut self, vm: &VM<'vm, '_>) -> Result<()> {
pub fn force_deep(&mut self, vm: &'vm VM<'_>) -> Result<()> {
let mut vec: Vec<_> = self.data.iter().cloned().collect();
vec.iter_mut()
.map(|v| v.force_deep(vm).map(|_| ()))

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

@@ -1,3 +1,4 @@
use std::cell::OnceCell;
use std::cell::RefCell;
use std::rc::Rc;
@@ -36,7 +37,7 @@ pub enum Value<'vm> {
Catchable(c::Catchable),
PrimOp(PrimOp<'vm>),
PartialPrimOp(PartialPrimOp<'vm>),
Func(&'vm Func<'vm>),
Func(Func<'vm>),
}
#[derive(Debug, IsVariant, Unwrap, Clone, PartialEq)]
@@ -49,7 +50,7 @@ pub enum ValueAsRef<'v, 'vm: 'v> {
Catchable(&'v c::Catchable),
PrimOp(&'v PrimOp<'vm>),
PartialPrimOp(&'v PartialPrimOp<'vm>),
Func(&'vm Func<'vm>),
Func(&'v Func<'vm>),
}
#[derive(Debug, IsVariant, Unwrap, PartialEq)]
@@ -62,7 +63,7 @@ pub enum ValueAsMut<'v, 'vm: 'v> {
Catchable(&'v mut c::Catchable),
PrimOp(&'v mut PrimOp<'vm>),
PartialPrimOp(&'v mut PartialPrimOp<'vm>),
Func(&'vm Func<'vm>),
Func(&'v Func<'vm>),
}
impl<'v, 'vm: 'v> Value<'vm> {
@@ -127,7 +128,7 @@ impl<'vm> Value<'vm> {
}
}
pub fn call(self, vm: &VM<'vm, '_>, args: Vec<Value<'vm>>) -> Result<Value<'vm>> {
pub fn call(self, vm: &'vm VM<'_>, args: Vec<Value<'vm>>) -> Result<Value<'vm>> {
use Value::*;
Ok(match self {
PrimOp(func) => func.call(vm, args),
@@ -365,7 +366,7 @@ impl<'vm> Value<'vm> {
self
}
pub fn force(&mut self, vm: &VM<'vm, '_>) -> Result<&mut Self> {
pub fn force(&mut self, vm: &'vm VM<'_>) -> Result<&mut Self> {
if let Value::Thunk(thunk) = self {
let value = thunk.force(vm)?;
*self = value
@@ -376,7 +377,7 @@ impl<'vm> Value<'vm> {
Ok(self)
}
pub fn force_deep(&mut self, vm: &VM<'vm, '_>) -> Result<&mut Self> {
pub fn force_deep(&mut self, vm: &'vm VM<'_>) -> Result<&mut Self> {
match self {
Value::Thunk(thunk) => {
let mut value = thunk.force(vm)?;
@@ -420,34 +421,30 @@ pub trait ToPublic {
#[derive(Debug, Clone)]
pub struct Thunk<'vm> {
pub thunk: RefCell<_Thunk<'vm>>,
pub env: RefCell<Option<Rc<Env<'vm>>>>,
pub thunk: Rc<RefCell<_Thunk<'vm>>>,
}
#[derive(Debug, IsVariant, Unwrap, Clone)]
pub enum _Thunk<'vm> {
Code(OpCodes),
Code(&'vm OpCodes, OnceCell<Rc<Env<'vm>>>),
SuspendedFrom(*const Thunk<'vm>),
Value(Box<Value<'vm>>),
}
impl<'vm> Thunk<'vm> {
pub fn new(opcodes: OpCodes) -> Self {
pub fn new(opcodes: &'vm OpCodes) -> Self {
Thunk {
thunk: RefCell::new(_Thunk::Code(opcodes)),
env: RefCell::new(None),
thunk: Rc::new(RefCell::new(_Thunk::Code(opcodes, OnceCell::new()))),
}
}
pub fn unwrap_code(&self) -> OpCodes {
self.thunk.borrow().clone().unwrap_code()
}
pub fn capture(&self, env: Rc<Env<'vm>>) {
*self.env.borrow_mut() = Some(env);
if let _Thunk::Code(_, envcell) = &*self.thunk.borrow() {
envcell.get_or_init(|| env);
}
}
pub fn force(&self, vm: &VM<'vm, '_>) -> Result<Value<'vm>> {
pub fn force(&self, vm: &'vm VM<'_>) -> Result<Value<'vm>> {
match &*self.thunk.borrow() {
_Thunk::Value(value) => return Ok(value.as_ref().clone()),
_Thunk::SuspendedFrom(from) => {
@@ -456,14 +453,14 @@ impl<'vm> Thunk<'vm> {
self as *const Thunk
)));
}
_Thunk::Code(_) => (),
_Thunk::Code(..) => (),
}
let opcodes = std::mem::replace(
let (opcodes, env) = std::mem::replace(
&mut *self.thunk.borrow_mut(),
_Thunk::SuspendedFrom(self as *const Thunk),
)
.unwrap_code();
let value = vm.eval(opcodes, self.env.borrow().clone().unwrap())?;
let value = vm.eval(opcodes.clone(), env.get().unwrap().clone())?;
let _ = std::mem::replace(
&mut *self.thunk.borrow_mut(),
_Thunk::Value(value.clone().into()),

8
src/ty/internal/primop.rs
View File

@@ -8,7 +8,7 @@ use super::Value;
pub struct PrimOp<'vm> {
pub name: &'static str,
arity: u8,
func: fn(&VM<'vm, '_>, Vec<Value<'vm>>) -> Value<'vm>,
func: fn(&'vm VM<'_>, Vec<Value<'vm>>) -> Value<'vm>,
}
impl PartialEq for PrimOp<'_> {
@@ -18,7 +18,7 @@ impl PartialEq for PrimOp<'_> {
}
impl<'vm> PrimOp<'vm> {
pub fn call(self, vm: &VM<'vm, '_>, args: Vec<Value<'vm>>) -> Value<'vm> {
pub fn call(self, vm: &'vm VM<'_>, args: Vec<Value<'vm>>) -> Value<'vm> {
if (args.len() as u8) < self.arity {
Value::PartialPrimOp(PartialPrimOp {
name: self.name,
@@ -39,7 +39,7 @@ pub struct PartialPrimOp<'vm> {
pub name: &'static str,
arity: u8,
args: Vec<Value<'vm>>,
func: fn(&VM<'vm, '_>, Vec<Value<'vm>>) -> Value<'vm>,
func: fn(&'vm VM<'_>, Vec<Value<'vm>>) -> Value<'vm>,
}
impl PartialEq for PartialPrimOp<'_> {
@@ -49,7 +49,7 @@ impl PartialEq for PartialPrimOp<'_> {
}
impl<'vm> PartialPrimOp<'vm> {
pub fn call(mut self, vm: &VM<'vm, '_>, args: Vec<Value<'vm>>) -> Value<'vm> {
pub fn call(mut self, vm: &'vm VM<'_>, args: Vec<Value<'vm>>) -> Value<'vm> {
let len = args.len() as u8;
self.args.extend(args);
if len < self.arity {