feat: deliver owner-scoped text file tasks through a bounded provider pool

This commit is contained in:
2026-10-23 11:59:40 +08:00
parent 05403e6996
commit 047e008729
3 changed files with 363 additions and 68 deletions
+154
View File
@@ -0,0 +1,154 @@
//! Background providers carry plain data and weak task identities, never a VM.
use endor_core::{VmError, WeakObjectRef};
use std::{
collections::HashMap,
fs::File,
io::Read,
sync::{
Arc, Mutex, OnceLock,
atomic::{AtomicBool, AtomicUsize, Ordering},
mpsc::{SyncSender, sync_channel},
},
thread,
};
const MAX_TEXT: usize = 1024 * 1024;
const MAX_ACTIVE: usize = 16;
const WORKERS: usize = 4;
const QUEUE: usize = 64;
type Completion = Result<String, String>;
#[derive(Debug, Default)]
struct Shared {
ready: Mutex<HashMap<WeakObjectRef, Completion>>,
active: AtomicUsize,
}
#[derive(Clone, Debug, Default)]
pub struct Provider {
shared: Arc<Shared>,
}
/// Only Task payloads own this lease. Provider threads hold just its flag.
#[derive(Debug)]
pub struct Lease {
shared: Arc<Shared>,
task: WeakObjectRef,
cancelled: Arc<AtomicBool>,
}
impl Drop for Lease {
fn drop(&mut self) {
self.cancelled.store(true, Ordering::Release);
if let Ok(mut ready) = self.shared.ready.lock() {
ready.remove(&self.task);
}
self.shared.active.fetch_sub(1, Ordering::AcqRel);
}
}
struct Job {
path: String,
task: WeakObjectRef,
cancelled: Arc<AtomicBool>,
shared: Arc<Shared>,
}
impl Provider {
pub fn submit(
&self,
task: WeakObjectRef,
path: String,
replacing: bool,
) -> Result<Arc<Lease>, VmError> {
self.shared
.active
.fetch_update(Ordering::AcqRel, Ordering::Acquire, |active| {
(active < MAX_ACTIVE + usize::from(replacing)).then_some(active + 1)
})
.map_err(|_| VmError::ExecutionLimit("16 file tasks per runtime"))?;
let lease = Arc::new(Lease {
shared: self.shared.clone(),
task,
cancelled: Arc::new(AtomicBool::new(false)),
});
let sender = pool().map_err(|_| VmError::InvalidArgument("file provider unavailable"))?;
sender
.try_send(Job {
path,
task,
cancelled: lease.cancelled.clone(),
shared: self.shared.clone(),
})
.map_err(|_| VmError::ExecutionLimit("file provider queue full or unavailable"))?;
Ok(lease)
}
pub fn take_ready(&self) -> Result<Vec<(WeakObjectRef, Completion)>, VmError> {
Ok(self
.shared
.ready
.lock()
.map_err(|_| VmError::InvalidArgument("file mailbox poisoned"))?
.drain()
.collect())
}
}
fn pool() -> Result<&'static SyncSender<Job>, &'static str> {
static POOL: OnceLock<Result<SyncSender<Job>, String>> = OnceLock::new();
POOL.get_or_init(|| {
let (sender, receiver) = sync_channel::<Job>(QUEUE);
let receiver = Arc::new(Mutex::new(receiver));
for index in 0..WORKERS {
let receiver = receiver.clone();
thread::Builder::new()
.name(format!("tessera-file-{index}"))
.spawn(move || {
loop {
let job = match receiver.lock() {
Ok(receiver) => receiver.recv(),
Err(_) => break,
};
let Ok(job) = job else {
break;
};
if job.cancelled.load(Ordering::Acquire) {
continue;
}
let result = read_text(&job.path);
if let Ok(mut ready) = job.shared.ready.lock()
&& !job.cancelled.load(Ordering::Acquire)
{
ready.insert(job.task, result);
}
}
})
.map_err(|error| error.to_string())?;
}
Ok(sender)
})
.as_ref()
.map_err(|_| "file provider unavailable")
}
fn read_text(path: &str) -> Completion {
let read = || -> Result<String, String> {
let metadata = std::fs::metadata(path).map_err(|error| error.to_string())?;
if !metadata.is_file() {
return Err("text source must be a regular file".into());
}
if metadata.len() > MAX_TEXT as u64 {
return Err("text source exceeds 1 MiB".into());
}
let file = File::open(path).map_err(|error| error.to_string())?;
if !file
.metadata()
.map_err(|error| error.to_string())?
.is_file()
{
return Err("text source must be a regular file".into());
}
let mut bytes = Vec::new();
file.take(MAX_TEXT as u64 + 1)
.read_to_end(&mut bytes)
.map_err(|error| error.to_string())?;
if bytes.len() > MAX_TEXT {
return Err("text source exceeds 1 MiB".into());
}
String::from_utf8(bytes).map_err(|_| "text source must be UTF-8".into())
};
read()
}
+1
View File
@@ -12,6 +12,7 @@ mod endor_script;
mod event_dispatch;
mod events;
mod geometry;
mod io_tasks;
mod layout;
mod mount;
mod native_visual;
+208 -68
View File
@@ -47,6 +47,10 @@ struct Task {
due: Instant,
callback: Option<ObjectRef>,
state: State,
ready: bool,
text: Option<Arc<str>>,
error: Option<Arc<str>>,
lease: Option<Arc<crate::io_tasks::Lease>>,
}
impl ObjectPayload for Task {
fn as_any(&self) -> &dyn std::any::Any {
@@ -183,6 +187,8 @@ pub fn cancel_owner(cx: &mut NativeContext<'_>, owner: ObjectRef) -> Result<(),
if task.state == State::Pending {
task.state = State::Cancelled;
task.callback = None;
task.lease = None;
task.text = None;
cx.replace_payload(reference, task)?;
}
cx.dict_delete(scope, &key)?;
@@ -192,6 +198,8 @@ pub fn cancel_owner(cx: &mut NativeContext<'_>, owner: ObjectRef) -> Result<(),
#[derive(Debug)]
struct After {
file: bool,
provider: crate::io_tasks::Provider,
signature: endor_core::CallSignature,
index: Index,
desktop: ObjectRef,
@@ -201,7 +209,7 @@ impl NativeCallable for After {
Some(self.signature.clone())
}
fn arity(&self) -> Option<endor_core::CallArity> {
Some(endor_core::CallArity::exact(4))
Some(self.signature.arity)
}
fn invoke(&self, cx: &mut NativeContext<'_>, args: &[Value]) -> Result<NativeResult, VmError> {
@@ -210,23 +218,29 @@ impl NativeCallable for After {
"asynchronous work is forbidden during read-only rendering",
));
}
let [owner, key, delay, callback] = args else {
return Err(invalid(
"ui.after requires owner, key, milliseconds and callback",
));
let (owner, key, delay, callback) = match args {
[owner, key, delay, callback] => (owner, key, delay, Some(callback)),
[owner, key, path] if self.file => (owner, key, path, None),
_ => {
return Err(invalid(
"asynchronous request requires owner, key, delay/path and optional file callback",
));
}
};
let owner = object(owner)?;
let callback = object(callback)?;
if !cx.store().object(callback)?.payload().is_function() {
return Err(invalid("task callback must be a Function"));
}
if !cx
.store()
.call_arity(callback)?
.ok_or(invalid("task callback requires positional metadata"))?
.accepts(0)
{
return Err(invalid("task callback requires zero unbound parameters"));
let callback = callback.map(object).transpose()?;
if let Some(callback) = callback {
if !cx.store().object(callback)?.payload().is_function() {
return Err(invalid("task callback must be a Function"));
}
if !cx
.store()
.call_arity(callback)?
.ok_or(invalid("task callback requires positional metadata"))?
.accepts(0)
{
return Err(invalid("task callback requires zero unbound parameters"));
}
}
let Value::Text(key) = key else {
return Err(invalid("task key must be text"));
@@ -234,17 +248,28 @@ impl NativeCallable for After {
if key.is_empty() || key.len() > 128 || key.chars().any(char::is_control) {
return Err(invalid("invalid task key"));
}
let Value::Number(delay) = delay else {
return Err(invalid(
"task delay must be an integer number of milliseconds",
));
let (milliseconds, path) = if self.file {
let Value::Text(path) = delay else {
return Err(invalid("text path must be a String"));
};
if path.is_empty() || path.len() > 4096 || path.contains('\0') {
return Err(invalid("invalid text path"));
}
(0, Some(path.clone()))
} else {
let Value::Number(delay) = delay else {
return Err(invalid(
"task delay must be an integer number of milliseconds",
));
};
let milliseconds = delay
.as_i64()
.filter(|delay| (0..=86_400_000).contains(delay))
.ok_or(invalid(
"task delay must be 0..86400000 integer milliseconds",
))?;
(milliseconds, None)
};
let milliseconds = delay
.as_i64()
.filter(|delay| (0..=86_400_000).contains(delay))
.ok_or(invalid(
"task delay must be 0..86400000 integer milliseconds",
))?;
if !eligible(cx.store(), owner, self.desktop)? {
return Err(invalid("task owner is closed or detached"));
}
@@ -282,10 +307,31 @@ impl NativeCallable for After {
due: Instant::now()
.checked_add(Duration::from_millis(milliseconds as u64))
.ok_or(invalid("task deadline overflow"))?,
callback: Some(callback),
callback,
state: State::Pending,
ready: !self.file,
text: None,
error: None,
lease: None,
})?;
cx.attach_type(task, desktop_type(cx.store(), "Task", self.desktop)?)?;
if let Some(path) = path {
let replacing = previous
.map(|previous| {
cx.store()
.payload::<Task>(previous, "Task")
.map(|task| task.state == State::Pending && task.lease.is_some())
})
.transpose()?
.unwrap_or(false);
let lease = self
.provider
.submit(cx.store().downgrade(task)?, path, replacing)?;
let mut value = cx.store().payload::<Task>(task, "Task")?.clone();
value.lease = Some(lease);
cx.replace_payload(task, value)?;
}
let task_scope = if let Some(scope) = existing_scope {
scope
} else {
@@ -308,6 +354,8 @@ impl NativeCallable for After {
if old.state == State::Pending {
old.state = State::Cancelled;
old.callback = None;
old.lease = None;
old.text = None;
cx.replace_payload(previous, old)?;
}
}
@@ -325,6 +373,8 @@ enum Query {
Cancel,
Status,
Active,
Result,
Error,
}
#[derive(Debug)]
struct Method {
@@ -368,6 +418,19 @@ impl NativeCallable for Method {
.into(),
),
Query::Active => Value::Bool(active),
Query::Result => {
if !matches!(task.state, State::Running | State::Completed) || task.error.is_some()
{
return Err(invalid(
"task result is not available; inspect status and error",
));
}
task.text
.as_ref()
.map(|text| Value::Text(text.to_string()))
.unwrap_or(Value::Nil)
}
Query::Error => Value::Text(task.error.as_deref().unwrap_or_default().into()),
Query::Cancel => {
if cx.store().is_read_only() {
return Err(invalid(
@@ -377,6 +440,8 @@ impl NativeCallable for Method {
if pending {
task.state = State::Cancelled;
task.callback = None;
task.lease = None;
task.text = None;
cx.replace_payload(reference, task.clone())?;
if let Some(owner) = owner
&& current(cx.store(), owner, reference, &task)?
@@ -395,12 +460,49 @@ impl NativeCallable for Method {
pub struct Scheduler {
index: Index,
desktop: ObjectRef,
provider: crate::io_tasks::Provider,
}
impl Scheduler {
/// Mutation boundaries collect unreachable owner/callback cycles before
/// this weak lookup. Idle timer polling does not rescan the entire heap.
pub fn poll(&self, vm: &mut Vm, limit: usize) -> Result<usize> {
anyhow::ensure!((1..=MAX_READY).contains(&limit), "invalid task poll limit");
// Provider threads only fill the mailbox. Only this VM worker updates
// managed payloads, and delivery below rechecks owner/key generation.
for (weak, completion) in self.provider.take_ready()? {
if let Some(reference) = vm.upgrade(weak)? {
let result = (|| -> Result<()> {
let mut task = vm.payload::<Task>(reference, "Task")?.clone();
if task.state != State::Pending || task.lease.is_none() {
return Ok(());
}
let owner = vm.upgrade(task.owner)?;
let active = (|| -> Result<bool> {
Ok(if let Some(owner) = owner {
eligible(vm.object_store(), owner, self.desktop)?
&& current(vm.object_store(), owner, reference, &task)?
} else {
false
})
})();
if let Some(owner) = owner {
vm.release(owner)?;
}
if !active? {
return Ok(());
}
task.ready = true;
match completion {
Ok(text) => task.text = Some(text.into()),
Err(error) => task.error = Some(error.into()),
}
vm.replace_payload(reference, task)?;
Ok(())
})();
vm.release(reference)?;
result?;
}
}
let snapshot = self
.index
.lock()
@@ -416,7 +518,7 @@ impl Scheduler {
continue;
};
let result = (|| -> Result<()> {
let task = vm.payload::<Task>(reference, "Task")?.clone();
let mut task = vm.payload::<Task>(reference, "Task")?.clone();
if task.state != State::Pending {
return Ok(());
}
@@ -432,13 +534,19 @@ impl Scheduler {
work += 1;
return finish(vm, reference, State::Cancelled);
}
if task.due > now {
if task.due > now || !task.ready {
return Ok(());
}
work += 1;
let callback = task
.callback
.ok_or_else(|| anyhow::anyhow!("pending task has no callback"))?;
if task.error.is_some() {
return finish(vm, reference, State::Failed);
}
let Some(callback) = task.callback else {
return finish(vm, reference, State::Completed);
};
// The provider is finished. Keep the result in the Task,
// but release its I/O slot before running source callbacks.
task.lease = None;
let mut running = task.clone();
running.state = State::Running;
vm.replace_payload(reference, running)?;
@@ -456,22 +564,18 @@ impl Scheduler {
Ok(value) => {
let unit = matches!(value, Value::Nil);
vm.release_value(value)?;
finish(
vm,
reference,
if unit {
State::Completed
} else {
State::Failed
},
)?;
if !unit {
fail_callback(
vm,
reference,
"asynchronous callback must return Unit",
)?;
bail!("asynchronous callback must return Unit");
}
Ok(())
finish(vm, reference, State::Completed)
}
Err(error) => {
finish(vm, reference, State::Failed)?;
fail_callback(vm, reference, &format!("{error:#}"))?;
Err(error)
}
}
@@ -529,6 +633,13 @@ impl Scheduler {
Ok(())
}
}
fn fail_callback(vm: &mut Vm, reference: ObjectRef, message: &str) -> Result<()> {
let mut task = vm.payload::<Task>(reference, "Task")?.clone();
task.error = Some(message.chars().take(1024).collect::<String>().into());
vm.replace_payload(reference, task)?;
finish(vm, reference, State::Failed)
}
fn finish(vm: &mut Vm, reference: ObjectRef, state: State) -> Result<()> {
let mut task = vm.payload::<Task>(reference, "Task")?.clone();
if !matches!(task.state, State::Pending | State::Running) {
@@ -536,6 +647,10 @@ fn finish(vm: &mut Vm, reference: ObjectRef, state: State) -> Result<()> {
}
task.state = state;
task.callback = None;
task.lease = None;
if state == State::Cancelled {
task.text = None;
}
vm.replace_payload(reference, task.clone())?;
if let Some(owner) = vm.upgrade(task.owner)? {
let result = (|| -> Result<()> {
@@ -560,30 +675,51 @@ pub fn install(
) -> Result<Scheduler> {
let index = Arc::new(Mutex::new(Vec::new()));
let definition = desktop_type(vm.object_store(), "Task", desktop)?;
let after = vm.allocate(ContextNativeFunction::new(
"after",
After {
signature: endor_core::CallSignature::exact(
vec![
endor_core::AnnotationType::Any,
endor_core::AnnotationType::String,
endor_core::AnnotationType::Number,
endor_core::AnnotationType::Function,
],
endor_core::AnnotationType::Nominal(definition),
endor_core::CallEffect::Mutating,
),
index: index.clone(),
desktop,
},
vec![desktop],
))?;
roots.push(after);
vm.set_attr(ui, "after", Value::Object(after))?;
let provider = crate::io_tasks::Provider::default();
for (name, file) in [("after", false), ("readText", true)] {
let function = vm.allocate(ContextNativeFunction::new(
name,
After {
file,
provider: provider.clone(),
signature: {
let mut signature = endor_core::CallSignature::exact(
vec![
endor_core::AnnotationType::Any,
endor_core::AnnotationType::String,
if file {
endor_core::AnnotationType::String
} else {
endor_core::AnnotationType::Number
},
endor_core::AnnotationType::Function,
],
endor_core::AnnotationType::Nominal(definition),
if file {
endor_core::CallEffect::External
} else {
endor_core::CallEffect::Mutating
},
);
if file {
signature.arity = endor_core::CallArity::range(3, 4);
}
signature
},
index: index.clone(),
desktop,
},
vec![desktop],
))?;
roots.push(function);
vm.set_attr(ui, name, Value::Object(function))?;
}
for (name, query) in [
("cancel", Query::Cancel),
("status", Query::Status),
("active", Query::Active),
("result", Query::Result),
("error", Query::Error),
] {
let method = vm.allocate(ContextNativeFunction::new(
name,
@@ -592,10 +728,10 @@ pub fn install(
desktop,
signature: endor_core::CallSignature::exact(
vec![endor_core::AnnotationType::Nominal(definition)],
if matches!(query, Query::Status) {
endor_core::AnnotationType::String
} else {
endor_core::AnnotationType::Bool
match query {
Query::Status | Query::Error => endor_core::AnnotationType::String,
Query::Result => endor_core::AnnotationType::Any,
_ => endor_core::AnnotationType::Bool,
},
if matches!(query, Query::Cancel) {
endor_core::CallEffect::Mutating
@@ -609,5 +745,9 @@ pub fn install(
roots.push(method);
vm.define_method(definition, name, method)?;
}
Ok(Scheduler { index, desktop })
Ok(Scheduler {
index,
desktop,
provider,
})
}