rrtrace 0.1.0-x86_64-linux

data/src/ringbuffer.rs

@@ -0,0 +1,134 @@
+use std::sync::atomic::{self, AtomicU64};
+
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct RRTraceEvent {
+    timestamp_and_event_type: u64,
+    data: u64,
+}
+
+const EVENT_TYPE_MASK: u64 = 0xF000000000000000;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum RRTraceEventType {
+    Call,
+    Return,
+    GCStart,
+    GCEnd,
+    ThreadStart,
+    ThreadReady,
+    ThreadSuspended,
+    ThreadResume,
+    ThreadExit,
+}
+
+impl RRTraceEvent {
+    pub fn timestamp(&self) -> u64 {
+        self.timestamp_and_event_type & !EVENT_TYPE_MASK
+    }
+
+    pub fn event_type(&self) -> RRTraceEventType {
+        match self.timestamp_and_event_type & EVENT_TYPE_MASK {
+            0x0000000000000000 => RRTraceEventType::Call,
+            0x1000000000000000 => RRTraceEventType::Return,
+            0x2000000000000000 => RRTraceEventType::GCStart,
+            0x3000000000000000 => RRTraceEventType::GCEnd,
+            0x4000000000000000 => RRTraceEventType::ThreadStart,
+            0x5000000000000000 => RRTraceEventType::ThreadReady,
+            0x6000000000000000 => RRTraceEventType::ThreadSuspended,
+            0x7000000000000000 => RRTraceEventType::ThreadResume,
+            0x8000000000000000 => RRTraceEventType::ThreadExit,
+            _ => unreachable!(),
+        }
+    }
+
+    pub fn data(&self) -> u64 {
+        self.data
+    }
+}
+
+pub const SIZE: usize = 65_536;
+pub const MASK: usize = SIZE - 1;
+
+#[repr(C, align(64))]
+struct RRTraceEventRingBufferWriter {
+    write_index: AtomicU64,
+    read_index_cache: u64,
+}
+
+#[repr(C, align(64))]
+struct RRTraceEventRingBufferReader {
+    read_index: AtomicU64,
+    write_index_cache: u64,
+}
+
+#[repr(C)]
+pub struct RRTraceEventRingBuffer {
+    buffer: [RRTraceEvent; SIZE],
+    writer: RRTraceEventRingBufferWriter,
+    reader: RRTraceEventRingBufferReader,
+}
+
+impl RRTraceEventRingBuffer {
+    unsafe fn read(this: *mut Self, buffer: &mut [RRTraceEvent]) -> usize {
+        unsafe {
+            let read_index = (*this).reader.read_index.load(atomic::Ordering::Acquire);
+            let write_index = (*this).reader.write_index_cache;
+            let available = (write_index - read_index) as usize;
+            let available = if available == 0 {
+                (*this).reader.write_index_cache =
+                    (*this).writer.write_index.load(atomic::Ordering::Acquire);
+                let write_index = (*this).reader.write_index_cache;
+                (write_index - read_index) as usize
+            } else {
+                available
+            };
+            let read_len = available.min(buffer.len());
+            let buffer = &mut buffer[..read_len];
+
+            let first_part_len = (&(*this).buffer)[read_index as usize & MASK..].len();
+            if read_len <= first_part_len {
+                buffer
+                    .copy_from_slice(&(&(*this).buffer)[read_index as usize & MASK..][..read_len]);
+            } else {
+                buffer[..first_part_len]
+                    .copy_from_slice(&(&(*this).buffer)[read_index as usize & MASK..]);
+                buffer[first_part_len..]
+                    .copy_from_slice(&(&(*this).buffer)[0..read_len - first_part_len]);
+            }
+
+            (*this)
+                .reader
+                .read_index
+                .store(read_index + read_len as u64, atomic::Ordering::Release);
+            read_len
+        }
+    }
+}
+
+pub struct EventRingBuffer {
+    ringbuffer: *mut RRTraceEventRingBuffer,
+    drop: Option<Box<dyn FnOnce()>>,
+}
+
+impl EventRingBuffer {
+    pub unsafe fn new(
+        ringbuffer: *mut RRTraceEventRingBuffer,
+        drop: impl FnOnce() + 'static,
+    ) -> Self {
+        EventRingBuffer {
+            ringbuffer,
+            drop: Some(Box::new(drop)),
+        }
+    }
+
+    pub fn read(&mut self, buffer: &mut [RRTraceEvent]) -> usize {
+        unsafe { RRTraceEventRingBuffer::read(self.ringbuffer, buffer) }
+    }
+}
+
+impl Drop for EventRingBuffer {
+    fn drop(&mut self) {
+        self.drop.take().unwrap()();
+    }
+}

