Sitelet https://github.com/category-labs/manytrace/commit/5f7e8211682d57c71f348a04c9360f8ceca13730
Skip to content

Commit 5f7e821

Browse files
dshulyakdshulyak
committed
protocol, perfetto-format, manytrace: introduce track event in the protocol
1 parent 4be23dc commit 5f7e821

3 files changed

Lines changed: 195 additions & 0 deletions

File tree

‎manytrace/src/converter.rs‎

Lines changed: 112 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,7 @@ pub struct PerfettoConverter<W: Write> {
99
process_tracks: HashMap<i32, u64>,
1010
thread_tracks: HashMap<(i32, i32), u64>,
1111
counter_tracks: HashMap<String, u64>,
12+
track_map: HashMap<protocol::TrackId, u64>,
1213
}
1314

1415
impl<W: Write> PerfettoConverter<W> {
@@ -18,6 +19,7 @@ impl<W: Write> PerfettoConverter<W> {
1819
process_tracks: HashMap::new(),
1920
thread_tracks: HashMap::new(),
2021
counter_tracks: HashMap::new(),
22+
track_map: HashMap::new(),
2123
}
2224
}
2325

@@ -185,6 +187,58 @@ impl<W: Write> PerfettoConverter<W> {
185187
Ok(())
186188
}
187189

190+
fn convert_track(&mut self, track: &protocol::Track) -> eyre::Result<()> {
191+
use protocol::TrackType;
192+
193+
let track_id = track.track_type.to_id();
194+
if self.track_map.contains_key(&track_id) {
195+
return Ok(());
196+
}
197+
198+
let parent_uuid = if let Some(parent) = &track.parent {
199+
let parent_id = parent.to_id();
200+
if !self.track_map.contains_key(&parent_id) {
201+
match parent {
202+
TrackType::Thread { tid, pid } => {
203+
let uuid = self.ensure_thread_track(*pid, *tid, None)?;
204+
self.track_map.insert(parent_id, uuid);
205+
uuid
206+
}
207+
TrackType::Process { pid } => {
208+
let uuid = self.ensure_process_track(*pid, None)?;
209+
self.track_map.insert(parent_id, uuid);
210+
uuid
211+
}
212+
TrackType::Cpu { .. }
213+
| TrackType::Custom { .. }
214+
| TrackType::Counter { .. } => *self.track_map.get(&parent_id).unwrap_or(&0),
215+
}
216+
} else {
217+
*self.track_map.get(&parent_id).unwrap()
218+
}
219+
} else {
220+
0
221+
};
222+
223+
let track_uuid = match &track.track_type {
224+
TrackType::Cpu { .. } | TrackType::Custom { .. } => self
225+
.writer
226+
.write_generic_track(track.name.to_string(), parent_uuid)?,
227+
TrackType::Counter { unit, .. } => self.writer.write_counter_track(
228+
track.name.to_string(),
229+
unit.map(|u| u.to_string()),
230+
parent_uuid,
231+
)?,
232+
TrackType::Thread { tid, pid } => {
233+
self.ensure_thread_track(*pid, *tid, Some(track.name))?
234+
}
235+
TrackType::Process { pid } => self.ensure_process_track(*pid, Some(track.name))?,
236+
};
237+
238+
self.track_map.insert(track_id, track_uuid);
239+
Ok(())
240+
}
241+
188242
pub fn convert_message(&mut self, message: &protocol::Message) -> eyre::Result<()> {
189243
let (event, stream_id) = match message {
190244
protocol::Message::Event(e) => (e, None),
@@ -239,6 +293,7 @@ impl<W: Write> PerfettoConverter<W> {
239293
Event::ProcessName(process_name) => {
240294
self.convert_process_name(process_name.pid, process_name.name)?
241295
}
296+
Event::Track(track) => self.convert_track(track)?,
242297
}
243298
Ok(())
244299
}
@@ -304,6 +359,63 @@ impl<W: Write> PerfettoConverter<W> {
304359
ArchivedEvent::ProcessName(process_name) => {
305360
self.convert_process_name(process_name.pid.to_native(), process_name.name.as_ref())?
306361
}
362+
ArchivedEvent::Track(track) => {
363+
let track_type = match &track.track_type {
364+
protocol::ArchivedTrackType::Cpu { cpu } => protocol::TrackType::Cpu {
365+
cpu: cpu.to_native(),
366+
},
367+
protocol::ArchivedTrackType::Thread { tid, pid } => {
368+
protocol::TrackType::Thread {
369+
tid: tid.to_native(),
370+
pid: pid.to_native(),
371+
}
372+
}
373+
protocol::ArchivedTrackType::Process { pid } => protocol::TrackType::Process {
374+
pid: pid.to_native(),
375+
},
376+
protocol::ArchivedTrackType::Custom { id } => {
377+
protocol::TrackType::Custom { id: id.to_native() }
378+
}
379+
protocol::ArchivedTrackType::Counter { id, unit } => {
380+
protocol::TrackType::Counter {
381+
id: id.to_native(),
382+
unit: unit.as_ref().map(|u| u.as_ref()),
383+
}
384+
}
385+
};
386+
387+
let parent = track.parent.as_ref().map(|p| match p {
388+
protocol::ArchivedTrackType::Cpu { cpu } => protocol::TrackType::Cpu {
389+
cpu: cpu.to_native(),
390+
},
391+
protocol::ArchivedTrackType::Thread { tid, pid } => {
392+
protocol::TrackType::Thread {
393+
tid: tid.to_native(),
394+
pid: pid.to_native(),
395+
}
396+
}
397+
protocol::ArchivedTrackType::Process { pid } => protocol::TrackType::Process {
398+
pid: pid.to_native(),
399+
},
400+
protocol::ArchivedTrackType::Custom { id } => {
401+
protocol::TrackType::Custom { id: id.to_native() }
402+
}
403+
protocol::ArchivedTrackType::Counter { id, unit } => {
404+
protocol::TrackType::Counter {
405+
id: id.to_native(),
406+
unit: unit.as_ref().map(|u| u.as_ref()),
407+
}
408+
}
409+
});
410+
411+
let owned_track = protocol::Track {
412+
name: track.name.as_ref(),
413+
track_type,
414+
parent,
415+
};
416+
417+
self.convert_track(&owned_track)?
418+
}
307419
}
308420
Ok(())
309421
}

