Merge pull request #376 from orottier/feature/no-garbage-collector-offline

Don't run the off-thread garbage collector for OfflineAudioContext

Author: orottier

src/context/offline.rs

@@ -17,33 +17,9 @@ pub struct OfflineAudioContext {
     /// the size of the buffer in sample-frames
     length: usize,
     /// the rendering 'thread', fully controlled by the offline context
-    renderer: SingleUseRenderThread,
+    renderer: RenderThread,
 }
 
-mod private {
-    use super::*;
-
-    pub(crate) struct SingleUseRenderThread(RenderThread);
-
-    impl SingleUseRenderThread {
-        pub fn new(rt: RenderThread) -> Self {
-            Self(rt)
-        }
-
-        pub fn render_audiobuffer(self, buffer_size: usize) -> AudioBuffer {
-            self.0.render_audiobuffer_sync(buffer_size)
-        }
-    }
-
-    // SAFETY:
-    // The RenderThread is not Sync since it contains `AudioRenderQuantum`s (which use Rc) and `dyn
-    // AudioProcessor` which may not allow sharing between threads. However we mark the
-    // SingleUseRenderThread as Sync because it can only run once (and thus on a single thread)
-    // NB: the render thread should never hand out the contained `Rc` and `AudioProcessor`s
-    unsafe impl Sync for SingleUseRenderThread {}
-}
-use private::SingleUseRenderThread;
-
 impl BaseAudioContext for OfflineAudioContext {
     fn base(&self) -> &ConcreteBaseAudioContext {
         &self.base
@@ -81,8 +57,6 @@ impl OfflineAudioContext {
             number_of_channels,
             receiver,
             frames_played_clone,
-            None,
-            None,
         );
 
         // first, setup the base audio context
@@ -98,7 +72,7 @@ impl OfflineAudioContext {
         Self {
             base,
             length,
-            renderer: SingleUseRenderThread::new(renderer),
+            renderer,
         }
     }
 
@@ -107,7 +81,7 @@ impl OfflineAudioContext {
     /// This function will block the current thread and returns the rendered `AudioBuffer`
     /// synchronously. An async version is currently not implemented.
     pub fn start_rendering_sync(self) -> AudioBuffer {
-        self.renderer.render_audiobuffer(self.length)
+        self.renderer.render_audiobuffer_sync(self.length)
     }
 
     /// get the length of rendering audio buffer

src/io/cpal.rs

@@ -186,14 +186,14 @@ impl AudioBackendManager for CpalBackend {
         // shared atomic to report output latency to the control thread
         let output_latency = Arc::new(AtomicF64::new(0.));
 
-        let renderer = RenderThread::new(
+        let mut renderer = RenderThread::new(
             sample_rate,
             preferred_config.channels as usize,
             ctrl_msg_recv.clone(),
             Arc::clone(&frames_played),
-            Some(load_value_send.clone()),
-            Some(event_send.clone()),
         );
+        renderer.set_event_channels(load_value_send.clone(), event_send.clone());
+        renderer.spawn_garbage_collector_thread();
 
         log::debug!(
             "Attempt output stream with preferred config: {:?}",
@@ -227,14 +227,14 @@ impl AudioBackendManager for CpalBackend {
                     &supported_config
                 );
 
-                let renderer = RenderThread::new(
+                let mut renderer = RenderThread::new(
                     sample_rate,
                     supported_config.channels as usize,
                     ctrl_msg_recv,
                     frames_played,
-                    Some(load_value_send),
-                    Some(event_send),
                 );
+                renderer.set_event_channels(load_value_send, event_send);
+                renderer.spawn_garbage_collector_thread();
 
                 let spawned = spawn_output_stream(
                     &device,

src/io/cubeb.rs

@@ -182,14 +182,14 @@ impl AudioBackendManager for CubebBackend {
             _ => cubeb::ChannelLayout::UNDEFINED, // TODO, does this work?
         };
 
-        let renderer = RenderThread::new(
+        let mut renderer = RenderThread::new(
             sample_rate,
             number_of_channels,
             ctrl_msg_recv,
             frames_played,
-            Some(load_value_send),
-            Some(event_send),
         );
+        renderer.set_event_channels(load_value_send, event_send);
+        renderer.spawn_garbage_collector_thread();
 
         let params = cubeb::StreamParamsBuilder::new()
             .format(cubeb::SampleFormat::Float32NE) // use float (native endian)

src/io/none.rs

@@ -77,14 +77,10 @@ impl AudioBackendManager for NoneBackend {
             event_send,
         } = render_thread_init;
 
-        let render_thread = RenderThread::new(
-            sample_rate,
-            MAX_CHANNELS,
-            ctrl_msg_recv,
-            frames_played,
-            Some(load_value_send),
-            Some(event_send),
-        );
+        let mut render_thread =
+            RenderThread::new(sample_rate, MAX_CHANNELS, ctrl_msg_recv, frames_played);
+        render_thread.set_event_channels(load_value_send, event_send);
+        render_thread.spawn_garbage_collector_thread();
 
         // Use a bounded channel for real-time safety. A maximum of 32 control messages (resume,
         // suspend, ..) will be handled per render quantum. The control thread will block when the

src/render/thread.rs

@@ -32,7 +32,7 @@ pub(crate) struct RenderThread {
     buffer_offset: Option<(usize, AudioRenderQuantum)>,
     load_value_sender: Option<Sender<AudioRenderCapacityLoad>>,
     event_sender: Option<Sender<EventDispatch>>,
-    garbage_collector: llq::Producer<Box<dyn Any + Send>>,
+    garbage_collector: Option<llq::Producer<Box<dyn Any + Send>>>,
 }
 
 // SAFETY:
@@ -52,21 +52,34 @@ impl RenderThread {
         number_of_channels: usize,
         receiver: Receiver<ControlMessage>,
         frames_played: Arc<AtomicU64>,
-        load_value_sender: Option<Sender<AudioRenderCapacityLoad>>,
-        event_sender: Option<Sender<EventDispatch>>,
     ) -> Self {
-        let (gc_producer, gc_consumer) = llq::Queue::new().split();
-        spawn_garbage_collector_thread(gc_consumer);
         Self {
             graph: None,
             sample_rate,
             number_of_channels,
             frames_played,
             receiver: Some(receiver),
             buffer_offset: None,
-            load_value_sender,
-            event_sender,
-            garbage_collector: gc_producer,
+            load_value_sender: None,
+            event_sender: None,
+            garbage_collector: None,
+        }
+    }
+
+    pub(crate) fn set_event_channels(
+        &mut self,
+        load_value_sender: Sender<AudioRenderCapacityLoad>,
+        event_sender: Sender<EventDispatch>,
+    ) {
+        self.load_value_sender = Some(load_value_sender);
+        self.event_sender = Some(event_sender);
+    }
+
+    pub(crate) fn spawn_garbage_collector_thread(&mut self) {
+        if self.garbage_collector.is_none() {
+            let (gc_producer, gc_consumer) = llq::Queue::new().split();
+            spawn_garbage_collector_thread(gc_consumer);
+            self.garbage_collector = Some(gc_producer);
         }
     }
 
@@ -129,7 +142,9 @@ impl RenderThread {
                 }
                 NodeMessage { id, mut msg } => {
                     self.graph.as_mut().unwrap().route_message(id, msg.as_mut());
-                    self.garbage_collector.push(msg);
+                    if let Some(gc) = self.garbage_collector.as_mut() {
+                        gc.push(msg)
+                    }
                 }
             }
         }
@@ -312,8 +327,9 @@ impl RenderThread {
 
 impl Drop for RenderThread {
     fn drop(&mut self) {
-        self.garbage_collector
-            .push(llq::Node::new(Box::new(TerminateGarbageCollectorThread)));
+        if let Some(gc) = self.garbage_collector.as_mut() {
+            gc.push(llq::Node::new(Box::new(TerminateGarbageCollectorThread)))
+        }
         log::info!("Audio render thread has been dropped");
     }
 }