data/src/shader.wgsl

@@ -0,0 +1,115 @@
+struct Vertex {
+    @location(0) position: vec3<f32>,
+}
+
+struct CallBox {
+    @location(1) start_time: vec2<u32>,
+    @location(2) end_time: vec2<u32>,
+    @location(3) method_id: u32,
+    @location(4) depth: u32,
+}
+
+struct GCBox {
+    @location(1) time: vec2<u32>,
+}
+
+struct CameraUniform {
+    view_proj: mat4x4<f32>,
+    base_time: vec2<u32>, // x: lo, y: hi
+    max_depth: u32,
+    num_threads: u32,
+}
+
+struct ThreadInfo {
+    lane_id: u32,
+}
+
+@group(0) @binding(0)
+var<uniform> camera: CameraUniform;
+
+@group(0) @binding(1)
+var<uniform> thread_info: ThreadInfo;
+
+struct VertexOutput {
+    @builtin(position) clip_position: vec4<f32>,
+    @location(0) color: vec4<f32>,
+}
+
+fn sub64(a: vec2<u32>, b: vec2<u32>) -> vec2<u32> {
+    if (a.x < b.x) {
+        let lo = a.x + 0x80000000u - b.x;
+        let hi = a.y - 1 - b.y;
+        return vec2<u32>(lo, hi);
+    } else {
+        let lo = a.x - b.x;
+        let hi = a.y - b.y;
+        return vec2<u32>(lo, hi);
+    }
+}
+
+fn u64tof32(v: vec2<u32>) -> f32 {
+    return f32(v.y) * 2147483648.0 + f32(v.x);
+}
+
+fn get_color(method_id: u32) -> vec4<f32> {
+    let m = method_id;
+    let r = f32((m * 123u) % 255u) / 255.0;
+    let g = f32((m * 456u) % 255u) / 255.0;
+    let b = f32((m * 789u) % 255u) / 255.0;
+    return vec4<f32>(r, g, b, 1.0);
+}
+
+@vertex
+fn vs_main(
+    v: Vertex,
+    call: CallBox,
+) -> VertexOutput {
+    var end_time: vec2<u32>;
+    if (call.end_time.y == 0xffffffffu) {
+        end_time = vec2<u32>(0, 0);
+    } else {
+        end_time = sub64(camera.base_time, call.end_time);
+    }
+    let start_time = sub64(camera.base_time, call.start_time);
+
+    let x = select(start_time, end_time, v.position.x > 0.5);
+
+    let world_pos = vec3<f32>(
+        u64tof32(x) / 500000000.0,
+        (f32(call.depth) + v.position.y) / f32(camera.max_depth),
+        (f32(thread_info.lane_id) + v.position.z) / f32(camera.num_threads),
+    );
+
+    var out: VertexOutput;
+    out.color = get_color(call.method_id);
+    out.clip_position = camera.view_proj * vec4<f32>(world_pos, 1.0);
+    return out;
+}
+
+@fragment
+fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
+    return in.color;
+}
+
+struct GCVertex {
+    @location(0) position: vec2<f32>,
+}
+
+@vertex
+fn vs_gc(
+    v: GCVertex,
+    gc: GCBox,
+) -> VertexOutput {
+    let time = sub64(camera.base_time, gc.time);
+
+    let world_pos = vec3<f32>(
+        u64tof32(time) / 500000000.0,
+        v.position.x,
+        v.position.y,
+    );
+
+    var out: VertexOutput;
+    out.color = vec4<f32>(1.0, 0.5, 0.0, 0.1);
+    out.clip_position = camera.view_proj * vec4<f32>(world_pos, 1.0);
+    return out;
+}

data/src/shm_unix.rs

