rrtrace 0.1.0 → 0.2.0

data/src/main.rs

@@ -1,21 +1,29 @@
+use crate::object_scatter::ObjectScatter;
+use crate::oneshot_channel::{OneshotReceiver, OneshotSender};
 use crate::renderer::Renderer;
 use crate::ringbuffer::{EventRingBuffer, RRTraceEvent};
-use crate::trace_state::{FastTrace, SlowTrace, VISIBLE_DURATION};
+use crate::trace_state::{FastTrace, SlowTrace};
+use crate::universal_notifier::UniversalNotifier;
+use std::collections::VecDeque;
 use std::ffi::CString;
-use std::sync::atomic::AtomicU64;
-use std::sync::{Arc, atomic};
+use std::num::NonZeroUsize;
+use std::sync::{Arc, OnceLock};
+use std::time::{Duration, Instant};
 use std::{env, mem, thread};
 use winit::application::ApplicationHandler;
 use winit::event::*;
 use winit::event_loop::{ControlFlow, EventLoop};
 use winit::window::Window;
 
+mod object_scatter;
+mod oneshot_channel;
 mod renderer;
 mod ringbuffer;
 #[cfg_attr(unix, path = "shm_unix.rs")]
 #[cfg_attr(windows, path = "shm_windows.rs")]
 mod shm;
 mod trace_state;
