From 51e5d208e48dfba31fe712ee8764d71d284db22d Mon Sep 17 00:00:00 2001 From: ldm0 Date: Tue, 18 Aug 2026 01:44:50 +0800 Subject: [PATCH] refactor(renderer): remove unused worker task generations --- .../context_bootstrap/crypto/subtle/tasks.rs | 16 +---- .../src/context_bootstrap/opfs.rs | 36 +++------- .../src/worker/global_scope/mod.rs | 67 ++++++------------- moli-renderer-v8/src/worker/thread/mod.rs | 2 - 4 files changed, 34 insertions(+), 87 deletions(-) diff --git a/moli-renderer-v8/src/context_bootstrap/crypto/subtle/tasks.rs b/moli-renderer-v8/src/context_bootstrap/crypto/subtle/tasks.rs index 7e0ecaf326..1ddcefa612 100644 --- a/moli-renderer-v8/src/context_bootstrap/crypto/subtle/tasks.rs +++ b/moli-renderer-v8/src/context_bootstrap/crypto/subtle/tasks.rs @@ -11,7 +11,6 @@ pub(crate) enum WebCryptoCompletionSink { Page(crate::page_task_queue::RendererPageWebCryptoTaskProducer), Worker { task_id: u64, - generation: u64, tx: tokio::sync::mpsc::UnboundedSender, }, } @@ -23,16 +22,8 @@ impl WebCryptoCompletionSink { WebCryptoCompletionSink::Page(producer) => { let _ = producer.send(result); } - WebCryptoCompletionSink::Worker { - task_id, - generation, - tx, - } => { - let _ = tx.send(crate::worker::WorkerWebCryptoCompletion { - task_id, - generation, - result, - }); + WebCryptoCompletionSink::Worker { task_id, tx } => { + let _ = tx.send(crate::worker::WorkerWebCryptoCompletion { task_id, result }); } } } @@ -57,13 +48,12 @@ pub(crate) fn register_webcrypto_task<'s>( unsafe { &mut *host_ptr }.register_pending_webcrypto_task(scope, promise.resolver())?; return Some((handle, WebCryptoCompletionSink::Page(producer))); } - let (task_id, generation, completion_tx) = + let (task_id, completion_tx) = crate::worker::register_worker_webcrypto_task(scope, promise.resolver())?; Some(( handle, WebCryptoCompletionSink::Worker { task_id, - generation, tx: completion_tx, }, )) diff --git a/moli-renderer-v8/src/context_bootstrap/opfs.rs b/moli-renderer-v8/src/context_bootstrap/opfs.rs index a032b52b3b..dbae5c5f29 100644 --- a/moli-renderer-v8/src/context_bootstrap/opfs.rs +++ b/moli-renderer-v8/src/context_bootstrap/opfs.rs @@ -350,7 +350,6 @@ enum OpfsCompletionSink { Page(crate::page_task_queue::RendererPageOpfsTaskProducer), Worker { task_id: u64, - generation: u64, sender: tokio::sync::mpsc::UnboundedSender, }, } @@ -359,23 +358,15 @@ impl OpfsCompletionSink { /// Consume the exact terminal capability. /// /// A Page capability already contains its task identity. Worker identity - /// stays local to the Worker transport because that queue still performs - /// its own generation authorization. + /// stays local to the Worker transport and is valid for that worker state's + /// lifetime. fn send(self, result: OpfsTaskResult) { match self { Self::Page(sender) => { let _ = sender.send(result); } - Self::Worker { - task_id, - generation, - sender, - } => { - let _ = sender.send(crate::worker::WorkerOpfsCompletion { - task_id, - generation, - result, - }); + Self::Worker { task_id, sender } => { + let _ = sender.send(crate::worker::WorkerOpfsCompletion { task_id, result }); } } } @@ -407,16 +398,11 @@ impl RegisteredOpfsTask { fn worker( task_id: u64, - generation: u64, sender: tokio::sync::mpsc::UnboundedSender, ) -> Self { Self { cancellation: RegisteredOpfsTaskCancellation::Worker { task_id }, - completion: OpfsCompletionSink::Worker { - task_id, - generation, - sender, - }, + completion: OpfsCompletionSink::Worker { task_id, sender }, } } @@ -443,9 +429,9 @@ fn register_opfs_task<'s>( )?; return Some(RegisteredOpfsTask::page(task_id, sender)); } - let (task_id, generation, sender) = + let (task_id, sender) = crate::worker::register_worker_opfs_task(scope, resolver, locator, handle_access)?; - Some(RegisteredOpfsTask::worker(task_id, generation, sender)) + Some(RegisteredOpfsTask::worker(task_id, sender)) } fn register_opfs_iterator_task<'s>( @@ -470,7 +456,7 @@ fn register_opfs_iterator_task<'s>( )?; return Some(RegisteredOpfsTask::page(task_id, sender)); } - let (task_id, generation, sender) = crate::worker::register_worker_opfs_iterator_task( + let (task_id, sender) = crate::worker::register_worker_opfs_iterator_task( scope, locator, registry, @@ -478,7 +464,7 @@ fn register_opfs_iterator_task<'s>( v8::Global::new(scope, iterator), handle_access, )?; - Some(RegisteredOpfsTask::worker(task_id, generation, sender)) + Some(RegisteredOpfsTask::worker(task_id, sender)) } fn register_opfs_move_task<'s>( @@ -504,7 +490,7 @@ fn register_opfs_move_task<'s>( )?; return Some(RegisteredOpfsTask::page(task_id, sender)); } - let (task_id, generation, sender) = crate::worker::register_worker_opfs_move_task( + let (task_id, sender) = crate::worker::register_worker_opfs_move_task( scope, resolver, handle, @@ -512,7 +498,7 @@ fn register_opfs_move_task<'s>( locator, handle_access, )?; - Some(RegisteredOpfsTask::worker(task_id, generation, sender)) + Some(RegisteredOpfsTask::worker(task_id, sender)) } fn current_opfs_handle_registry(scope: &mut v8::PinScope<'_, '_>) -> Option { diff --git a/moli-renderer-v8/src/worker/global_scope/mod.rs b/moli-renderer-v8/src/worker/global_scope/mod.rs index c5dc6a230e..031e5023ec 100644 --- a/moli-renderer-v8/src/worker/global_scope/mod.rs +++ b/moli-renderer-v8/src/worker/global_scope/mod.rs @@ -1037,10 +1037,9 @@ pub(super) enum PendingServiceWorkerClientQueryType { } /// A WebCrypto primitive dispatched off the worker event loop to the blocking -/// pool. The worker owns the resolver; completion is matched back by `task_id` -/// and dropped if the worker generation advanced (navigation/`close()` reset). +/// pool. The worker owns the resolver and matches the completion back by the +/// task id allocated for this worker lifetime. pub(super) struct PendingWorkerWebCryptoTask { - pub(super) generation: u64, pub(super) resolver: v8::Global, } @@ -1049,12 +1048,10 @@ pub(super) struct PendingWorkerWebCryptoTask { /// page-side typed producer captures its exact Page/Window owner. pub(crate) struct WorkerWebCryptoCompletion { pub(crate) task_id: u64, - pub(crate) generation: u64, pub(crate) result: Result, } pub(super) struct PendingWorkerOpfsTask { - pub(super) generation: u64, pub(super) locator: moli_storage_service::StorageBucketLocator, pub(super) handle_access: Option, pub(super) settlement: crate::opfs_owner_tasks::OpfsTaskSettlement, @@ -1086,7 +1083,6 @@ impl WorkerOpfsOwnerState { pub(crate) struct WorkerOpfsCompletion { pub(crate) task_id: u64, - pub(crate) generation: u64, pub(crate) result: OpfsTaskResult, } @@ -1597,15 +1593,8 @@ pub(crate) struct WorkerGlobalState { pub(super) pending_webcrypto: HashMap, /// Worker WebCrypto task id counter (never zero so 0 can mean "unset"). pub(super) next_webcrypto_task_id: u64, - /// Worker WebCrypto generation; bumping it invalidates in-flight completions. - /// Workers have no in-place context reset (terminate/`close()` drops the - /// whole state and tears down the isolate), so this is currently constant. - /// It mirrors the page-side generation guard and would let a future in-place - /// worker reset drop stale blocking-task completions without a code change. - pub(super) webcrypto_generation: u64, /// OPFS completions routed from the partition-owned storage IO sequence. pub(super) opfs_completion_tx: mpsc::UnboundedSender, - pub(super) opfs_generation: u64, pub(super) opfs_owner_state: Option, /// In-flight Service Worker `periodicsync` events keyed by runtime event id. pub(super) pending_service_worker_periodic_sync_events: @@ -1715,18 +1704,14 @@ impl WorkerGlobalState { pub(super) fn register_pending_webcrypto_task( &mut self, resolver: v8::Global, - ) -> (u64, u64, mpsc::UnboundedSender) { + ) -> (u64, mpsc::UnboundedSender) { let task_id = self.next_webcrypto_task_id; - self.next_webcrypto_task_id = self.next_webcrypto_task_id.wrapping_add(1).max(1); - let generation = self.webcrypto_generation; - self.pending_webcrypto.insert( - task_id, - PendingWorkerWebCryptoTask { - generation, - resolver, - }, - ); - (task_id, generation, self.webcrypto_completion_tx.clone()) + self.next_webcrypto_task_id = task_id + .checked_add(1) + .expect("worker WebCrypto task id exhausted"); + self.pending_webcrypto + .insert(task_id, PendingWorkerWebCryptoTask { resolver }); + (task_id, self.webcrypto_completion_tx.clone()) } pub(super) fn take_pending_webcrypto_task( @@ -1741,23 +1726,23 @@ impl WorkerGlobalState { locator: moli_storage_service::StorageBucketLocator, handle_access: Option, settlement: crate::opfs_owner_tasks::OpfsTaskSettlement, - ) -> (u64, u64, mpsc::UnboundedSender) { + ) -> (u64, mpsc::UnboundedSender) { let state = self .opfs_owner_state .get_or_insert_with(WorkerOpfsOwnerState::default); let task_id = state.next_task_id; - state.next_task_id = state.next_task_id.wrapping_add(1).max(1); - let generation = self.opfs_generation; + state.next_task_id = task_id + .checked_add(1) + .expect("worker OPFS task id exhausted"); state.pending_tasks.insert( task_id, PendingWorkerOpfsTask { - generation, locator, handle_access, settlement, }, ); - (task_id, generation, self.opfs_completion_tx.clone()) + (task_id, self.opfs_completion_tx.clone()) } pub(super) fn take_pending_opfs_task(&mut self, task_id: u64) -> Option { @@ -2138,7 +2123,7 @@ impl WorkerGlobalState { pub(crate) fn register_worker_webcrypto_task( scope: &mut v8::PinScope<'_, '_>, resolver: v8::Local<'_, v8::PromiseResolver>, -) -> Option<(u64, u64, mpsc::UnboundedSender)> { +) -> Option<(u64, mpsc::UnboundedSender)> { let state = get_worker_state(scope)?; let resolver = v8::Global::new(scope, resolver); let mut state = state.borrow_mut(); @@ -2150,7 +2135,7 @@ pub(crate) fn register_worker_opfs_task( resolver: v8::Local<'_, v8::PromiseResolver>, locator: moli_storage_service::StorageBucketLocator, handle_access: Option, -) -> Option<(u64, u64, mpsc::UnboundedSender)> { +) -> Option<(u64, mpsc::UnboundedSender)> { let state = get_worker_state(scope)?; let resolver = v8::Global::new(scope, resolver); let mut state = state.borrow_mut(); @@ -2168,7 +2153,7 @@ pub(crate) fn register_worker_opfs_iterator_task( iterator_id: u32, keep_alive: v8::Global, handle_access: Option, -) -> Option<(u64, u64, mpsc::UnboundedSender)> { +) -> Option<(u64, mpsc::UnboundedSender)> { let state = get_worker_state(scope)?; let mut state = state.borrow_mut(); Some(state.register_pending_opfs_task( @@ -2189,7 +2174,7 @@ pub(crate) fn register_worker_opfs_move_task( mutation: crate::opfs_owner_tasks::OpfsHandleMutationGuard, locator: moli_storage_service::StorageBucketLocator, handle_access: Option, -) -> Option<(u64, u64, mpsc::UnboundedSender)> { +) -> Option<(u64, mpsc::UnboundedSender)> { let state = get_worker_state(scope)?; let mut state = state.borrow_mut(); Some(state.register_pending_opfs_task( @@ -2262,8 +2247,8 @@ pub(crate) fn cancel_worker_opfs_task(scope: &mut v8::PinScope<'_, '_>, task_id: } /// Settle a worker WebCrypto promise once its blocking task reports back on the -/// worker event loop. Stale completions (generation advanced by a worker reset) -/// are dropped without touching the resolver. +/// worker event loop. Terminating a worker drops this state and its completion +/// receiver together, so a separate reset generation is unnecessary. pub(super) fn drain_worker_webcrypto_completion( scope: &mut v8::PinScope<'_, '_>, state: &Rc>, @@ -2271,15 +2256,9 @@ pub(super) fn drain_worker_webcrypto_completion( ) { let pending = { let mut state = state.borrow_mut(); - let current_generation = state.webcrypto_generation; let Some(pending) = state.take_pending_webcrypto_task(completion.task_id) else { return; }; - if pending.generation != completion.generation - || completion.generation != current_generation - { - return; - } pending }; let resolver = v8::Local::new(scope, &pending.resolver); @@ -2297,15 +2276,9 @@ pub(super) fn drain_worker_opfs_completion( ) { let pending = { let mut state = state.borrow_mut(); - let current_generation = state.opfs_generation; let Some(pending) = state.take_pending_opfs_task(completion.task_id) else { return; }; - if pending.generation != completion.generation - || completion.generation != current_generation - { - return; - } pending }; let handle_access = pending.handle_access; diff --git a/moli-renderer-v8/src/worker/thread/mod.rs b/moli-renderer-v8/src/worker/thread/mod.rs index 4f25bd2f24..43720b98c1 100644 --- a/moli-renderer-v8/src/worker/thread/mod.rs +++ b/moli-renderer-v8/src/worker/thread/mod.rs @@ -1733,9 +1733,7 @@ async fn worker_main( webcrypto_completion_tx, pending_webcrypto: std::collections::HashMap::new(), next_webcrypto_task_id: 1, - webcrypto_generation: 0, opfs_completion_tx, - opfs_generation: 0, opfs_owner_state: None, pending_service_worker_periodic_sync_events: std::collections::HashMap::new(), pending_service_worker_client_queries: std::collections::HashMap::new(),