ITStudio_OUC/OxideJS
Archived
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: 将基础类型定义放在单独 crate 以解决循环依赖

Browse Source
This commit is contained in:
爱特每羊队
2026-06-05 22:50:06 +08:00
parent 2d3ced1a7b
commit 91d4d135fa
20 changed files with 64 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/oxide_kernel/src/builtin.rs
+3 -3
View File
@@ -1,6 +1,6 @@
use oxide_vm::mem::P;
use oxide_vm::object::JsObject;
use oxide_vm::value::JsValue;
use oxide_types::mem::P;
use oxide_types::object::JsObject;
use oxide_types::value::JsValue;
use crate::shape_forge::{ShapeForge, EMPTY_SHAPE_ID};
use crate::string_forge::Interner;
crates/oxide_kernel/src/kernel.rs
+1 -33
View File
@@ -1,13 +1,12 @@
#![allow(clippy::arc_with_non_send_sync)]
use std::sync::{Arc, Mutex};
use std::sync::Arc;
use crate::builtin::BuiltinWorld;
use crate::code_forge::CodeForge;
use crate::prop_forge::PropForge;
use crate::shape_forge::ShapeForge;
use crate::string_forge::Interner;
use crate::vm_pool::{VmGuard, VmPool};
pub struct KernelConfig {
pub min_pool_size: usize,
@@ -66,8 +65,6 @@ pub struct OxideKernel {
pub code_forge: Arc<CodeForge>,
pub prop_forge: Arc<PropForge>,
pub builtin_world: Arc<BuiltinWorld>,
#[allow(dead_code)]
vm_pool: Mutex<Option<Arc<VmPool>>>,
}
impl OxideKernel {
@@ -85,28 +82,9 @@ impl OxideKernel {
code_forge,
prop_forge,
builtin_world,
vm_pool: Mutex::new(None),
}
}
pub fn init_vm_pool(self: &Arc<Self>) {
let pool = VmPool::new(
Arc::clone(self),
self.config.min_pool_size,
self.config.max_pool_size,
);
*self.vm_pool.lock().unwrap() = Some(pool);
}
pub fn spawn(&self) -> VmGuard {
self.vm_pool
.lock()
.unwrap()
.as_ref()
.expect("vm_pool not initialized — call init_vm_pool() first")
.spawn()
}
pub fn string_forge(&self) -> &Arc<Interner> {
&self.string_forge
}
@@ -173,14 +151,4 @@ mod tests {
assert!(KernelConfig::full().warmup_builtin_ic);
assert_eq!(KernelConfig::full().max_pool_size, None);
}
#[test]
fn test_kernel_spawn() {
let kernel = Arc::new(OxideKernel::new(KernelConfig::minimal()));
kernel.init_vm_pool();
let guard = kernel.spawn();
drop(guard);
let guard2 = kernel.spawn();
drop(guard2);
}
}
crates/oxide_kernel/src/lib.rs
-1
View File
@@ -6,4 +6,3 @@ pub mod kernel;
pub mod prop_forge;
pub mod shape_forge;
pub mod string_forge;
pub mod vm_pool;
crates/oxide_kernel/src/vm_pool.rs
-176
View File
@@ -1,176 +0,0 @@
#![allow(clippy::arc_with_non_send_sync)]
use std::sync::{Arc, Condvar, Mutex};
use oxide_vm::mem::P;
use oxide_vm::vm::Vm;
use crate::kernel::OxideKernel;
struct VmPoolInner {
available: Vec<Vm>,
total_count: usize,
}
pub struct VmPool {
kernel: Arc<OxideKernel>,
inner: Mutex<VmPoolInner>,
condvar: Condvar,
#[allow(dead_code)]
min_size: usize,
max_size: Option<usize>,
}
pub struct VmGuard {
vm: Option<Vm>,
pool: Arc<VmPool>,
dirty: bool,
interned_strings: Vec<u32>,
}
impl VmPool {
pub fn new(kernel: Arc<OxideKernel>, min_size: usize, max_size: Option<usize>) -> Arc<Self> {
let pool = Arc::new(Self {
kernel,
inner: Mutex::new(VmPoolInner {
available: Vec::with_capacity(min_size),
total_count: 0,
}),
condvar: Condvar::new(),
min_size,
max_size,
});
{
let mut inner = pool.inner.lock().unwrap();
for _ in 0..min_size {
let vm = Self::new_vm(&pool.kernel);
inner.available.push(vm);
inner.total_count += 1;
}
}
pool
}
fn new_vm(kernel: &Arc<OxideKernel>) -> Vm {
let mut vm = Vm::new();
vm.object_prototype = P::clone(&kernel.builtin_world().object_proto);
vm
}
fn replace_vm(&self) -> Vm {
Self::new_vm(&self.kernel)
}
pub fn spawn(self: &Arc<Self>) -> VmGuard {
loop {
let mut inner = self.inner.lock().unwrap();
if let Some(vm) = inner.available.pop() {
return VmGuard {
vm: Some(vm),
pool: Arc::clone(self),
dirty: false,
interned_strings: Vec::new(),
};
}
let can_grow = match self.max_size {
Some(max) => inner.total_count < max,
None => true,
};
if can_grow {
inner.total_count += 1;
drop(inner);
let vm = Self::new_vm(&self.kernel);
return VmGuard {
vm: Some(vm),
pool: Arc::clone(self),
dirty: false,
interned_strings: Vec::new(),
};
}
inner = self.condvar.wait(inner).unwrap();
}
}
}
impl VmGuard {
pub fn vm(&self) -> &Vm {
self.vm.as_ref().expect("VmGuard has no VM")
}
pub fn vm_mut(&mut self) -> &mut Vm {
self.vm.as_mut().expect("VmGuard has no VM")
}
pub fn mark_dirty(&mut self) {
self.dirty = true;
}
}
impl Drop for VmGuard {
fn drop(&mut self) {
let Some(vm) = self.vm.take() else {
return;
};
let mut inner = self.pool.inner.lock().unwrap();
if self.dirty {
let new_vm = self.pool.replace_vm();
inner.available.push(new_vm);
} else {
for &idx in &self.interned_strings {
self.pool.kernel.string_forge().decref(idx);
}
let mut returned_vm = vm;
returned_vm.reset();
inner.available.push(returned_vm);
}
self.pool.condvar.notify_one();
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::kernel::KernelConfig;
fn test_kernel() -> Arc<OxideKernel> {
Arc::new(OxideKernel::new(KernelConfig::minimal()))
}
#[test]
fn test_pool_spawn_returns_guard() {
let kernel = test_kernel();
let pool = VmPool::new(kernel, 1, None);
let guard = pool.spawn();
drop(guard);
}
#[test]
fn test_pool_recycle_on_drop() {
let kernel = test_kernel();
let pool = VmPool::new(kernel, 1, None);
let guard = pool.spawn();
drop(guard);
let guard2 = pool.spawn();
drop(guard2);
}
#[test]
fn test_pool_grows_if_empty() {
let kernel = test_kernel();
let pool = VmPool::new(Arc::clone(&kernel), 1, Some(3));
let g1 = pool.spawn();
let g2 = pool.spawn();
drop(g1);
drop(g2);
}
}