Update trace_dump to handle trace records

- Supports only list_frames for now

Signed-off-by: Doru Blânzeanu <dblnz@pm.me>

Author: dblnz

src/trace_dump/main.rs

@@ -7,8 +7,21 @@ use std::rc::Rc;
 use std::sync::Mutex;
 use std::time::Duration;
 
-use piet_common::{kurbo, Color, RenderContext, Text, TextLayout, TextLayoutBuilder};
+use piet_common::{Color, RenderContext, Text, TextLayout, TextLayoutBuilder, kurbo};
 
+fn read_u8_vec(inf: &mut File) -> Option<Vec<u8>> {
+    let len = read_u64(inf)?;
+    let mut vec = Vec::with_capacity(len as usize);
+    for _ in 0..len {
+        vec.push(read_u8(inf)?);
+    }
+    Some(vec)
+}
+fn read_u8(inf: &mut File) -> Option<u8> {
+    let mut bytes: [u8; 1] = [0; 1];
+    inf.read_exact(&mut bytes).ok()?;
+    Some(u8::from_ne_bytes(bytes))
+}
 fn read_u128(inf: &mut File) -> Result<u128, std::io::Error> {
     let mut bytes: [u8; 16] = [0; 16];
     inf.read_exact(&mut bytes)?;
@@ -76,6 +89,19 @@ fn dump_free(
     Some(())
 }
 
+fn dump_trace_record(
+    _state: &mut State,
+    _rs: &mut (),
+    now: Duration,
+    cycles: u64,
+    msg: Rc<[u8]>,
+) -> Option<()> {
+    let msg = String::from_utf8_lossy(&msg);
+    println!("\n[{:9?}] Cycles: {}, Message: {}", now, cycles, msg);
+
+    Some(())
+}
+
 // todo: this should use something more reasonable than a hash table
 // for each node. let's measure the out-degree and see if a small
 // array is better, to start.
@@ -526,19 +552,31 @@ fn render_free(
     Some(())
 }
 
-fn read_file<I, U, A, F, S>(
+fn render_trace_record(
+    _state: &mut State,
+    _rs: &mut RenderState,
+    _now: Duration,
+    _cycles: u64,
+    _msg: Rc<[u8]>,
+) -> Option<()> {
+    Some(())
+}
+
+fn read_file<I, U, A, F, T, S>(
     state: &mut State,
     mut handle_state: S,
     handle_ident: I,
     handle_unwind: U,
     handle_alloc: A,
     handle_free: F,
+    handle_trace_record: T,
 ) -> Option<()>
 where
     I: Fn(&mut State, &mut S, Duration, blake3::Hash) -> Option<()>,
     U: Fn(&mut State, &mut S, Duration, Rc<[u64]>) -> Option<()>,
     A: Fn(&mut State, &mut S, Duration, u64, u64, Rc<[u64]>) -> Option<()>,
     F: Fn(&mut State, &mut S, Duration, u64, u64, Rc<[u64]>) -> Option<()>,
+    T: Fn(&mut State, &mut S, Duration, u64, Rc<[u8]>) -> Option<()>,
 {
     loop {
         let time = match read_u128(&mut state.inf) {
@@ -584,6 +622,10 @@ where
             let trace = amt_trace.1.clone();
             state.total -= amt;
             handle_free(state, &mut handle_state, now, ptr, amt, trace)?;
+        } else if frame_id == 4 {
+            let cycles = read_u64(&mut state.inf)?;
+            let msg = read_u8_vec(&mut state.inf)?.into();
+            handle_trace_record(state, &mut handle_state, now, cycles, msg)?;
         } else {
             return None;
         }
@@ -683,6 +725,7 @@ fn spawn_render_thread(
             render_unwind,
             render_alloc,
             render_free,
+            render_trace_record,
         )?;
         bar_ffmpeg.wait().ok()?;
         flame_ffmpeg.wait().ok()?;
@@ -739,6 +782,7 @@ fn dump_trace(mut state: State) {
         dump_unwind,
         dump_alloc,
         dump_free,
+        dump_trace_record,
     );
 }
 
@@ -755,6 +799,7 @@ fn plot_mem(args: Vec<String>, mut state: State) {
         |_, _, _, _| Some(()),
         |_, _, _, _, _, _| Some(()),
         |_, _, _, _, _, _| Some(()),
+        |_, _, _, _, _| Some(()),
     ) {
         Some(()) => (),
         None => {
@@ -794,6 +839,7 @@ fn plot_mem(args: Vec<String>, mut state: State) {
         |_, _, _, _| Some(()),
         count_frame,
         count_frame,
+        |_, _, _, _, _| Some(()),
     );
     if state.num_durations > 0 {
         (*jobs.lock().unwrap()).push((*start_duration.lock().unwrap(), state.max_duration));