+mod universal_notifier;
 
 struct App {
     window: Option<Arc<Window>>,
@@ -77,14 +85,17 @@ impl ApplicationHandler for App {
     }
 
     fn about_to_wait(&mut self, _event_loop: &winit::event_loop::ActiveEventLoop) {
-        let updated = self.renderer.sync();
-        if updated && let Some(window) = self.window.as_ref() {
+        self.renderer.sync();
+        if let Some(window) = self.window.as_ref() {
             window.request_redraw();
         }
     }
 }
 
+static BASE_TIME: OnceLock<Instant> = OnceLock::new();
+
 fn main() {
+    BASE_TIME.set(Instant::now()).unwrap();
     assert_eq!(env::args().len(), 2, "Usage: rrtrace <shm_name>");
     let shm_name = env::args().nth(1).unwrap();
 
@@ -141,7 +152,7 @@ async fn init_gpu() -> (wgpu::Instance, wgpu::Adapter, wgpu::Device, wgpu::Queue
 
 fn queue_pipe_thread(
     shm_name: String,
-    event_queue: Arc<crossbeam_queue::SegQueue<Vec<RRTraceEvent>>>,
+    event_queue: Arc<crossbeam_queue::SegQueue<Arc<[RRTraceEvent]>>>,
 ) -> impl FnOnce() + Send + 'static {
     move || {
         let shm = unsafe {
@@ -152,46 +163,117 @@ fn queue_pipe_thread(
         };
         let mut ringbuffer = unsafe { EventRingBuffer::new(shm.as_ptr(), move || drop(shm)) };
         let mut buffer = vec![Default::default(); 65536];
+        let mut offset = 0;
+        let mut before_send_time = 0;
         loop {
-            let count = ringbuffer.read(&mut buffer);
+            let count = ringbuffer.read(&mut buffer[offset..]);
             if count > 0 {
-                buffer.truncate(count);
-                event_queue.push(buffer.clone());
-                buffer.resize_with(65536, Default::default);
+                offset += count;
+                let chunk = &mut buffer[..offset];
+                chunk.sort_by_key(RRTraceEvent::timestamp);
+                let last_time = chunk.last().unwrap().timestamp();
+                if offset >= 1024 || last_time.saturating_sub(before_send_time) > 1_000_000 {
+                    event_queue.push(Arc::from(&chunk[..]));
+                    offset = 0;
+                    before_send_time = last_time;
+                }
+            } else {
+                thread::sleep(Duration::from_millis(1));
             }
         }
     }
 }
 fn trace_thread(
-    event_queue: Arc<crossbeam_queue::SegQueue<Vec<RRTraceEvent>>>,
+    event_queue: Arc<crossbeam_queue::SegQueue<Arc<[RRTraceEvent]>>>,
     result_queue: Arc<crossbeam_queue::SegQueue<SlowTrace>>,
 ) -> impl FnOnce() + Send + 'static {
     move || {
-        static LATEST_END_TIME: AtomicU64 = AtomicU64::new(0);
+        let parallel_trace_threads = thread::available_parallelism()
+            .map_or(0, NonZeroUsize::get)
+            .saturating_sub(2)
+            .max(1);
+
+        let universal_notifier = UniversalNotifier::new();
+        let (mut second_stage_sender, second_stage_receivers) =
+            ObjectScatter::<(u64, Arc<FastTrace>, Arc<[RRTraceEvent]>)>::new(
+                parallel_trace_threads,
+            );
+        let first_stage_event_queue = Arc::new(crossbeam_queue::SegQueue::<(
+            Arc<[RRTraceEvent]>,
+            OneshotSender<FastTrace>,
+        )>::new());
+        second_stage_receivers
+            .enumerate()
+            .for_each(|(i, mut second_stage_receiver)| {
+                let universal_notifier = universal_notifier.clone();
+                let first_stage_event_queue = Arc::clone(&first_stage_event_queue);
+                let result_queue = Arc::clone(&result_queue);
+                thread::Builder::new()
+                    .name(format!("slow_trace_thread_{}", i))
+                    .spawn(move || {
+                        loop {
+                            let v = universal_notifier.value();
+                            if let Some((events, result_slot)) = first_stage_event_queue.pop() {
+                                let trace = FastTrace::from_events(&events);
+                                result_slot.send(trace);
+                                continue;
+                            }
+                            if let Some(data) = second_stage_receiver.try_receive() {
+                                let (start_time, fast_trace, events) = *data;
+                                let trace = SlowTrace::trace(start_time, &fast_trace, &events);
+                                result_queue.push(trace);
+                                continue;
+                            }
+                            universal_notifier.wait(v);
+                        }
+                    })
+                    .unwrap();
+            });
+        let mut first = true;
         let mut start_time = 0u64;
-        let mut fast_trace = FastTrace::new();
+        let mut local_event_queue = VecDeque::new();
+        let mut first_stage_result_queue = VecDeque::new();
+        let mut first_stage_results = VecDeque::new();
+        let mut first_stage_result = None::<OneshotReceiver<FastTrace>>;
+        let mut trace_accumulate = None::<Arc<FastTrace>>;
         loop {
-            let Some(events) = event_queue.pop() else {
-                continue;
-            };
-            rayon_core::spawn({
-                let fast_trace = fast_trace.clone();
-                let events = events.clone();
-                let result_queue = result_queue.clone();
-                move || {
-                    if start_time + VISIBLE_DURATION
-                        < LATEST_END_TIME.load(atomic::Ordering::Relaxed)
-                    {
-                        return;
+            if first_stage_result.is_none()
+                && let Some(receiver) = first_stage_result_queue.pop_front()
+            {
+                first_stage_result = Some(receiver);
+            }
+            if let Some(receiver) = first_stage_result.take() {
+                match receiver.try_receive() {
+                    Ok(mut trace) => {
+                        match trace_accumulate.take() {
+                            None => trace.mark_as_first(),
+                            Some(acc) => acc.merge_into(&mut trace),
+                        }
+                        let trace = Arc::new(trace);
+                        trace_accumulate = Some(Arc::clone(&trace));
+                        first_stage_results.push_back(trace);
+                        first_stage_result = first_stage_result_queue.pop_front();
                     }
-                    let slow_trace = SlowTrace::trace(start_time, fast_trace, &events);
-                    result_queue.push(slow_trace);
+                    Err(receiver) => first_stage_result = Some(receiver),
+                };
+            }
+            if !first_stage_results.is_empty() && !local_event_queue.is_empty() {
+                let trace = first_stage_results.pop_front().unwrap();
+                let (start_time, events) = local_event_queue.pop_front().unwrap();
+                second_stage_sender.send((start_time, trace, events));
+                universal_notifier.notify();
+            }
+            if let Some(events) = event_queue.pop() {
+                let end_time = events.last().unwrap().timestamp();
+                let (sender, receiver) = oneshot_channel::channel();
+                first_stage_event_queue.push((Arc::clone(&events), sender));
+                universal_notifier.notify();
+                first_stage_result_queue.push_back(receiver);
+                if !mem::replace(&mut first, false) {
+                    local_event_queue.push_back((start_time, events));
                 }
-            });
-            fast_trace.process_events(&events);
-            let end_time = events.last().unwrap().timestamp();
-            LATEST_END_TIME.store(end_time, atomic::Ordering::Relaxed);
-            start_time = end_time;
+                start_time = end_time;
+            }
         }
     }
 }

data/src/object_scatter.rs

@@ -0,0 +1,110 @@
+use std::sync::atomic::AtomicPtr;
+use std::sync::{Arc, atomic};
+use std::{iter, marker::PhantomData, ptr, rc::Rc};
+
+#[repr(align(128))]
+struct Line<T> {
+    array: [AtomicPtr<T>; 16],
+}
+
+impl<T> Line<T> {
+    fn new() -> Line<T> {
+        Line {
+            array: [const { AtomicPtr::new(ptr::null_mut()) }; 16],
+        }
+    }
+
+    #[inline(always)]
+    fn get(&self, index: usize) -> &AtomicPtr<T> {
+        &self.array[index]
+    }
+}
+
+impl<T> Drop for Line<T> {
+    fn drop(&mut self) {
+        self.array.iter_mut().for_each(|ptr| {
+            let ptr = ptr.get_mut();
+            if !ptr.is_null() {
+                unsafe {
+                    drop(Box::from_raw(ptr));
+                }
+            }
+        })
+    }
+}
+
+pub struct ObjectScatter<T> {
+    array: Arc<[Line<T>]>,
+    index: usize,
+    _not_send: PhantomData<Rc<()>>,
+}
+
+pub struct ObjectScatterReceiver<T> {
+    array: Arc<[Line<T>]>,
+    slot: usize,
+    index: usize,
+}
+
+impl<T: Send> ObjectScatter<T> {
+    pub fn new(
+        count: usize,
+    ) -> (
+        ObjectScatter<T>,
+        impl ExactSizeIterator<Item = ObjectScatterReceiver<T>>,
+    ) {
+        assert!(count > 0);
+        let array = Arc::from(Vec::from_iter(
+            iter::from_fn(|| Some(Line::new())).take(count),
+        ));
+        let scatter = ObjectScatter {
+            array: Arc::clone(&array),
+            index: 0,
+            _not_send: PhantomData,
+        };
+        let receiver_iter = (0..count).map(move |slot| ObjectScatterReceiver {
+            array: Arc::clone(&array),
+            slot,
+            index: 0,
+        });
+        (scatter, receiver_iter)
+    }
+
+    pub fn send(&mut self, value: T) {
+        let ptr = Box::new(value);
+        let ptr = Box::into_raw(ptr);
+        let i = self.index;
+        let slot = i % self.array.len();
+        let index = i / self.array.len();
+        let line = &self.array[slot];
+        let old_ptr = line.get(index).swap(ptr, atomic::Ordering::Release);
+        if !old_ptr.is_null() {
+            unsafe {
+                drop(Box::from_raw(old_ptr));
+            }
+        }
+        self.index += 1;
+        if self.index >= self.array.len() * 16 {
+            self.index = 0;
+        }
+    }
+}
+
+impl<T: Send> ObjectScatterReceiver<T> {
+    pub fn try_receive(&mut self) -> Option<Box<T>> {
+        let line = &self.array[self.slot];
+        for _ in 0..16 {
+            let index = self.index;
+            let ptr = line
+                .get(index)
+                .swap(ptr::null_mut(), atomic::Ordering::Acquire);
+            self.index += 1;
+            if self.index >= 16 {
+                self.index = 0;
+            }
+            if !ptr.is_null() {
+                return unsafe { Some(Box::from_raw(ptr)) };
+            }
+        }
+        None
+    }
+}

data/src/oneshot_channel.rs

@@ -0,0 +1,74 @@
+use std::cell::UnsafeCell;
+use std::mem::MaybeUninit;
+use std::sync::atomic::AtomicBool;
+use std::sync::{Arc, atomic};
+
+struct OneshotSlot<T> {
+    value: UnsafeCell<MaybeUninit<T>>,
+    initialized: AtomicBool,
+}
+
+unsafe impl<T: Send> Send for OneshotSlot<T> {}
+unsafe impl<T: Sync> Sync for OneshotSlot<T> {}
+
+impl<T> Drop for OneshotSlot<T> {
+    fn drop(&mut self) {
+        if *self.initialized.get_mut() {
+            unsafe {
+                self.value.get_mut().assume_init_drop();
+            }
+        }
+    }
+}
+
+pub struct OneshotSender<T> {
+    slot: Arc<OneshotSlot<T>>,
+}
+
+impl<T> OneshotSender<T> {
+    #[inline(always)]
+    pub fn send(self, value: T) {
+        unsafe {
+            MaybeUninit::write(&mut *self.slot.value.get(), value);
+        }
+        self.slot.initialized.store(true, atomic::Ordering::Release);
+    }
+}
+
+pub struct OneshotReceiver<T> {
+    slot: Arc<OneshotSlot<T>>,
+}
+
+impl<T> OneshotReceiver<T> {
+    #[inline(always)]
+    pub fn try_receive(self) -> Result<T, OneshotReceiver<T>> {
+        if self
+            .slot
+            .initialized
+            .compare_exchange(
+                true,
+                false,
+                atomic::Ordering::Acquire,
+                atomic::Ordering::Relaxed,
+            )
+            .is_ok()
+        {
+            let value = unsafe { (*self.slot.value.get()).assume_init_read() };
+            Ok(value)
+        } else {
+            Err(self)
+        }
+    }
+}
+
+pub fn channel<T>() -> (OneshotSender<T>, OneshotReceiver<T>) {
+    let slot = Arc::new(OneshotSlot {
+        value: UnsafeCell::new(MaybeUninit::uninit()),
+        initialized: AtomicBool::new(false),
+    });
+    let sender = OneshotSender {
+        slot: Arc::clone(&slot),
+    };
+    let receiver = OneshotReceiver { slot };
+    (sender, receiver)
+}

data/src/renderer/vertex_arena.rs

@@ -57,20 +57,20 @@ impl FreeList {
         let mut start = range.start;
         let mut end = range.end;
 
-        if let Some((&next_start, &next_end)) = self.by_start.range(end..).next() {
-            if next_start == end {
-                self.by_size.remove(&(next_end - next_start, next_start));
-                self.by_start.remove(&next_start);
-                end = next_end;
-            }
+        if let Some((&next_start, &next_end)) = self.by_start.range(end..).next()
+            && next_start == end
+        {
+            self.by_size.remove(&(next_end - next_start, next_start));
+            self.by_start.remove(&next_start);
+            end = next_end;
         }
 
-        if let Some((&prev_start, &prev_end)) = self.by_start.range(..start).next_back() {
-            if prev_end == start {
-                self.by_size.remove(&(prev_end - prev_start, prev_start));
-                self.by_start.remove(&prev_start);
-                start = prev_start;
-            }
+        if let Some((&prev_start, &prev_end)) = self.by_start.range(..start).next_back()
+            && prev_end == start
+        {
+            self.by_size.remove(&(prev_end - prev_start, prev_start));
+            self.by_start.remove(&prev_start);
+            start = prev_start;
         }
 
         self.by_start.insert(start, end);
@@ -96,6 +96,7 @@ impl<T> VertexArena<T> {
             usage,
             mapped_at_creation: false,
         });
+        #[allow(clippy::reversed_empty_ranges)]
         VertexArena {
             data: Vec::new(),
             device,
@@ -232,7 +233,10 @@ impl<T> VertexArena<T> {
             }
         }
 
-        self.dirty_range = usize::MAX..0;
+        #[allow(clippy::reversed_empty_ranges)]
+        {
+            self.dirty_range = usize::MAX..0;
+        }
     }
 
     pub fn read_buffers(&self, mut f: impl FnMut(&Buffer, usize)) {