@@ -0,0 +1,47 @@
+use std::ffi::CString;
+
+pub struct SharedMemory {
+    ptr: *mut u8,
+    name: CString,
+    size: usize,
+}
+
+impl SharedMemory {
+    pub unsafe fn open(name: CString, size: usize) -> SharedMemory {
+        let fd = unsafe { libc::shm_open(name.as_ptr(), libc::O_RDWR, 0) };
+        if fd < 0 {
+            panic!("shm_open failed");
+        }
+        let memory = unsafe {
+            libc::mmap(
+                std::ptr::null_mut(),
+                size,
+                libc::PROT_READ | libc::PROT_WRITE,
+                libc::MAP_SHARED,
+                fd,
+                0,
+            )
+        };
+        if memory == libc::MAP_FAILED {
+            panic!("mmap failed");
+        }
+        SharedMemory {
+            ptr: memory as *mut u8,
+            name,
+            size,
+        }
+    }
+
+    pub fn as_ptr<T>(&self) -> *mut T {
+        self.ptr.cast()
+    }
+}
+
+impl Drop for SharedMemory {
+    fn drop(&mut self) {
+        unsafe {
+            libc::munmap(self.ptr as *mut libc::c_void, self.size);
+            libc::shm_unlink(self.name.as_ptr());
+        }
+    }
+}

data/src/shm_windows.rs

@@ -0,0 +1,44 @@
+use std::ffi::CString;
+use windows_sys::Win32::Foundation::{CloseHandle, GetLastError, HANDLE};
+use windows_sys::Win32::System::Memory::{
+    FILE_MAP_ALL_ACCESS, MEMORY_MAPPED_VIEW_ADDRESS, MapViewOfFile, OpenFileMappingA,
+    UnmapViewOfFile,
+};
+
+pub struct SharedMemory {
+    ptr: MEMORY_MAPPED_VIEW_ADDRESS,
+    handle: HANDLE,
+}
+
+impl SharedMemory {
+    pub unsafe fn open(name: CString, size: usize) -> SharedMemory {
+        let handle =
+            unsafe { OpenFileMappingA(FILE_MAP_ALL_ACCESS, 0, name.as_ptr() as *const u8) };
+        if handle.is_null() {
+            panic!("OpenFileMappingA failed with error {}", unsafe {
+                GetLastError()
+            });
+        }
+
+        let ptr = unsafe { MapViewOfFile(handle, FILE_MAP_ALL_ACCESS, 0, 0, size) };
+        if ptr.Value.is_null() {
+            unsafe { CloseHandle(handle) };
+            panic!("MapViewOfFile failed");
+        }
+
+        SharedMemory { ptr, handle }
+    }
+
+    pub fn as_ptr<T>(&self) -> *mut T {
+        self.ptr.Value.cast()
+    }
+}
+
+impl Drop for SharedMemory {
+    fn drop(&mut self) {
+        unsafe {
+            UnmapViewOfFile(self.ptr);
+            CloseHandle(self.handle);
+        }
+    }
+}

data/src/trace_state.rs

