How Meetily Implements Async Boundary Design Using Arc<RwLock> for Shared Recording State

Meetily coordinates concurrent audio capture, processing, and UI tasks by wrapping a RecordingState struct in an Arc<RwLock> to enable safe shared ownership and fine-grained access control across async boundaries.

Meetily’s audio subsystem must synchronize several concurrently running components—including audio streams, processing pipelines, and Tauri commands—without triggering borrow checker violations or data races. To solve this, the application implements an async boundary design using Arc<RwLock> for shared recording state, allowing multiple async tasks to read and write state safely while minimizing lock contention.

The Challenge of Async Audio Coordination

Meetily’s architecture spans three concurrent domains: raw audio capture streams, the processing pipeline that handles VAD and Whisper transcription, and the Tauri-based UI that exposes recording controls. Each domain runs on separate Tokio tasks and threads, yet they must share critical state such as recording status, device handles, and error counters.

Passing raw references between these async boundaries would violate Rust’s ownership rules. The solution requires a pattern that provides both shared ownership and runtime-borrow checking.

Arc as the Async Boundary Solution

The codebase adopts a classic pattern that separates ownership from access control.

Reference Counting with Arc

The RecordingManager initializes the state once and wraps it in an Arc (Atomic Reference Counted) pointer. This cloneable handle allows every async component—stream managers, pipeline workers, and UI command handlers—to hold a cheap reference to the same underlying data without lifetime conflicts.

Read-Write Locking for Access Patterns

An RwLock guards the interior state, enabling multiple concurrent readers through read guards while guaranteeing exclusive access for writers. This design accommodates high-frequency read operations—such as UI polls checking is_recording—while safely serializing state transitions like start_recording or pause_recording.

Inside the RecordingState Structure

To minimize contention on the outer RwLock, RecordingState employs finer-grained synchronization primitives for frequently updated fields:

• AtomicBool for is_recording and is_paused flags
• AtomicU32 for high-frequency counters like chunks processed
• Mutex<Option<Arc<AudioDevice>>> for device handles that require infrequent updates

This hybrid approach ensures the outer lock is held only for complex state transitions, while atomic operations handle hot-path updates without blocking.

Implementation Across Components

Initialization and Distribution

In frontend/src-tauri/src/audio/recording_manager.rs, the RecordingManager creates the shared state and distributes clones to subsystems:

pub struct RecordingManager {
    // Shared, thread‑safe state
    state: Arc<RecordingState>,
    // …other managers
}

impl RecordingManager {
    pub fn new() -> Self {
        let state = RecordingState::new();                 // ⇢ Arc<RecordingState>
        let stream_manager = AudioStreamManager::new(state.clone());
        let pipeline_manager = AudioPipelineManager::new(state.clone());
        Self {
            state,
            stream_manager,
            pipeline_manager,
            // …
        }
    }
}

Concurrent Reads in the Pipeline

The audio pipeline in frontend/src-tauri/src/audio/pipeline.rs acquires read locks for metrics and status checks:

// Inside an async loop that emits metrics to the UI
let is_active = {
    let guard = self.state.read().await;      // Acquire read lock
    guard.is_active()
};
if is_active {
    // …emit metric
}

Exclusive Writes for State Transitions

When the user triggers a recording start, the manager acquires an exclusive write lock to update flags and timestamps:

pub fn start_recording(&self) -> Result<()> {
    let mut guard = self.state.write().await; // Exclusive write lock
    guard.is_recording.store(true, Ordering::SeqCst);
    guard.recording_start = Some(Instant::now());
    Ok(())
}

Lock-Free Counter Updates

For high-frequency operations like chunk processing, the system bypasses the RwLock entirely using atomic operations:

pub fn send_audio_chunk(&self, chunk: AudioChunk) -> Result<()> {
    // Update atomic counter without entering the outer RwLock
    self.stats
        .chunks_processed
        .fetch_add(1, Ordering::Relaxed);
    // …
}

Key Source Files

File	Role in the async‑boundary design
frontend/src-tauri/src/audio/recording_state.rs	Defines RecordingState (atomic flags, mutexes) and its public API.
frontend/src-tauri/src/audio/recording_manager.rs	Holds an Arc<RecordingState> and distributes it to async subsystems.
frontend/src-tauri/src/audio/pipeline.rs	Consumes the shared state, reads flags, and updates statistics.
frontend/src-tauri/src/audio/stream.rs	Uses the same Arc<RecordingState> to pause/resume streams based on the state.
frontend/src-tauri/src/lib.rs	Registers Tauri commands that operate on the shared state.

Summary

• Meetily uses Arc<RwLock<RecordingState>> to share ownership across async boundaries without lifetime issues.
• The RwLock allows concurrent reads for UI polling and metrics while serializing write operations for state transitions.
• Fine-grained primitives (AtomicBool, AtomicU32, Mutex) inside RecordingState minimize contention on the outer lock.
• This pattern scales easily: new async components receive a cloned Arc without requiring architectural changes.

Frequently Asked Questions

Why does Meetily use RwLock instead of Mutex for the recording state?

RwLock allows multiple tasks to read the state simultaneously, which is critical when the UI polls recording status while the pipeline checks metrics. A Mutex would force these read operations to serialize, creating unnecessary bottlenecks during high-frequency status checks.

How does the recording state handle high-frequency updates without performance issues?

The RecordingState struct uses atomic types like AtomicU32 and AtomicBool for fields that change often, such as chunk counters. These updates use fetch_add with Ordering::Relaxed and do not require acquiring the outer RwLock, eliminating lock contention on the hot path.

What prevents data races when multiple async tasks access the AudioDevice handles?

Device handles are wrapped in Mutex<Option<Arc<AudioDevice>>> and protected by the outer RwLock. This ensures that reads or swaps of the device reference occur exclusively, preventing race conditions during device reconnection events while the recording state remains accessible for reads.

Can this Arc pattern scale to additional audio processing features?

Yes. The architecture only requires cloning the Arc for new components. Whether adding a noise suppression module or a secondary analysis pipeline, each new async task receives the same shared handle, maintaining the async boundary guarantees without modifying existing code.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}