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') 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