4 use std::mem::{self, Discriminant};
7 use std::thread::ThreadId;
10 use crate::ty::query::QueryName;
12 use measureme::{StringId, TimestampKind};
14 /// MmapSerializatioSink is faster on macOS and Linux
15 /// but FileSerializationSink is faster on Windows
17 type Profiler = measureme::Profiler<measureme::MmapSerializationSink>;
19 type Profiler = measureme::Profiler<measureme::FileSerializationSink>;
21 #[derive(Clone, Copy, Debug, PartialEq, Eq, Ord, PartialOrd)]
22 pub enum ProfileCategory {
33 struct EventFilter: u32 {
34 const GENERIC_ACTIVITIES = 1 << 0;
35 const QUERY_PROVIDERS = 1 << 1;
36 const QUERY_CACHE_HITS = 1 << 2;
37 const QUERY_BLOCKED = 1 << 3;
38 const INCR_CACHE_LOADS = 1 << 4;
40 const DEFAULT = Self::GENERIC_ACTIVITIES.bits |
41 Self::QUERY_PROVIDERS.bits |
42 Self::QUERY_BLOCKED.bits |
43 Self::INCR_CACHE_LOADS.bits;
45 // empty() and none() aren't const-fns unfortunately
47 const ALL = !Self::NONE.bits;
51 const EVENT_FILTERS_BY_NAME: &[(&str, EventFilter)] = &[
52 ("none", EventFilter::NONE),
53 ("all", EventFilter::ALL),
54 ("generic-activity", EventFilter::GENERIC_ACTIVITIES),
55 ("query-provider", EventFilter::QUERY_PROVIDERS),
56 ("query-cache-hit", EventFilter::QUERY_CACHE_HITS),
57 ("query-blocked" , EventFilter::QUERY_BLOCKED),
58 ("incr-cache-load", EventFilter::INCR_CACHE_LOADS),
61 fn thread_id_to_u64(tid: ThreadId) -> u64 {
62 unsafe { mem::transmute::<ThreadId, u64>(tid) }
65 pub struct SelfProfiler {
67 event_filter_mask: EventFilter,
68 query_event_kind: StringId,
69 generic_activity_event_kind: StringId,
70 incremental_load_result_event_kind: StringId,
71 query_blocked_event_kind: StringId,
72 query_cache_hit_event_kind: StringId,
77 output_directory: &Path,
78 crate_name: Option<&str>,
79 event_filters: &Option<Vec<String>>
80 ) -> Result<SelfProfiler, Box<dyn Error>> {
81 fs::create_dir_all(output_directory)?;
83 let crate_name = crate_name.unwrap_or("unknown-crate");
84 let filename = format!("{}-{}.rustc_profile", crate_name, process::id());
85 let path = output_directory.join(&filename);
86 let profiler = Profiler::new(&path)?;
88 let query_event_kind = profiler.alloc_string("Query");
89 let generic_activity_event_kind = profiler.alloc_string("GenericActivity");
90 let incremental_load_result_event_kind = profiler.alloc_string("IncrementalLoadResult");
91 let query_blocked_event_kind = profiler.alloc_string("QueryBlocked");
92 let query_cache_hit_event_kind = profiler.alloc_string("QueryCacheHit");
94 let mut event_filter_mask = EventFilter::empty();
96 if let Some(ref event_filters) = *event_filters {
97 let mut unknown_events = vec![];
98 for item in event_filters {
99 if let Some(&(_, mask)) = EVENT_FILTERS_BY_NAME.iter()
100 .find(|&(name, _)| name == item) {
101 event_filter_mask |= mask;
103 unknown_events.push(item.clone());
107 // Warn about any unknown event names
108 if unknown_events.len() > 0 {
109 unknown_events.sort();
110 unknown_events.dedup();
112 warn!("Unknown self-profiler events specified: {}. Available options are: {}.",
113 unknown_events.join(", "),
114 EVENT_FILTERS_BY_NAME.iter()
115 .map(|&(name, _)| name.to_string())
120 event_filter_mask = EventFilter::DEFAULT;
127 generic_activity_event_kind,
128 incremental_load_result_event_kind,
129 query_blocked_event_kind,
130 query_cache_hit_event_kind,
134 fn get_query_name_string_id(query_name: QueryName) -> StringId {
135 let discriminant = unsafe {
136 mem::transmute::<Discriminant<QueryName>, u64>(mem::discriminant(&query_name))
139 StringId::reserved(discriminant as u32)
142 pub fn register_query_name(&self, query_name: QueryName) {
143 let id = SelfProfiler::get_query_name_string_id(query_name);
144 self.profiler.alloc_string_with_reserved_id(id, query_name.as_str());
148 pub fn start_activity(
150 label: impl Into<Cow<'static, str>>,
152 if self.event_filter_mask.contains(EventFilter::GENERIC_ACTIVITIES) {
153 self.record(&label.into(), self.generic_activity_event_kind, TimestampKind::Start);
160 label: impl Into<Cow<'static, str>>,
162 if self.event_filter_mask.contains(EventFilter::GENERIC_ACTIVITIES) {
163 self.record(&label.into(), self.generic_activity_event_kind, TimestampKind::End);
168 pub fn record_query_hit(&self, query_name: QueryName) {
169 if self.event_filter_mask.contains(EventFilter::QUERY_CACHE_HITS) {
170 self.record_query(query_name, self.query_cache_hit_event_kind, TimestampKind::Instant);
175 pub fn start_query(&self, query_name: QueryName) {
176 if self.event_filter_mask.contains(EventFilter::QUERY_PROVIDERS) {
177 self.record_query(query_name, self.query_event_kind, TimestampKind::Start);
182 pub fn end_query(&self, query_name: QueryName) {
183 if self.event_filter_mask.contains(EventFilter::QUERY_PROVIDERS) {
184 self.record_query(query_name, self.query_event_kind, TimestampKind::End);
189 pub fn incremental_load_result_start(&self, query_name: QueryName) {
190 if self.event_filter_mask.contains(EventFilter::INCR_CACHE_LOADS) {
193 self.incremental_load_result_event_kind,
200 pub fn incremental_load_result_end(&self, query_name: QueryName) {
201 if self.event_filter_mask.contains(EventFilter::INCR_CACHE_LOADS) {
204 self.incremental_load_result_event_kind,
211 pub fn query_blocked_start(&self, query_name: QueryName) {
212 if self.event_filter_mask.contains(EventFilter::QUERY_BLOCKED) {
213 self.record_query(query_name, self.query_blocked_event_kind, TimestampKind::Start);
218 pub fn query_blocked_end(&self, query_name: QueryName) {
219 if self.event_filter_mask.contains(EventFilter::QUERY_BLOCKED) {
220 self.record_query(query_name, self.query_blocked_event_kind, TimestampKind::End);
225 fn record(&self, event_id: &str, event_kind: StringId, timestamp_kind: TimestampKind) {
226 let thread_id = thread_id_to_u64(std::thread::current().id());
228 let event_id = self.profiler.alloc_string(event_id);
229 self.profiler.record_event(event_kind, event_id, thread_id, timestamp_kind);
235 query_name: QueryName,
236 event_kind: StringId,
237 timestamp_kind: TimestampKind,
239 let dep_node_name = SelfProfiler::get_query_name_string_id(query_name);
241 let thread_id = thread_id_to_u64(std::thread::current().id());
243 self.profiler.record_event(event_kind, dep_node_name, thread_id, timestamp_kind);