bgworker wakes up on messages and works until no more work to do.

[pykello]

No description provided.

[greptile-apps]

Greptile Summary

This PR refactors the background worker in the lazy block device implementation to use an event-driven architecture instead of polling. The key change transforms the BgWorker from using a fixed 1ms sleep polling loop to a more efficient system that blocks on message reception when idle and processes work continuously when busy.

The implementation adds busy() methods to both StripeFetcher and MetadataFlusher components. These methods check for pending operations - the StripeFetcher checks if the fetch queue has items or if source/target channels are busy, while the MetadataFlusher checks for pending or in-progress flush requests. The BgWorker uses these busy states to determine whether to block on receive_requests() or continue processing.

The receive_requests() method signature is updated to accept a boolean block parameter. When block=true, it uses blocking recv() followed by draining available messages with try_recv(). When block=false, it only processes immediately available messages. The worker's main loop now calls receive_requests(block) where block = !(stripe_fetcher.busy() || metadata_flusher.busy()).

This change integrates with the existing lazy block device architecture where the BgWorker coordinates between stripe fetching (reading data from source to target in chunks) and metadata flushing operations. The event-driven approach should improve both response latency when the system is idle and CPU efficiency by eliminating unnecessary wake-ups.

Confidence score: 4/5

• This is a well-structured refactoring that should improve performance and responsiveness without changing core functionality
• The implementation follows consistent patterns across components and maintains thread safety
• The bgworker.rs changes need careful review to ensure the new event-driven logic doesn't introduce race conditions or deadlocks

_{4 files reviewed, 1 comment}

_{Edit Code Review Bot Settings | Greptile}

[Copilot]

Pull Request Overview

This PR improves the efficiency of the background worker by implementing demand-driven processing instead of polling with fixed sleep intervals. The worker now blocks on incoming requests when idle and processes all available work when busy.

• Replaced polling loop with sleep to a blocking/non-blocking request processing model
• Added busy state detection to determine when components have pending work
• Removed fixed 1ms sleep interval in favor of event-driven processing

Reviewed Changes

Copilot reviewed 4 out of 4 changed files in this pull request and generated 2 comments.

File	Description
src/block_device/bdev_lazy/stripe_fetcher.rs	Added busy() method to check if fetcher has pending work
src/block_device/bdev_lazy/metadata_flusher.rs	Added busy() method to check if flusher has pending requests
src/block_device/bdev_lazy/bgworker.rs	Refactored request processing to use blocking/non-blocking pattern and removed sleep
src/block_device/bdev_lazy/bdev_lazy_tests.rs	Updated test calls to use new non-blocking request processing