‎perfetto-format/src/lib.rs‎

Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -280,6 +280,32 @@ impl<W: Write> PerfettoStreamWriter<W> {
280280
self.write_packet(packet, None)
281281
}
282282

283+
pub fn write_generic_track(
284+
&mut self,
285+
name: String,
286+
parent_track_uuid: u64,
287+
) -> Result<u64, std::io::Error> {
288+
let track_uuid = self.next_track_uuid();
289+
let track_desc = TrackDescriptor {
290+
uuid: Some(track_uuid),
291+
parent_uuid: if parent_track_uuid > 0 {
292+
Some(parent_track_uuid)
293+
} else {
294+
None
295+
},
296+
static_or_dynamic_name: Some(track_descriptor::StaticOrDynamicName::Name(name)),
297+
..Default::default()
298+
};
299+
300+
let packet = TracePacket {
301+
data: Some(trace_packet::Data::TrackDescriptor(track_desc)),
302+
..Default::default()
303+
};
304+
305+
self.write_packet(packet, None)?;
306+
Ok(track_uuid)
307+
}
308+
283309
pub fn write_counter_track(
284310
&mut self,
285311
name: String,

‎protocol/src/lib.rs‎

Lines changed: 57 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -84,6 +84,62 @@ impl<'a> Default for InternedData<'a> {
8484
}
8585
}
8686

87+
#[derive(Archive, Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, Hash)]
88+
#[rkyv(compare(PartialEq), derive(Debug))]
89+
pub enum TrackId {
90+
Cpu { cpu: u32 },
91+
Thread { tid: i32, pid: i32 },
92+
Process { pid: i32 },
93+
Custom { id: u64 },
94+
Counter { id: u64 },
95+
}
96+
97+
#[derive(Archive, Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
98+
#[rkyv(compare(PartialEq))]
99+
pub enum TrackType<'a> {
100+
Cpu {
101+
cpu: u32,
102+
},
103+
Thread {
104+
tid: i32,
105+
pid: i32,
106+
},
107+
Process {
108+
pid: i32,
109+
},
110+
Custom {
111+
id: u64,
112+
},
113+
Counter {
114+
id: u64,
115+
#[rkyv(with = Map<InlineAsBox>)]
116+
unit: Option<&'a str>,
117+
},
118+
}
119+
120+
impl<'a> TrackType<'a> {
121+
pub fn to_id(&self) -> TrackId {
122+
match self {
123+
TrackType::Cpu { cpu } => TrackId::Cpu { cpu: *cpu },
124+
TrackType::Thread { tid, pid } => TrackId::Thread {
125+
tid: *tid,
126+
pid: *pid,
127+
},
128+
TrackType::Process { pid } => TrackId::Process { pid: *pid },
129+
TrackType::Custom { id } => TrackId::Custom { id: *id },
130+
TrackType::Counter { id, .. } => TrackId::Counter { id: *id },
131+
}
132+
}
133+
}
134+
135+
#[derive(Archive, Serialize, Deserialize)]
136+
pub struct Track<'a> {
137+
#[rkyv(with = InlineAsBox)]
138+
pub name: &'a str,
139+
pub track_type: TrackType<'a>,
140+
pub parent: Option<TrackType<'a>>,
141+
}
142+
87143
#[derive(Archive, Serialize, Deserialize)]
88144
pub struct Counter<'a> {
89145
#[rkyv(with = InlineAsBox)]
@@ -217,6 +273,7 @@ pub enum Event<'a> {
217273
ProcessName(ProcessName<'a>),
218274
InternedData(InternedData<'a>),
219275
Sample(Sample),
276+
Track(Track<'a>),
220277
}
221278

222279
#[derive(Archive, Serialize, Deserialize)]

0 commit comments

Comments
 (0)