mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use CmdArgs pattern for bench & analysis stats

Browse Source
This commit is contained in:
Aleksey Kladov 2020-07-30 22:38:24 +02:00
parent be49547b44
commit cd9f863b01
5 changed files with 309 additions and 335 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
crates/rust-analyzer/src/bin/args.rs
View File

@ -8,7 +8,7 @@
use anyhow::{bail, Result};
use pico_args::Arguments;
use ra_ssr::{SsrPattern, SsrRule};
use rust_analyzer::cli::{BenchWhat, Position, Verbosity};
use rust_analyzer::cli::{AnalysisStatsCmd, BenchCmd, BenchWhat, Position, Verbosity};
use vfs::AbsPathBuf;
pub(crate) struct Args {
@ -24,23 +24,8 @@ pub(crate) enum Command {
Highlight {
rainbow: bool,
},
Stats {
randomize: bool,
parallel: bool,
memory_usage: bool,
only: Option<String>,
with_deps: bool,
path: PathBuf,
load_output_dirs: bool,
with_proc_macro: bool,
},
Bench {
memory_usage: bool,
path: PathBuf,
what: BenchWhat,
load_output_dirs: bool,
with_proc_macro: bool,
},
AnalysisStats(AnalysisStatsCmd),
Bench(BenchCmd),
Diagnostics {
path: PathBuf,
load_output_dirs: bool,
@ -199,7 +184,7 @@ pub(crate) fn parse() -> Result<Result<Args, HelpPrinted>> {
trailing.pop().unwrap().into()
};
Command::Stats {
Command::AnalysisStats(AnalysisStatsCmd {
randomize,
parallel,
memory_usage,
@ -208,7 +193,7 @@ pub(crate) fn parse() -> Result<Result<Args, HelpPrinted>> {
path,
load_output_dirs,
with_proc_macro,
}
})
}
"analysis-bench" => {
if matches.contains(["-h", "--help"]) {
@ -256,7 +241,13 @@ pub(crate) fn parse() -> Result<Result<Args, HelpPrinted>> {
let memory_usage = matches.contains("--memory-usage");
let load_output_dirs = matches.contains("--load-output-dirs");
let with_proc_macro = matches.contains("--with-proc-macro");
Command::Bench { memory_usage, path, what, load_output_dirs, with_proc_macro }
Command::Bench(BenchCmd {
memory_usage,
path,
what,
load_output_dirs,
with_proc_macro,
})
}
"diagnostics" => {
if matches.contains(["-h", "--help"]) {

32
crates/rust-analyzer/src/bin/main.rs
View File

@ -33,36 +33,8 @@ fn main() -> Result<()> {
args::Command::Parse { no_dump } => cli::parse(no_dump)?,
args::Command::Symbols => cli::symbols()?,
args::Command::Highlight { rainbow } => cli::highlight(rainbow)?,
args::Command::Stats {
randomize,
parallel,
memory_usage,
only,
with_deps,
path,
load_output_dirs,
with_proc_macro,
} => cli::analysis_stats(
args.verbosity,
memory_usage,
path.as_ref(),
only.as_ref().map(String::as_ref),
with_deps,
randomize,
parallel,
load_output_dirs,
with_proc_macro,
)?,
args::Command::Bench { memory_usage, path, what, load_output_dirs, with_proc_macro } => {
cli::analysis_bench(
args.verbosity,
path.as_ref(),
what,
memory_usage,
load_output_dirs,
with_proc_macro,
)?
}
args::Command::AnalysisStats(cmd) => cmd.run(args.verbosity)?,
args::Command::Bench(cmd) => cmd.run(args.verbosity)?,
args::Command::Diagnostics { path, load_output_dirs, with_proc_macro, all } => {
cli::diagnostics(path.as_ref(), load_output_dirs, with_proc_macro, all)?
}

4
crates/rust-analyzer/src/cli.rs
View File

@ -14,8 +14,8 @@
use ra_prof::profile;
use ra_syntax::{AstNode, SourceFile};
pub use analysis_bench::{analysis_bench, BenchWhat, Position};
pub use analysis_stats::analysis_stats;
pub use analysis_bench::{BenchCmd, BenchWhat, Position};
pub use analysis_stats::AnalysisStatsCmd;
pub use diagnostics::diagnostics;
pub use load_cargo::load_cargo;
pub use ssr::{apply_ssr_rules, search_for_patterns};

36
crates/rust-analyzer/src/cli/analysis_bench.rs
View File

@ -1,6 +1,6 @@
//! Benchmark operations like highlighting or goto definition.
use std::{env, path::Path, str::FromStr, sync::Arc, time::Instant};
use std::{env, path::PathBuf, str::FromStr, sync::Arc, time::Instant};
use anyhow::{bail, format_err, Result};
use ra_db::{
@ -15,6 +15,14 @@
print_memory_usage,
};
pub struct BenchCmd {
pub path: PathBuf,
pub what: BenchWhat,
pub memory_usage: bool,
pub load_output_dirs: bool,
pub with_proc_macro: bool,
}
pub enum BenchWhat {
Highlight { path: AbsPathBuf },
Complete(Position),
@ -42,23 +50,17 @@ fn from_str(s: &str) -> Result<Self> {
}
}
pub fn analysis_bench(
verbosity: Verbosity,
path: &Path,
what: BenchWhat,
memory_usage: bool,
load_output_dirs: bool,
with_proc_macro: bool,
) -> Result<()> {
impl BenchCmd {
pub fn run(self, verbosity: Verbosity) -> Result<()> {
ra_prof::init();
let start = Instant::now();
eprint!("loading: ");
let (mut host, vfs) = load_cargo(path, load_output_dirs, with_proc_macro)?;
let (mut host, vfs) = load_cargo(&self.path, self.load_output_dirs, self.with_proc_macro)?;
eprintln!("{:?}\n", start.elapsed());
let file_id = {
let path = match &what {
let path = match &self.what {
BenchWhat::Highlight { path } => path,
BenchWhat::Complete(pos) | BenchWhat::GotoDef(pos) => &pos.path,
};
@ -66,7 +68,7 @@ pub fn analysis_bench(
vfs.file_id(&path).ok_or_else(|| format_err!("Can't find {}", path))?
};
match &what {
match &self.what {
BenchWhat::Highlight { .. } => {
let res = do_work(&mut host, file_id, |analysis| {
analysis.diagnostics(file_id, true).unwrap();
@ -77,7 +79,7 @@ pub fn analysis_bench(
}
}
BenchWhat::Complete(pos) | BenchWhat::GotoDef(pos) => {
let is_completion = matches!(what, BenchWhat::Complete(..));
let is_completion = matches!(self.what, BenchWhat::Complete(..));
let offset = host
.analysis()
@ -94,8 +96,9 @@ pub fn analysis_bench(
println!("\n{:#?}", res);
}
} else {
let res =
do_work(&mut host, file_id, |analysis| analysis.goto_definition(file_position));
let res = do_work(&mut host, file_id, |analysis| {
analysis.goto_definition(file_position)
});
if verbosity.is_verbose() {
println!("\n{:#?}", res);
}
@ -103,12 +106,13 @@ pub fn analysis_bench(
}
}
if memory_usage {
if self.memory_usage {
print_memory_usage(host, vfs);
}
Ok(())
}
}
fn do_work<F: Fn(&Analysis) -> T, T>(host: &mut AnalysisHost, file_id: FileId, work: F) -> T {
{

59
crates/rust-analyzer/src/cli/analysis_stats.rs
View File

@ -2,7 +2,7 @@
//! errors.
use std::{
path::Path,
path::PathBuf,
time::{SystemTime, UNIX_EPOCH},
};
@ -39,34 +39,36 @@ fn clone(&self) -> Snap<salsa::Snapshot<DB>> {
}
}
pub fn analysis_stats(
verbosity: Verbosity,
memory_usage: bool,
path: &Path,
only: Option<&str>,
with_deps: bool,
randomize: bool,
parallel: bool,
load_output_dirs: bool,
with_proc_macro: bool,
) -> Result<()> {
pub struct AnalysisStatsCmd {
pub randomize: bool,
pub parallel: bool,
pub memory_usage: bool,
pub only: Option<String>,
pub with_deps: bool,
pub path: PathBuf,
pub load_output_dirs: bool,
pub with_proc_macro: bool,
}
impl AnalysisStatsCmd {
pub fn run(self, verbosity: Verbosity) -> Result<()> {
let mut rng = {
let seed = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_millis() as u64;
Rand32::new(seed)
};
let mut db_load_sw = StopWatch::start().memory(memory_usage);
let (host, vfs) = load_cargo(path, load_output_dirs, with_proc_macro)?;
let mut db_load_sw = self.stop_watch();
let (host, vfs) = load_cargo(&self.path, self.load_output_dirs, self.with_proc_macro)?;
let db = host.raw_database();
eprintln!("Database loaded {}", db_load_sw.elapsed());
let mut analysis_sw = StopWatch::start().memory(memory_usage);
let mut analysis_sw = self.stop_watch();
let mut num_crates = 0;
let mut visited_modules = FxHashSet::default();
let mut visit_queue = Vec::new();
let mut krates = Crate::all(db);
if randomize {
if self.randomize {
shuffle(&mut rng, &mut krates);
}
for krate in krates {
@ -75,13 +77,13 @@ pub fn analysis_stats(
let file_id = file_id.original_file(db);
let source_root = db.file_source_root(file_id);
let source_root = db.source_root(source_root);
if !source_root.is_library || with_deps {
if !source_root.is_library || self.with_deps {
num_crates += 1;
visit_queue.push(module);
}
}
if randomize {
if self.randomize {
shuffle(&mut rng, &mut visit_queue);
}
@ -114,18 +116,18 @@ pub fn analysis_stats(
eprintln!("Total functions: {}", funcs.len());
eprintln!("Item Collection: {}", analysis_sw.elapsed());
if randomize {
if self.randomize {
shuffle(&mut rng, &mut funcs);
}
let mut bar = match verbosity {
Verbosity::Quiet | Verbosity::Spammy => ProgressReport::hidden(),
_ if parallel => ProgressReport::hidden(),
_ if self.parallel => ProgressReport::hidden(),
_ => ProgressReport::new(funcs.len() as u64),
};
if parallel {
let mut inference_sw = StopWatch::start().memory(memory_usage);
if self.parallel {
let mut inference_sw = self.stop_watch();
let snap = Snap(db.snapshot());
funcs
.par_iter()
@ -138,7 +140,7 @@ pub fn analysis_stats(
eprintln!("Parallel Inference: {}", inference_sw.elapsed());
}
let mut inference_sw = StopWatch::start().memory(memory_usage);
let mut inference_sw = self.stop_watch();
bar.tick();
let mut num_exprs = 0;
let mut num_exprs_unknown = 0;
@ -154,7 +156,7 @@ pub fn analysis_stats(
.filter_map(|it| it.name(db))
.chain(Some(f.name(db)))
.join("::");
if let Some(only_name) = only {
if let Some(only_name) = self.only.as_deref() {
if name.to_string() != only_name && full_name != only_name {
continue;
}
@ -192,7 +194,7 @@ pub fn analysis_stats(
num_exprs_partially_unknown += 1;
}
}
if only.is_some() && verbosity.is_spammy() {
if self.only.is_some() && verbosity.is_spammy() {
// in super-verbose mode for just one function, we print every single expression
let (_, sm) = db.body_with_source_map(f_id.into());
let src = sm.expr_syntax(expr_id);
@ -301,13 +303,18 @@ pub fn analysis_stats(
report_metric("total memory", memory.allocated.megabytes() as u64, "MB");
}
if memory_usage {
if self.memory_usage {
print_memory_usage(host, vfs);
}
Ok(())
}
fn stop_watch(&self) -> StopWatch {
StopWatch::start().memory(self.memory_usage)
}
}
fn shuffle<T>(rng: &mut Rand32, slice: &mut [T]) {
for i in 0..slice.len() {
randomize_first(rng, &mut slice[i..]);