|
|
use std::{ |
|
|
cmp::max, |
|
|
collections::VecDeque, |
|
|
fmt::{Debug, Formatter}, |
|
|
vec, |
|
|
}; |
|
|
|
|
|
use hashbrown::HashMap; |
|
|
use rayon::iter::{IntoParallelIterator, IntoParallelRefIterator, ParallelIterator}; |
|
|
use rustc_hash::FxHashSet; |
|
|
|
|
|
use crate::{ |
|
|
FxIndexMap, |
|
|
bottom_up::build_bottom_up_graph, |
|
|
span::{Span, SpanEvent, SpanExtra, SpanGraphEvent, SpanIndex, SpanNames, SpanTimeData}, |
|
|
span_bottom_up_ref::SpanBottomUpRef, |
|
|
span_graph_ref::{SpanGraphEventRef, SpanGraphRef, event_map_to_list}, |
|
|
store::{SpanId, Store}, |
|
|
timestamp::Timestamp, |
|
|
}; |
|
|
|
|
|
pub type GroupNameToDirectAndRecusiveSpans<'l> = |
|
|
FxIndexMap<(&'l str, &'l str), (Vec<SpanIndex>, Vec<SpanIndex>)>; |
|
|
|
|
|
#[derive(Copy, Clone)] |
|
|
pub struct SpanRef<'a> { |
|
|
pub(crate) span: &'a Span, |
|
|
pub(crate) store: &'a Store, |
|
|
pub(crate) index: usize, |
|
|
} |
|
|
|
|
|
impl<'a> SpanRef<'a> { |
|
|
pub fn id(&self) -> SpanId { |
|
|
unsafe { SpanId::new_unchecked(self.index << 1) } |
|
|
} |
|
|
|
|
|
pub fn index(&self) -> SpanIndex { |
|
|
SpanIndex::new(self.index).unwrap() |
|
|
} |
|
|
|
|
|
pub fn parent(&self) -> Option<SpanRef<'a>> { |
|
|
self.span.parent.map(|index| SpanRef { |
|
|
span: &self.store.spans[index.get()], |
|
|
store: self.store, |
|
|
index: index.get(), |
|
|
}) |
|
|
} |
|
|
|
|
|
pub fn start(&self) -> Timestamp { |
|
|
self.span.start |
|
|
} |
|
|
|
|
|
pub fn time_data(&self) -> &'a SpanTimeData { |
|
|
self.span.time_data() |
|
|
} |
|
|
|
|
|
pub fn extra(&self) -> &'a SpanExtra { |
|
|
self.span.extra() |
|
|
} |
|
|
|
|
|
pub fn names(&self) -> &'a SpanNames { |
|
|
self.span.names() |
|
|
} |
|
|
|
|
|
pub fn end(&self) -> Timestamp { |
|
|
let time_data = self.time_data(); |
|
|
*time_data.end.get_or_init(|| { |
|
|
max( |
|
|
time_data.self_end, |
|
|
self.children() |
|
|
.map(|child| child.end()) |
|
|
.max() |
|
|
.unwrap_or_default(), |
|
|
) |
|
|
}) |
|
|
} |
|
|
|
|
|
pub fn is_complete(&self) -> bool { |
|
|
self.span.is_complete |
|
|
} |
|
|
|
|
|
pub fn is_root(&self) -> bool { |
|
|
self.index == 0 |
|
|
} |
|
|
|
|
|
pub fn nice_name(&self) -> (&'a str, &'a str) { |
|
|
let (category, title) = self.names().nice_name.get_or_init(|| { |
|
|
if let Some(name) = self |
|
|
.span |
|
|
.args |
|
|
.iter() |
|
|
.find(|&(k, _)| k == "name") |
|
|
.map(|(_, v)| v.as_str()) |
|
|
{ |
|
|
if matches!(self.span.name.as_str(), "turbo_tasks::function") { |
|
|
(self.span.name.clone(), name.to_string()) |
|
|
} else if matches!( |
|
|
self.span.name.as_str(), |
|
|
"turbo_tasks::resolve_call" | "turbo_tasks::resolve_trait_call" |
|
|
) { |
|
|
(self.span.name.clone(), format!("*{name}")) |
|
|
} else { |
|
|
( |
|
|
self.span.category.clone(), |
|
|
format!("{} {name}", self.span.name), |
|
|
) |
|
|
} |
|
|
} else { |
|
|
(self.span.category.to_string(), self.span.name.to_string()) |
|
|
} |
|
|
}); |
|
|
(category, title) |
|
|
} |
|
|
|
|
|
pub fn group_name(&self) -> (&'a str, &'a str) { |
|
|
let (category, title) = self.names().group_name.get_or_init(|| { |
|
|
if matches!(self.span.name.as_str(), "turbo_tasks::function") { |
|
|
let name = self |
|
|
.span |
|
|
.args |
|
|
.iter() |
|
|
.find(|&(k, _)| k == "name") |
|
|
.map(|(_, v)| v.to_string()) |
|
|
.unwrap_or_else(|| self.span.name.to_string()); |
|
|
(self.span.name.clone(), name) |
|
|
} else if matches!( |
|
|
self.span.name.as_str(), |
|
|
"turbo_tasks::resolve_call" | "turbo_tasks::resolve_trait_call" |
|
|
) { |
|
|
let name = self |
|
|
.span |
|
|
.args |
|
|
.iter() |
|
|
.find(|&(k, _)| k == "name") |
|
|
.map(|(_, v)| format!("*{v}")) |
|
|
.unwrap_or_else(|| self.span.name.to_string()); |
|
|
( |
|
|
self.span.category.clone(), |
|
|
format!("{} {name}", self.span.name), |
|
|
) |
|
|
} else { |
|
|
(self.span.category.clone(), self.span.name.clone()) |
|
|
} |
|
|
}); |
|
|
(category.as_str(), title.as_str()) |
|
|
} |
|
|
|
|
|
pub fn args(&self) -> impl Iterator<Item = (&str, &str)> { |
|
|
self.span.args.iter().map(|(k, v)| (k.as_str(), v.as_str())) |
|
|
} |
|
|
|
|
|
pub fn self_time(&self) -> Timestamp { |
|
|
self.time_data().self_time |
|
|
} |
|
|
|
|
|
pub fn self_allocations(&self) -> u64 { |
|
|
|
|
|
self.span.self_allocations.saturating_sub(32) |
|
|
} |
|
|
|
|
|
pub fn self_deallocations(&self) -> u64 { |
|
|
self.span.self_deallocations |
|
|
} |
|
|
|
|
|
pub fn self_persistent_allocations(&self) -> u64 { |
|
|
self.self_allocations() |
|
|
.saturating_sub(self.span.self_deallocations) |
|
|
} |
|
|
|
|
|
pub fn self_allocation_count(&self) -> u64 { |
|
|
|
|
|
self.span.self_allocation_count.saturating_sub(4) |
|
|
} |
|
|
|
|
|
pub fn self_span_count(&self) -> u64 { |
|
|
1 |
|
|
} |
|
|
|
|
|
|
|
|
#[allow(dead_code)] |
|
|
pub fn events_count(&self) -> usize { |
|
|
self.span.events.len() |
|
|
} |
|
|
|
|
|
|
|
|
#[allow(dead_code)] |
|
|
pub fn events(&self) -> impl Iterator<Item = SpanEventRef<'a>> { |
|
|
self.span.events.iter().map(|event| match event { |
|
|
&SpanEvent::SelfTime { start, end } => SpanEventRef::SelfTime { start, end }, |
|
|
SpanEvent::Child { index } => SpanEventRef::Child { |
|
|
span: SpanRef { |
|
|
span: &self.store.spans[index.get()], |
|
|
store: self.store, |
|
|
index: index.get(), |
|
|
}, |
|
|
}, |
|
|
}) |
|
|
} |
|
|
|
|
|
pub fn children(&self) -> impl DoubleEndedIterator<Item = SpanRef<'a>> + 'a + use<'a> { |
|
|
self.span.events.iter().filter_map(|event| match event { |
|
|
SpanEvent::SelfTime { .. } => None, |
|
|
SpanEvent::Child { index } => Some(SpanRef { |
|
|
span: &self.store.spans[index.get()], |
|
|
store: self.store, |
|
|
index: index.get(), |
|
|
}), |
|
|
}) |
|
|
} |
|
|
|
|
|
pub fn children_par(&self) -> impl ParallelIterator<Item = SpanRef<'a>> + 'a { |
|
|
self.span.events.par_iter().filter_map(|event| match event { |
|
|
SpanEvent::SelfTime { .. } => None, |
|
|
SpanEvent::Child { index } => Some(SpanRef { |
|
|
span: &self.store.spans[index.get()], |
|
|
store: self.store, |
|
|
index: index.get(), |
|
|
}), |
|
|
}) |
|
|
} |
|
|
|
|
|
pub fn total_time(&self) -> Timestamp { |
|
|
*self.time_data().total_time.get_or_init(|| { |
|
|
self.children() |
|
|
.map(|child| child.total_time()) |
|
|
.reduce(|a, b| a + b) |
|
|
.unwrap_or_default() |
|
|
+ self.self_time() |
|
|
}) |
|
|
} |
|
|
|
|
|
pub fn total_allocations(&self) -> u64 { |
|
|
*self.span.total_allocations.get_or_init(|| { |
|
|
self.children() |
|
|
.map(|child| child.total_allocations()) |
|
|
.reduce(|a, b| a + b) |
|
|
.unwrap_or_default() |
|
|
+ self.self_allocations() |
|
|
}) |
|
|
} |
|
|
|
|
|
pub fn total_deallocations(&self) -> u64 { |
|
|
*self.span.total_deallocations.get_or_init(|| { |
|
|
self.children() |
|
|
.map(|child| child.total_deallocations()) |
|
|
.reduce(|a, b| a + b) |
|
|
.unwrap_or_default() |
|
|
+ self.self_deallocations() |
|
|
}) |
|
|
} |
|
|
|
|
|
pub fn total_persistent_allocations(&self) -> u64 { |
|
|
*self.span.total_persistent_allocations.get_or_init(|| { |
|
|
self.children() |
|
|
.map(|child| child.total_persistent_allocations()) |
|
|
.reduce(|a, b| a + b) |
|
|
.unwrap_or_default() |
|
|
+ self.self_persistent_allocations() |
|
|
}) |
|
|
} |
|
|
|
|
|
pub fn total_allocation_count(&self) -> u64 { |
|
|
*self.span.total_allocation_count.get_or_init(|| { |
|
|
self.children() |
|
|
.map(|child| child.total_allocation_count()) |
|
|
.reduce(|a, b| a + b) |
|
|
.unwrap_or_default() |
|
|
+ self.self_allocation_count() |
|
|
}) |
|
|
} |
|
|
|
|
|
pub fn total_span_count(&self) -> u64 { |
|
|
*self.span.total_span_count.get_or_init(|| { |
|
|
self.children() |
|
|
.map(|child| child.total_span_count()) |
|
|
.reduce(|a, b| a + b) |
|
|
.unwrap_or_default() |
|
|
+ 1 |
|
|
}) |
|
|
} |
|
|
|
|
|
pub fn corrected_self_time(&self) -> Timestamp { |
|
|
let store = self.store; |
|
|
*self.time_data().corrected_self_time.get_or_init(|| { |
|
|
let mut self_time = self |
|
|
.span |
|
|
.events |
|
|
.par_iter() |
|
|
.filter_map(|event| { |
|
|
if let SpanEvent::SelfTime { start, end } = event { |
|
|
let duration = *end - *start; |
|
|
if !duration.is_zero() { |
|
|
store.set_max_self_time_lookup(*end); |
|
|
let corrected_time = |
|
|
store.self_time_tree.as_ref().map_or(duration, |tree| { |
|
|
tree.lookup_range_corrected_time(*start, *end) |
|
|
}); |
|
|
return Some(corrected_time); |
|
|
} |
|
|
} |
|
|
None |
|
|
}) |
|
|
.sum(); |
|
|
if self.children().next().is_none() { |
|
|
self_time = max(self_time, Timestamp::from_value(1)); |
|
|
} |
|
|
self_time |
|
|
}) |
|
|
} |
|
|
|
|
|
pub fn corrected_total_time(&self) -> Timestamp { |
|
|
*self.time_data().corrected_total_time.get_or_init(|| { |
|
|
self.children_par() |
|
|
.map(|child| child.corrected_total_time()) |
|
|
.sum::<Timestamp>() |
|
|
+ self.corrected_self_time() |
|
|
}) |
|
|
} |
|
|
|
|
|
pub fn max_depth(&self) -> u32 { |
|
|
*self.span.max_depth.get_or_init(|| { |
|
|
self.children() |
|
|
.map(|child| child.max_depth() + 1) |
|
|
.max() |
|
|
.unwrap_or_default() |
|
|
}) |
|
|
} |
|
|
|
|
|
pub fn graph(&self) -> impl Iterator<Item = SpanGraphEventRef<'a>> + '_ { |
|
|
self.extra() |
|
|
.graph |
|
|
.get_or_init(|| { |
|
|
struct Entry<'a> { |
|
|
span: SpanRef<'a>, |
|
|
recursive: Vec<SpanIndex>, |
|
|
} |
|
|
let entries = self |
|
|
.children_par() |
|
|
.map(|span| { |
|
|
let name = span.group_name(); |
|
|
let mut recursive = Vec::new(); |
|
|
let mut queue = VecDeque::with_capacity(0); |
|
|
for nested_child in span.children() { |
|
|
let nested_name = nested_child.group_name(); |
|
|
if name == nested_name { |
|
|
recursive.push(nested_child.index()); |
|
|
queue.push_back(nested_child); |
|
|
} |
|
|
} |
|
|
while let Some(child) = queue.pop_front() { |
|
|
for nested_child in child.children() { |
|
|
let nested_name = nested_child.group_name(); |
|
|
if name == nested_name { |
|
|
recursive.push(nested_child.index()); |
|
|
queue.push_back(nested_child); |
|
|
} |
|
|
} |
|
|
} |
|
|
Entry { span, recursive } |
|
|
}) |
|
|
.collect_vec_list(); |
|
|
let mut map: GroupNameToDirectAndRecusiveSpans = FxIndexMap::default(); |
|
|
for Entry { |
|
|
span, |
|
|
mut recursive, |
|
|
} in entries.into_iter().flatten() |
|
|
{ |
|
|
let name = span.group_name(); |
|
|
let (list, recursive_list) = map.entry(name).or_default(); |
|
|
list.push(span.index()); |
|
|
recursive_list.append(&mut recursive); |
|
|
} |
|
|
event_map_to_list(map) |
|
|
}) |
|
|
.iter() |
|
|
.map(|event| match event { |
|
|
SpanGraphEvent::SelfTime { duration } => SpanGraphEventRef::SelfTime { |
|
|
duration: *duration, |
|
|
}, |
|
|
SpanGraphEvent::Child { child } => SpanGraphEventRef::Child { |
|
|
graph: SpanGraphRef { |
|
|
graph: child.clone(), |
|
|
store: self.store, |
|
|
}, |
|
|
}, |
|
|
}) |
|
|
} |
|
|
|
|
|
pub fn bottom_up(self) -> impl Iterator<Item = SpanBottomUpRef<'a>> { |
|
|
self.extra() |
|
|
.bottom_up |
|
|
.get_or_init(|| build_bottom_up_graph([self].into_iter())) |
|
|
.iter() |
|
|
.map(move |bottom_up| SpanBottomUpRef { |
|
|
bottom_up: bottom_up.clone(), |
|
|
store: self.store, |
|
|
}) |
|
|
} |
|
|
|
|
|
pub fn search(&self, query: &str) -> impl Iterator<Item = SpanRef<'a>> { |
|
|
let mut query_items = query.split(",").map(str::trim); |
|
|
let index = self.search_index(); |
|
|
let mut result = FxHashSet::default(); |
|
|
let query = query_items.next().unwrap(); |
|
|
for (key, spans) in index { |
|
|
if key.contains(query) { |
|
|
result.extend(spans.iter().copied()); |
|
|
} |
|
|
} |
|
|
for query in query_items { |
|
|
let mut and_result = FxHashSet::default(); |
|
|
for (key, spans) in index { |
|
|
if key.contains(query) { |
|
|
and_result.extend(spans.iter().copied()); |
|
|
} |
|
|
} |
|
|
result.retain(|index| and_result.contains(index)); |
|
|
} |
|
|
let store = self.store; |
|
|
result.into_iter().map(move |index| SpanRef { |
|
|
span: &store.spans[index.get()], |
|
|
store, |
|
|
index: index.get(), |
|
|
}) |
|
|
} |
|
|
|
|
|
fn search_index(&self) -> &HashMap<String, Vec<SpanIndex>> { |
|
|
self.extra().search_index.get_or_init(|| { |
|
|
let mut all_spans = Vec::new(); |
|
|
all_spans.push(self.index); |
|
|
let mut i = 0; |
|
|
while i < all_spans.len() { |
|
|
let index = all_spans[i]; |
|
|
let span = SpanRef { |
|
|
span: &self.store.spans[index], |
|
|
store: self.store, |
|
|
index, |
|
|
}; |
|
|
for child in span.children() { |
|
|
all_spans.push(child.index); |
|
|
} |
|
|
i += 1; |
|
|
} |
|
|
|
|
|
enum SpanOrMap<'a> { |
|
|
Span(SpanRef<'a>), |
|
|
Map(HashMap<String, Vec<SpanIndex>>), |
|
|
} |
|
|
|
|
|
fn add_span_to_map<'a>(index: &mut HashMap<String, Vec<SpanIndex>>, span: SpanRef<'a>) { |
|
|
if !span.is_root() { |
|
|
let (cat, name) = span.nice_name(); |
|
|
if !cat.is_empty() { |
|
|
index |
|
|
.raw_entry_mut() |
|
|
.from_key(cat) |
|
|
.and_modify(|_, v| v.push(span.index())) |
|
|
.or_insert_with(|| (cat.to_string(), vec![span.index()])); |
|
|
} |
|
|
if !name.is_empty() { |
|
|
index |
|
|
.raw_entry_mut() |
|
|
.from_key(name) |
|
|
.and_modify(|_, v| v.push(span.index())) |
|
|
.or_insert_with(|| (format!("name={name}"), vec![span.index()])); |
|
|
} |
|
|
for (name, value) in span.span.args.iter() { |
|
|
index |
|
|
.raw_entry_mut() |
|
|
.from_key(value) |
|
|
.and_modify(|_, v| v.push(span.index())) |
|
|
.or_insert_with(|| (format!("{name}={value}"), vec![span.index()])); |
|
|
} |
|
|
if !span.is_complete() && !span.time_data().ignore_self_time { |
|
|
let name = "incomplete_span"; |
|
|
index |
|
|
.raw_entry_mut() |
|
|
.from_key(name) |
|
|
.and_modify(|_, v| v.push(span.index())) |
|
|
.or_insert_with(|| (name.to_string(), vec![span.index()])); |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
let result = all_spans |
|
|
.into_par_iter() |
|
|
.map(|index| { |
|
|
SpanOrMap::Span(SpanRef { |
|
|
span: &self.store.spans[index], |
|
|
store: self.store, |
|
|
index, |
|
|
}) |
|
|
}) |
|
|
.reduce( |
|
|
|| SpanOrMap::Map(HashMap::default()), |
|
|
|a, b| { |
|
|
let mut map = match a { |
|
|
SpanOrMap::Span(span) => { |
|
|
let mut map = HashMap::default(); |
|
|
add_span_to_map(&mut map, span); |
|
|
map |
|
|
} |
|
|
SpanOrMap::Map(map) => map, |
|
|
}; |
|
|
match b { |
|
|
SpanOrMap::Span(span) => { |
|
|
add_span_to_map(&mut map, span); |
|
|
} |
|
|
SpanOrMap::Map(other_map) => { |
|
|
for (name, value) in other_map { |
|
|
map.entry(name).or_default().extend(value); |
|
|
} |
|
|
} |
|
|
} |
|
|
SpanOrMap::Map(map) |
|
|
}, |
|
|
); |
|
|
match result { |
|
|
SpanOrMap::Span(span) => { |
|
|
let mut map = HashMap::default(); |
|
|
add_span_to_map(&mut map, span); |
|
|
map |
|
|
} |
|
|
SpanOrMap::Map(map) => map, |
|
|
} |
|
|
}) |
|
|
} |
|
|
} |
|
|
|
|
|
impl Debug for SpanRef<'_> { |
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { |
|
|
f.debug_struct("SpanRef") |
|
|
.field("id", &self.id()) |
|
|
.field("name", &self.nice_name()) |
|
|
.field("start", &self.start()) |
|
|
.field("end", &self.end()) |
|
|
.field("is_complete", &self.is_complete()) |
|
|
.field("self_time", &self.self_time()) |
|
|
.field("total_time", &self.total_time()) |
|
|
.field("max_depth", &self.max_depth()) |
|
|
.finish() |
|
|
} |
|
|
} |
|
|
|
|
|
#[allow(dead_code)] |
|
|
#[derive(Copy, Clone)] |
|
|
pub enum SpanEventRef<'a> { |
|
|
SelfTime { start: Timestamp, end: Timestamp }, |
|
|
Child { span: SpanRef<'a> }, |
|
|
} |
|
|
|
