Attempt to improve performance of event loop in offline rendering

- inline some methods
- only conditionally poll for control messages

Author: orottier

src/events.rs

@@ -166,11 +166,15 @@ impl EventLoop {
         result
     }
 
-    pub fn handle_pending_events(&self) {
+    #[inline(always)]
+    pub fn handle_pending_events(&self) -> bool {
+        let mut events_were_handled = false;
         // try_iter will yield all pending events, but does not block
         for event in self.event_recv.try_iter() {
             self.handle_event(event);
+            events_were_handled = true;
         }
+        events_were_handled
     }
 
     pub fn run_in_thread(&self) {

src/render/thread.rs

@@ -2,7 +2,7 @@
 
 use std::any::Any;
 use std::cell::Cell;
-
+use std::ops::ControlFlow;
 use std::sync::atomic::{AtomicU64, AtomicU8, Ordering};
 use std::sync::Arc;
 use std::time::{Duration, Instant};
@@ -105,116 +105,125 @@ impl RenderThread {
         }
     }
 
+    #[inline(always)]
     fn handle_control_messages(&mut self) {
-        let receiver = match &self.receiver {
-            None => return,
-            Some(receiver) => receiver,
-        };
+        if self.receiver.is_none() {
+            return;
+        }
 
-        for msg in receiver.try_iter() {
-            use ControlMessage::*;
+        while let Ok(msg) = self.receiver.as_ref().unwrap().try_recv() {
+            let result = self.handle_control_message(msg);
+            if result.is_break() {
+                return; // stop processing
+            }
+        }
+    }
 
-            match msg {
-                RegisterNode {
-                    id: node_id,
+    fn handle_control_message(&mut self, msg: ControlMessage) -> ControlFlow<()> {
+        use ControlMessage::*;
+
+        match msg {
+            RegisterNode {
+                id: node_id,
+                reclaim_id,
+                node,
+                inputs,
+                outputs,
+                channel_config,
+            } => {
+                self.graph.as_mut().unwrap().add_node(
+                    node_id,
                     reclaim_id,
                     node,
                     inputs,
                     outputs,
                     channel_config,
-                } => {
-                    self.graph.as_mut().unwrap().add_node(
-                        node_id,
-                        reclaim_id,
-                        node,
-                        inputs,
-                        outputs,
-                        channel_config,
-                    );
-                }
-                ConnectNode {
-                    from,
-                    to,
-                    output,
-                    input,
-                } => {
-                    self.graph
-                        .as_mut()
-                        .unwrap()
-                        .add_edge((from, output), (to, input));
-                }
-                DisconnectNode { from, to } => {
-                    self.graph.as_mut().unwrap().remove_edge(from, to);
-                }
-                DisconnectAll { from } => {
-                    self.graph.as_mut().unwrap().remove_edges_from(from);
-                }
-                ControlHandleDropped { id } => {
-                    self.graph.as_mut().unwrap().mark_control_handle_dropped(id);
-                }
-                MarkCycleBreaker { id } => {
-                    self.graph.as_mut().unwrap().mark_cycle_breaker(id);
-                }
-                CloseAndRecycle { sender } => {
-                    self.set_state(AudioContextState::Suspended);
-                    let _ = sender.send(self.graph.take().unwrap());
-                    self.receiver = None;
-                    return; // no further handling of ctrl msgs
-                }
-                Startup { graph } => {
-                    debug_assert!(self.graph.is_none());
-                    self.graph = Some(graph);
-                    self.set_state(AudioContextState::Running);
-                }
-                NodeMessage { id, mut msg } => {
-                    self.graph.as_mut().unwrap().route_message(id, msg.as_mut());
-                    if let Some(gc) = self.garbage_collector.as_mut() {
-                        gc.push(msg)
-                    }
-                }
-                RunDiagnostics { mut buffer } => {
-                    use std::io::Write;
-                    writeln!(&mut buffer, "{:#?}", &self).ok();
-                    writeln!(&mut buffer, "{:?}", &self.graph).ok();
-                    self.event_sender
-                        .try_send(EventDispatch::diagnostics(buffer))
-                        .expect("Unable to send diagnostics - channel is full");
-                }
-                Suspend { notify } => {
-                    self.suspended = true;
-                    self.set_state(AudioContextState::Suspended);
-                    notify.send();
-                }
-                Resume { notify } => {
-                    self.suspended = false;
-                    self.set_state(AudioContextState::Running);
-                    notify.send();
-                }
-                Close { notify } => {
-                    self.suspended = true;
-                    self.set_state(AudioContextState::Closed);
-                    notify.send();
+                );
+            }
+            ConnectNode {
+                from,
+                to,
+                output,
+                input,
+            } => {
+                self.graph
+                    .as_mut()
+                    .unwrap()
+                    .add_edge((from, output), (to, input));
+            }
+            DisconnectNode { from, to } => {
+                self.graph.as_mut().unwrap().remove_edge(from, to);
+            }
+            DisconnectAll { from } => {
+                self.graph.as_mut().unwrap().remove_edges_from(from);
+            }
+            ControlHandleDropped { id } => {
+                self.graph.as_mut().unwrap().mark_control_handle_dropped(id);
+            }
+            MarkCycleBreaker { id } => {
+                self.graph.as_mut().unwrap().mark_cycle_breaker(id);
+            }
+            CloseAndRecycle { sender } => {
+                self.set_state(AudioContextState::Suspended);
+                let _ = sender.send(self.graph.take().unwrap());
+                self.receiver = None;
+                return ControlFlow::Break(()); // no further handling of ctrl msgs
+            }
+            Startup { graph } => {
+                debug_assert!(self.graph.is_none());
+                self.graph = Some(graph);
+                self.set_state(AudioContextState::Running);
+            }
+            NodeMessage { id, mut msg } => {
+                self.graph.as_mut().unwrap().route_message(id, msg.as_mut());
+                if let Some(gc) = self.garbage_collector.as_mut() {
+                    gc.push(msg)
                 }
+            }
+            RunDiagnostics { mut buffer } => {
+                use std::io::Write;
+                writeln!(&mut buffer, "{:#?}", &self).ok();
+                writeln!(&mut buffer, "{:?}", &self.graph).ok();
+                self.event_sender
+                    .try_send(EventDispatch::diagnostics(buffer))
+                    .expect("Unable to send diagnostics - channel is full");
+            }
+            Suspend { notify } => {
+                self.suspended = true;
+                self.set_state(AudioContextState::Suspended);
+                notify.send();
+            }
+            Resume { notify } => {
+                self.suspended = false;
+                self.set_state(AudioContextState::Running);
+                notify.send();
+            }
+            Close { notify } => {
+                self.suspended = true;
+                self.set_state(AudioContextState::Closed);
+                notify.send();
+            }
 
-                SetChannelCount { id, count } => {
-                    self.graph.as_mut().unwrap().set_channel_count(id, count);
-                }
+            SetChannelCount { id, count } => {
+                self.graph.as_mut().unwrap().set_channel_count(id, count);
+            }
 
-                SetChannelCountMode { id, mode } => {
-                    self.graph
-                        .as_mut()
-                        .unwrap()
-                        .set_channel_count_mode(id, mode);
-                }
+            SetChannelCountMode { id, mode } => {
+                self.graph
+                    .as_mut()
+                    .unwrap()
+                    .set_channel_count_mode(id, mode);
+            }
 
-                SetChannelInterpretation { id, interpretation } => {
-                    self.graph
-                        .as_mut()
-                        .unwrap()
-                        .set_channel_interpretation(id, interpretation);
-                }
+            SetChannelInterpretation { id, interpretation } => {
+                self.graph
+                    .as_mut()
+                    .unwrap()
+                    .set_channel_interpretation(id, interpretation);
             }
         }
+
+        ControlFlow::Continue(()) // continue handling more messages
     }
 
     // Render method of the `OfflineAudioContext::start_rendering_sync`
@@ -240,22 +249,26 @@ impl RenderThread {
         let mut buffer = AudioBuffer::new(options);
         let num_frames = (length + RENDER_QUANTUM_SIZE - 1) / RENDER_QUANTUM_SIZE;
 
-        // Handle addition/removal of nodes/edges
+        // Handle initial control messages
         self.handle_control_messages();
 
         for quantum in 0..num_frames {
             // Suspend at given times and run callbacks
             if suspend_callbacks.first().map(|&(q, _)| q) == Some(quantum) {
                 let callback = suspend_callbacks.remove(0).1;
                 (callback)(context);
-            }
 
-            // Handle addition/removal of nodes/edges
-            self.handle_control_messages();
+                // Handle any control messages that may have been submitted by the callback
+                self.handle_control_messages();
+            }
 
             self.render_offline_quantum(&mut buffer);
 
-            event_loop.handle_pending_events();
+            let events_were_handled = event_loop.handle_pending_events();
+            if events_were_handled {
+                // Handle any control messages that may have been submitted by the handler
+                self.handle_control_messages();
+            }
         }
 
         buffer