@@ -0,0 +1,275 @@
+use crate::ringbuffer::{RRTraceEvent, RRTraceEventType};
+use smallvec::SmallVec;
+use std::convert;
+use std::fmt::Debug;
+
+#[repr(C)]
+#[derive(Copy, Default, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
+pub struct CallBox {
+    start_time: [u32; 2],
+    end_time: [u32; 2],
+    method_id: u32,
+    depth: u32,
+}
+
+pub const VISIBLE_DURATION: u64 = 1_000_000_000 * 5;
+
+pub fn encode_time(time: u64) -> [u32; 2] {
+    [
+        (time & 0x7fffffff) as u32,
+        ((time >> 31) & 0xffffffff) as u32,
+    ]
+}
+
+#[derive(Debug, Clone)]
+pub struct FastTrace {
+    thread_stacks: SmallVec<[(u32, SmallVec<[u64; 4]>); 1]>,
+    current_thread: u32,
+    in_gc: bool,
+}
+
+impl FastTrace {
+    pub fn new() -> FastTrace {
+        FastTrace {
+            thread_stacks: smallvec::smallvec![(0, SmallVec::new())],
+            current_thread: 0,
+            in_gc: false,
+        }
+    }
+    pub fn process_events(&mut self, events: &[RRTraceEvent]) {
+        for &event in events {
+            match event.event_type() {
+                RRTraceEventType::Call => {
+                    let method_id = event.data();
+                    self.thread_stacks[self.current_thread as usize]
+                        .1
+                        .push(method_id);
+                }
+                RRTraceEventType::Return => {
+                    let method_id = event.data();
+                    let stack = &mut self.thread_stacks[self.current_thread as usize].1;
+                    while stack.pop().is_some_and(|m| m != method_id) {}
+                }
+                RRTraceEventType::ThreadSuspended => {
+                    self.current_thread = u32::MAX;
+                }
+                RRTraceEventType::ThreadResume => {
+                    let thread_id = event.data() as u32;
+                    let index = match self
+                        .thread_stacks
+                        .binary_search_by_key(&thread_id, |&(thread_id, _)| thread_id)
+                    {
+                        Ok(index) => index,
+                        Err(index) => {
+                            self.thread_stacks
+                                .insert(index, (thread_id, SmallVec::new()));
+                            index
+                        }
+                    };
+                    self.current_thread = index as u32;
+                }
+                RRTraceEventType::ThreadExit => {
+                    let thread_id = event.data() as u32;
+                    if let Ok(index) = self
+                        .thread_stacks
+                        .binary_search_by_key(&thread_id, |&(thread_id, _)| thread_id)
+                    {
+                        self.thread_stacks.remove(index);
+                    };
+                }
+                RRTraceEventType::GCStart
+                | RRTraceEventType::GCEnd
+                | RRTraceEventType::ThreadStart
+                | RRTraceEventType::ThreadReady => {}
+            }
+        }
+        self.in_gc = events.last().unwrap().event_type() == RRTraceEventType::GCStart;
+    }
+}
+
+#[derive(Debug, Clone)]
+struct CallStackEntry {
+    vertex_index: usize,
+    method_id: u64,
+}
+
+pub struct SlowTrace {
+    data: Vec<(u32, Vec<CallStackEntry>, Vec<CallBox>)>,
+    max_depth: u32,
+    end_time: u64,
+    gc_events: Vec<u64>,
+}
+
+impl SlowTrace {
+    pub fn trace(start_time: u64, fast_trace: FastTrace, events: &[RRTraceEvent]) -> SlowTrace {
+        let end_time = events.last().unwrap().timestamp();
+        let mut max_depth = 0;
+        let FastTrace {
+            thread_stacks,
+            current_thread,
+            in_gc,
+        } = fast_trace;
+        let mut gc_events = Vec::new();
+        let mut call_stack = thread_stacks
+            .into_iter()
+            .map(|(thread_id, stack)| {
+                (
+                    thread_id,
+                    stack
+                        .into_iter()
+                        .map(|method_id| CallStackEntry {
+                            method_id,
+                            vertex_index: usize::MAX,
+                        })
+                        .collect::<Vec<_>>(),
+                    Vec::new(),
+                )
+            })
+            .collect::<Vec<_>>();
+        if !in_gc && let Some((_, stack, vertices)) = call_stack.get_mut(current_thread as usize) {
+            vertices.reserve(stack.len());
+            for (depth, entry) in stack.iter_mut().enumerate() {
+                entry.vertex_index = vertices.len();
+                let depth = depth as u32;
+                max_depth = max_depth.max(depth);
+                vertices.push(CallBox {
+                    start_time: encode_time(start_time),
+                    end_time: encode_time(end_time),
+                    method_id: entry.method_id as u32,
+                    depth,
+                });
+            }
+        }
+        let mut null_vec1 = Vec::new();
+        let mut null_vec2 = Vec::new();
+        let (mut current_stack, mut current_vertices) = call_stack
+            .get_mut(current_thread as usize)
+            .map_or((&mut null_vec1, &mut null_vec2), |(_, stack, vertices)| {
+                (stack, vertices)
+            });
+        for event in events {
+            match event.event_type() {
+                RRTraceEventType::Call => {
+                    let vertex_index = current_vertices.len();
+                    let depth = current_stack.len() as u32;
+                    current_stack.push(CallStackEntry {
+                        vertex_index,
+                        method_id: event.data(),
+                    });
+                    current_vertices.push(CallBox {
+                        start_time: encode_time(event.timestamp()),
+                        end_time: encode_time(end_time),
+                        method_id: event.data() as u32,
+                        depth,
+                    });
+                    max_depth = max_depth.max(depth);
+                }
+                RRTraceEventType::Return => {
+                    while let Some(CallStackEntry {
+                        vertex_index,
+                        method_id,
+                    }) = current_stack.pop()
+                    {
+                        current_vertices[vertex_index].end_time = encode_time(event.timestamp());
+                        if method_id == event.data() {
+                            break;
+                        }
+                    }
+                }
+                RRTraceEventType::GCStart => {
+                    gc_events.push(event.timestamp());
+                    for CallStackEntry { vertex_index, .. } in current_stack.iter_mut() {
+                        current_vertices[*vertex_index].end_time = encode_time(event.timestamp());
+                        *vertex_index = usize::MAX;
+                    }
+                }
+                RRTraceEventType::GCEnd => {
+                    gc_events.push(event.timestamp());
+                    for (
+                        depth,
+                        &mut CallStackEntry {
+                            ref mut vertex_index,
+                            method_id,
+                        },
+                    ) in current_stack.iter_mut().enumerate()
+                    {
+                        let new_index = current_vertices.len();
+                        let depth = depth as u32;
+                        current_vertices.push(CallBox {
+                            start_time: encode_time(event.timestamp()),
+                            end_time: encode_time(end_time),
+                            method_id: method_id as u32,
+                            depth,
+                        });
+                        max_depth = max_depth.max(depth);
+                        *vertex_index = new_index;
+                    }
+                }
+                RRTraceEventType::ThreadSuspended => {
+                    for CallStackEntry { vertex_index, .. } in current_stack.iter_mut() {
+                        current_vertices[*vertex_index].end_time = encode_time(event.timestamp());
+                        *vertex_index = usize::MAX;
+                    }
+                }
+                RRTraceEventType::ThreadResume => {
+                    let thread_id = event.data() as u32;
+                    let index = call_stack.binary_search_by_key(&thread_id, |&(tid, _, _)| tid);
+                    if let Err(i) = index {
+                        call_stack.insert(i, (thread_id, Vec::new(), Vec::new()));
+                    }
+                    let (_, new_stack, new_vertices) =
+                        &mut call_stack[index.unwrap_or_else(convert::identity)];
+
+                    for (
+                        depth,
+                        &mut CallStackEntry {
+                            ref mut vertex_index,
+                            method_id,
+                        },
+                    ) in new_stack.iter_mut().enumerate()
+                    {
+                        let new_index = new_vertices.len();
+                        let depth = depth as u32;
+                        new_vertices.push(CallBox {
+                            start_time: encode_time(event.timestamp()),
+                            end_time: encode_time(end_time),
+                            method_id: method_id as u32,
+                            depth,
+                        });
+                        max_depth = max_depth.max(depth);
+                        *vertex_index = new_index;
+                    }
+
+                    (current_stack, current_vertices) = (new_stack, new_vertices);
+                }
+                RRTraceEventType::ThreadExit
+                | RRTraceEventType::ThreadStart
+                | RRTraceEventType::ThreadReady => {}
+            }
+        }
+        SlowTrace {
+            data: call_stack,
+            max_depth,
+            end_time,
+            gc_events,
+        }
+    }
+
+    pub fn data(&self) -> impl Iterator<Item = (u32, &[CallBox])> {
+        self.data
+            .iter()
+            .map(|&(thread_id, _, ref call_box)| (thread_id, call_box.as_slice()))
+    }
+
+    pub fn gc_events(&self) -> &[u64] {
+        &self.gc_events
+    }
+
+    pub fn end_time(&self) -> u64 {
+        self.end_time
+    }
+
+    pub fn max_depth(&self) -> u32 {
+        self.max_depth
+    }
+}

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: rrtrace
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: x86_64-linux
+authors:
+- White-Green
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Rrtrace is a profiling tool that captures Ruby method calls and visualizes
+  them using a high-performance Rust renderer.
+email:
+- 43771790+White-Green@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/release.yml"
+- Cargo.lock
+- Cargo.toml
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/rrtrace/extconf.rb
+- ext/rrtrace/process_manager_posix.h
+- ext/rrtrace/process_manager_windows.h
+- ext/rrtrace/rrtrace.c
+- ext/rrtrace/rrtrace.h
+- ext/rrtrace/rrtrace_event.h
+- ext/rrtrace/rrtrace_event_ringbuffer.h
+- ext/rrtrace/rust_build_helper.rb
+- ext/rrtrace/shared_memory_posix.h
+- ext/rrtrace/shared_memory_windows.h
+- lib/rrtrace.rb
+- lib/rrtrace/rrtrace.so
+- lib/rrtrace/version.rb
+- mise.toml
+- sig/rrtrace.rbs
+- src/main.rs
+- src/renderer.rs
+- src/renderer/vertex_arena.rs
+- src/ringbuffer.rs
+- src/shader.wgsl
+- src/shm_unix.rs
+- src/shm_windows.rs
+- src/trace_state.rs
+homepage: https://github.com/White-Green/rrtrace
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/White-Green/rrtrace
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '4.0'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 4.1.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: A Ruby trace tool with Rust-based visualizer
+test_files: []