reth/spec.md

Proof Worker Context Refresh – Minimal Plan

Goal

Stop respawning proof workers every block while still giving them the latest ProofTaskCtx and read-only transaction.

Core Approach

1. Spawn the storage/account worker threads once during startup and keep the crossbeam queues alive.
2. Teach the worker job enums a single control message (UpdateWorkerContext) that carries a fresh read-only transaction and a refreshed ProofTaskCtx.
3. Before processing block N+1, wait until all block N jobs finish, broadcast one UpdateWorkerContext per worker, wait for acknowledgements, then resume normal job dispatching.

Step-by-step Implementation Plan

1. Extend ProofTaskCtx

   • Add a consistent_view: ConsistentDbView<Factory> field.
   • Update the constructor, tests, and every call site (payload processor, multiproof task, benches) to pass the view along with the existing trie overlays.

2. Add control variants to worker jobs

   • Update StorageWorkerJob / AccountWorkerJob with UpdateWorkerContext { tx, task_ctx, ack } and Shutdown.
   • Keep the enums generic so the control message can carry the concrete transaction type.

3. Handle context refresh inside workers

   • Make ProofTaskTx mutable inside each worker loop.
   • On UpdateWorkerContext, replace the stored tx and ProofTaskCtx, rebuild cursor factories and any cached providers, then ack.
   • On Shutdown, break the loop so the thread exits cleanly.

4. Track in-flight jobs

   • Introduce an Arc<AtomicUsize> shared by handles and workers.
   • Increment when queuing any job (storage/account/blinded); wrap execution in an RAII guard that decrements on completion/panic.
   • Expose a helper to read the current count.

5. Wire into PayloadProcessor

   • Initialise the workers once during setup.
   • Before each new block: wait until in_flight == 0, send one UpdateWorkerContext (with a fresh tx from the ctx’s view) to each worker, await all acknowledgements, then hand out a refreshed handle for the next block.
   • Drop any old handles during the refresh window so callers cannot enqueue work mid-swap.

6. Shutdown path

   • When the owner drops the pool/handle, broadcast Shutdown once per worker so every thread exits.

Integration Notes

• PayloadProcessor drives the refresh inline: wait for in_flight == 0, dispatch UpdateWorkerContext to each worker, await all acknowledgements, then resume normal job flow.
• Drop old handles before the refresh window so no new jobs sneak in while the workers are swapping state.
• On shutdown, send Shutdown once per worker so threads exit cleanly.

Testing Checklist

• Unit test that UpdateWorkerContext swaps the worker’s tx/ctx and triggers the ack.
• Unit test that the in-flight counter blocks the refresh loop until outstanding work completes.
• Integration test that reuses the same workers across two block contexts and observes updated state.