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/Cargo.toml | 9 +++ crates/ra_prof/src/lib.rs | 161 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 170 insertions(+) create mode 100644 crates/ra_prof/Cargo.toml create mode 100644 crates/ra_prof/src/lib.rs (limited to 'crates') diff --git a/crates/ra_prof/Cargo.toml b/crates/ra_prof/Cargo.toml new file mode 100644 index 000000000..19ce21783 --- /dev/null +++ b/crates/ra_prof/Cargo.toml @@ -0,0 +1,9 @@ +[package] +edition = "2018" +name = "ra_prof" +version = "0.1.0" +authors = ["rust-analyzer developers"] +publish = false + +[dependencies] +lazy_static = "1.3.0" \ No newline at end of file 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') 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_cli/Cargo.toml | 1 + crates/ra_cli/src/main.rs | 7 +++---- crates/ra_hir/Cargo.toml | 1 + crates/ra_hir/src/nameres.rs | 4 ++-- crates/ra_lsp_server/Cargo.toml | 1 + crates/ra_lsp_server/src/main.rs | 10 ++++++++++ crates/ra_lsp_server/src/main_loop.rs | 7 +++---- crates/ra_prof/src/lib.rs | 6 ++++++ 8 files changed, 27 insertions(+), 10 deletions(-) (limited to 'crates') diff --git a/crates/ra_cli/Cargo.toml b/crates/ra_cli/Cargo.toml index 4c666f556..a92a63257 100644 --- a/crates/ra_cli/Cargo.toml +++ b/crates/ra_cli/Cargo.toml @@ -19,3 +19,4 @@ tools = { path = "../tools" } ra_batch = { path = "../ra_batch" } ra_hir = { path = "../ra_hir" } ra_db = { path = "../ra_db" } +ra_prof = { path = "../ra_prof" } diff --git a/crates/ra_cli/src/main.rs b/crates/ra_cli/src/main.rs index 5285f1f28..c13c7910c 100644 --- a/crates/ra_cli/src/main.rs +++ b/crates/ra_cli/src/main.rs @@ -1,6 +1,6 @@ mod analysis_stats; -use std::{fs, io::Read, path::Path, time::Instant}; +use std::{fs, io::Read, path::Path}; use clap::{App, Arg, SubCommand}; use join_to_string::join; @@ -9,6 +9,7 @@ use ra_ide_api_light::file_structure; use ra_syntax::{SourceFile, TextRange, TreeArc, AstNode}; use tools::collect_tests; use flexi_logger::Logger; +use ra_prof::profile; type Result = ::std::result::Result; @@ -34,13 +35,11 @@ fn main() -> Result<()> { .get_matches(); match matches.subcommand() { ("parse", Some(matches)) => { - let start = Instant::now(); + let _p = profile("parsing"); let file = file()?; - let elapsed = start.elapsed(); if !matches.is_present("no-dump") { println!("{}", file.syntax().debug_dump()); } - eprintln!("parsing: {:?}", elapsed); ::std::mem::forget(file); } ("symbols", _) => { diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml index 501308acc..a2858dad9 100644 --- a/crates/ra_hir/Cargo.toml +++ b/crates/ra_hir/Cargo.toml @@ -19,6 +19,7 @@ ra_db = { path = "../ra_db" } mbe = { path = "../ra_mbe", package = "ra_mbe" } tt = { path = "../ra_tt", package = "ra_tt" } test_utils = { path = "../test_utils" } +ra_prof = {path = "../ra_prof" } [dev-dependencies] flexi_logger = "0.11.0" diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs index d361cf9e6..5ac878c79 100644 --- a/crates/ra_hir/src/nameres.rs +++ b/crates/ra_hir/src/nameres.rs @@ -59,6 +59,7 @@ use rustc_hash::FxHashMap; use ra_arena::{Arena, RawId, impl_arena_id}; use ra_db::{FileId, Edition}; use test_utils::tested_by; +use ra_prof::profile; use crate::{ ModuleDef, Name, Crate, Module, Problem, @@ -197,7 +198,7 @@ enum ReachedFixedPoint { impl CrateDefMap { pub(crate) fn crate_def_map_query(db: &impl DefDatabase, krate: Crate) -> Arc { - let start = std::time::Instant::now(); + let _p = profile("crate_def_map_query"); let def_map = { let edition = krate.edition(db); let mut modules: Arena = Arena::default(); @@ -216,7 +217,6 @@ impl CrateDefMap { } }; let def_map = collector::collect_defs(db, def_map); - log::info!("crate_def_map_query: {:?}", start.elapsed()); Arc::new(def_map) } diff --git a/crates/ra_lsp_server/Cargo.toml b/crates/ra_lsp_server/Cargo.toml index d82410700..bc181e4eb 100644 --- a/crates/ra_lsp_server/Cargo.toml +++ b/crates/ra_lsp_server/Cargo.toml @@ -27,6 +27,7 @@ ra_ide_api = { path = "../ra_ide_api" } ra_arena = { path = "../ra_arena" } gen_lsp_server = { path = "../gen_lsp_server" } ra_project_model = { path = "../ra_project_model" } +ra_prof = { path = "../ra_prof" } [dev-dependencies] tempfile = "3" diff --git a/crates/ra_lsp_server/src/main.rs b/crates/ra_lsp_server/src/main.rs index 5a2905207..eb4091a3d 100644 --- a/crates/ra_lsp_server/src/main.rs +++ b/crates/ra_lsp_server/src/main.rs @@ -3,6 +3,7 @@ use flexi_logger::{Duplicate, Logger}; use gen_lsp_server::{run_server, stdio_transport}; use ra_lsp_server::{Result, InitializationOptions}; +use ra_prof; fn main() -> Result<()> { ::std::env::set_var("RUST_BACKTRACE", "short"); @@ -11,6 +12,15 @@ fn main() -> Result<()> { Ok(ref v) if v == "1" => logger.log_to_file().directory("log").start()?, _ => logger.start()?, }; + let prof_depth = match ::std::env::var("RA_PROFILE_DEPTH") { + Ok(ref d) => d.parse()?, + _ => 0, + }; + let profile_allowed = match ::std::env::var("RA_PROFILE") { + Ok(ref p) => p.split(";").map(String::from).collect(), + _ => Vec::new(), + }; + ra_prof::set_filter(ra_prof::Filter::new(prof_depth, profile_allowed)); log::info!("lifecycle: server started"); match ::std::panic::catch_unwind(main_inner) { Ok(res) => { diff --git a/crates/ra_lsp_server/src/main_loop.rs b/crates/ra_lsp_server/src/main_loop.rs index eecf278a8..82410bee3 100644 --- a/crates/ra_lsp_server/src/main_loop.rs +++ b/crates/ra_lsp_server/src/main_loop.rs @@ -24,6 +24,7 @@ use crate::{ Result, InitializationOptions, }; +use ra_prof::profile; #[derive(Debug, Fail)] #[fail(display = "Language Server request failed with {}. ({})", code, message)] @@ -181,7 +182,7 @@ fn main_loop_inner( recv(libdata_receiver) -> data => Event::Lib(data.unwrap()) }; log::info!("loop_turn = {:?}", event); - let start = std::time::Instant::now(); + let _p = profile("loop_turn"); let mut state_changed = false; match event { Event::Task(task) => on_task(task, msg_sender, pending_requests), @@ -235,10 +236,9 @@ fn main_loop_inner( in_flight_libraries += 1; let sender = libdata_sender.clone(); pool.execute(move || { - let start = ::std::time::Instant::now(); log::info!("indexing {:?} ... ", root); + let _p = profile(&format!("indexed {:?}", root)); let data = LibraryData::prepare(root, files); - log::info!("indexed {:?} {:?}", start.elapsed(), root); sender.send(data).unwrap(); }); } @@ -266,7 +266,6 @@ fn main_loop_inner( subs.subscriptions(), ) } - log::info!("loop_turn = {:?}", start.elapsed()); } } 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