From 58224bc65910ae94cff81b2cdcd74a435498f5f2 Mon Sep 17 00:00:00 2001 From: Sergey Parilin Date: Wed, 27 Mar 2019 18:09:51 +0300 Subject: profiling crate first draft --- crates/ra_prof/src/lib.rs | 161 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 161 insertions(+) create mode 100644 crates/ra_prof/src/lib.rs (limited to 'crates/ra_prof/src') diff --git a/crates/ra_prof/src/lib.rs b/crates/ra_prof/src/lib.rs new file mode 100644 index 000000000..55ad45fb7 --- /dev/null +++ b/crates/ra_prof/src/lib.rs @@ -0,0 +1,161 @@ +extern crate lazy_static; + +use std::cell::RefCell; +use std::time; +use std::fmt; +use std::mem; +use std::io::{stderr, StderrLock, Write}; +use std::iter::repeat; +use std::collections::{HashSet}; +use std::default::Default; +use std::iter::FromIterator; +use std::sync::RwLock; + +use lazy_static::lazy_static; + +type Message = (usize, u64, String); + +pub struct Profiler { + desc: String, +} + +pub struct Filter { + depth: usize, + allowed: Vec, +} + +struct ProfileStack { + starts: Vec, + messages: Vec, + filter_data: FilterData, +} + +impl ProfileStack { + fn new() -> ProfileStack { + ProfileStack { starts: Vec::new(), messages: Vec::new(), filter_data: Default::default() } + } +} + +#[derive(Default)] +struct FilterData { + depth: usize, + version: usize, + allowed: HashSet, +} + +impl Clone for FilterData { + fn clone(&self) -> FilterData { + let set = HashSet::from_iter(self.allowed.iter().cloned()); + FilterData { depth: self.depth, allowed: set, version: self.version } + } +} + +lazy_static! { + static ref FILTER: RwLock = RwLock::new(Default::default()); +} + +thread_local!(static PROFILE_STACK: RefCell = RefCell::new(ProfileStack::new())); + +pub fn set_filter(f: Filter) { + let mut old = FILTER.write().unwrap(); + let set = HashSet::from_iter(f.allowed.iter().cloned()); + let filter_data = FilterData { depth: f.depth, allowed: set, version: old.version + 1 }; + *old = filter_data; +} + +pub fn profile(desc: T) -> Profiler { + PROFILE_STACK.with(|stack| { + let mut stack = stack.borrow_mut(); + if stack.starts.len() == 0 { + match FILTER.try_read() { + Ok(f) => { + if f.version > stack.filter_data.version { + stack.filter_data = f.clone(); + } + } + Err(_) => (), + }; + } + let desc_str = desc.to_string(); + if desc_str.is_empty() { + Profiler { desc: desc_str } + } else if stack.starts.len() < stack.filter_data.depth + && stack.filter_data.allowed.contains(&desc_str) + { + stack.starts.push(time::Instant::now()); + Profiler { desc: desc_str } + } else { + Profiler { desc: String::new() } + } + }) +} + +impl Drop for Profiler { + fn drop(&mut self) { + if self.desc.is_empty() { + return; + } + PROFILE_STACK.with(|stack| { + let mut stack = stack.borrow_mut(); + let start = stack.starts.pop().unwrap(); + let duration = start.elapsed(); + let duration_ms = duration.as_secs() * 1000 + u64::from(duration.subsec_millis()); + let stack_len = stack.starts.len(); + let msg = (stack_len, duration_ms, mem::replace(&mut self.desc, String::new())); + stack.messages.push(msg); + if stack_len == 0 { + let stdout = stderr(); + print(0, &stack.messages, 1, &mut stdout.lock()); + stack.messages.clear(); + } + }); + } +} + +fn print(lvl: usize, msgs: &[Message], enabled: usize, stdout: &mut StderrLock<'_>) { + if lvl > enabled { + return; + } + let mut last = 0; + for (i, &(l, time, ref msg)) in msgs.iter().enumerate() { + if l != lvl { + continue; + } + writeln!( + stdout, + "{} {:6}ms - {}", + repeat(" ").take(lvl + 1).collect::(), + time, + msg + ) + .expect("printing profiling info to stdout"); + + print(lvl + 1, &msgs[last..i], enabled, stdout); + last = i; + } +} + +#[cfg(test)] +mod tests { + + use super::profile; + use super::set_filter; + use super::Filter; + + #[test] + fn test_basic_profile() { + let s = vec!["profile1".to_string(), "profile2".to_string()]; + let f = Filter { depth: 2, allowed: s }; + set_filter(f); + profiling_function1(); + } + + fn profiling_function1() { + let _p = profile("profile1"); + profiling_function2(); + } + + fn profiling_function2() { + let _p = profile("profile2"); + } +} -- cgit v1.2.3 From ef02c3c038812897cd96789fa35770e4215d27e8 Mon Sep 17 00:00:00 2001 From: Sergey Parilin Date: Fri, 29 Mar 2019 15:34:05 +0300 Subject: some PR issues fixed --- crates/ra_prof/src/lib.rs | 150 +++++++++++++++++++++------------------------- 1 file changed, 68 insertions(+), 82 deletions(-) (limited to 'crates/ra_prof/src') diff --git a/crates/ra_prof/src/lib.rs b/crates/ra_prof/src/lib.rs index 55ad45fb7..0107f7de9 100644 --- a/crates/ra_prof/src/lib.rs +++ b/crates/ra_prof/src/lib.rs @@ -1,22 +1,50 @@ -extern crate lazy_static; - use std::cell::RefCell; -use std::time; -use std::fmt; +use std::time::{Duration, Instant}; use std::mem; -use std::io::{stderr, StderrLock, Write}; +use std::io::{stderr, Write}; use std::iter::repeat; use std::collections::{HashSet}; use std::default::Default; use std::iter::FromIterator; use std::sync::RwLock; - use lazy_static::lazy_static; -type Message = (usize, u64, String); +pub fn set_filter(f: Filter) { + let set = HashSet::from_iter(f.allowed.iter().cloned()); + let mut old = FILTER.write().unwrap(); + let filter_data = FilterData { depth: f.depth, allowed: set, version: old.version + 1 }; + *old = filter_data; +} + +pub fn profile(desc: &str) -> Profiler { + PROFILE_STACK.with(|stack| { + let mut stack = stack.borrow_mut(); + if stack.starts.len() == 0 { + match FILTER.try_read() { + Ok(f) => { + if f.version > stack.filter_data.version { + stack.filter_data = f.clone(); + } + } + Err(_) => (), + }; + } + let desc_str = desc.to_string(); + if desc_str.is_empty() { + Profiler { desc: None } + } else if stack.starts.len() < stack.filter_data.depth + && stack.filter_data.allowed.contains(&desc_str) + { + stack.starts.push(Instant::now()); + Profiler { desc: Some(desc_str) } + } else { + Profiler { desc: None } + } + }) +} pub struct Profiler { - desc: String, + desc: Option, } pub struct Filter { @@ -25,112 +53,70 @@ pub struct Filter { } struct ProfileStack { - starts: Vec, + starts: Vec, messages: Vec, filter_data: FilterData, } +struct Message { + level: usize, + duration: Duration, + message: String, +} + impl ProfileStack { fn new() -> ProfileStack { ProfileStack { starts: Vec::new(), messages: Vec::new(), filter_data: Default::default() } } } -#[derive(Default)] +#[derive(Default, Clone)] struct FilterData { depth: usize, version: usize, allowed: HashSet, } -impl Clone for FilterData { - fn clone(&self) -> FilterData { - let set = HashSet::from_iter(self.allowed.iter().cloned()); - FilterData { depth: self.depth, allowed: set, version: self.version } - } -} - lazy_static! { static ref FILTER: RwLock = RwLock::new(Default::default()); } thread_local!(static PROFILE_STACK: RefCell = RefCell::new(ProfileStack::new())); -pub fn set_filter(f: Filter) { - let mut old = FILTER.write().unwrap(); - let set = HashSet::from_iter(f.allowed.iter().cloned()); - let filter_data = FilterData { depth: f.depth, allowed: set, version: old.version + 1 }; - *old = filter_data; -} - -pub fn profile(desc: T) -> Profiler { - PROFILE_STACK.with(|stack| { - let mut stack = stack.borrow_mut(); - if stack.starts.len() == 0 { - match FILTER.try_read() { - Ok(f) => { - if f.version > stack.filter_data.version { - stack.filter_data = f.clone(); - } - } - Err(_) => (), - }; - } - let desc_str = desc.to_string(); - if desc_str.is_empty() { - Profiler { desc: desc_str } - } else if stack.starts.len() < stack.filter_data.depth - && stack.filter_data.allowed.contains(&desc_str) - { - stack.starts.push(time::Instant::now()); - Profiler { desc: desc_str } - } else { - Profiler { desc: String::new() } - } - }) -} - impl Drop for Profiler { fn drop(&mut self) { - if self.desc.is_empty() { - return; - } - PROFILE_STACK.with(|stack| { - let mut stack = stack.borrow_mut(); - let start = stack.starts.pop().unwrap(); - let duration = start.elapsed(); - let duration_ms = duration.as_secs() * 1000 + u64::from(duration.subsec_millis()); - let stack_len = stack.starts.len(); - let msg = (stack_len, duration_ms, mem::replace(&mut self.desc, String::new())); - stack.messages.push(msg); - if stack_len == 0 { - let stdout = stderr(); - print(0, &stack.messages, 1, &mut stdout.lock()); - stack.messages.clear(); + match self { + Profiler { desc: Some(desc) } => { + PROFILE_STACK.with(|stack| { + let mut stack = stack.borrow_mut(); + let start = stack.starts.pop().unwrap(); + let duration = start.elapsed(); + let level = stack.starts.len(); + let message = mem::replace(desc, String::new()); + stack.messages.push(Message { level, duration, message }); + if level == 0 { + let stdout = stderr(); + print(0, &stack.messages, &mut stdout.lock()); + stack.messages.clear(); + } + }); } - }); + Profiler { desc: None } => (), + } } } -fn print(lvl: usize, msgs: &[Message], enabled: usize, stdout: &mut StderrLock<'_>) { - if lvl > enabled { - return; - } +fn print(lvl: usize, msgs: &[Message], out: &mut impl Write) { let mut last = 0; - for (i, &(l, time, ref msg)) in msgs.iter().enumerate() { + let indent = repeat(" ").take(lvl + 1).collect::(); + for (i, &Message { level: l, duration: dur, message: ref msg }) in msgs.iter().enumerate() { if l != lvl { continue; } - writeln!( - stdout, - "{} {:6}ms - {}", - repeat(" ").take(lvl + 1).collect::(), - time, - msg - ) - .expect("printing profiling info to stdout"); - - print(lvl + 1, &msgs[last..i], enabled, stdout); + writeln!(out, "{} {:6}ms - {}", indent, dur.as_millis(), msg) + .expect("printing profiling info to stdout"); + + print(lvl + 1, &msgs[last..i], out); last = i; } } -- cgit v1.2.3 From 9b73f809596e955216dde24fcf921d6985a1a767 Mon Sep 17 00:00:00 2001 From: Sergey Parilin Date: Tue, 2 Apr 2019 17:52:04 +0300 Subject: PR issuse resolved --- crates/ra_prof/src/lib.rs | 6 ++++++ 1 file changed, 6 insertions(+) (limited to 'crates/ra_prof/src') diff --git a/crates/ra_prof/src/lib.rs b/crates/ra_prof/src/lib.rs index 0107f7de9..abddff960 100644 --- a/crates/ra_prof/src/lib.rs +++ b/crates/ra_prof/src/lib.rs @@ -52,6 +52,12 @@ pub struct Filter { allowed: Vec, } +impl Filter { + pub fn new(depth: usize, allowed: Vec) -> Filter { + Filter { depth, allowed } + } +} + struct ProfileStack { starts: Vec, messages: Vec, -- cgit v1.2.3