use std::env;
use std::path::PathBuf;
-use std::process::Command;
+use std::process::{Child, Command};
use std::str::FromStr;
use std::time::Instant;
cmd.arg("-Z").arg("force-unstable-if-unmarked");
}
+ let is_test = args.iter().any(|a| a == "--test");
if verbose > 1 {
+ let rust_env_vars =
+ env::vars().filter(|(k, _)| k.starts_with("RUST") || k.starts_with("CARGO"));
+ let prefix = if is_test { "[RUSTC-SHIM] rustc --test" } else { "[RUSTC-SHIM] rustc" };
+ let prefix = match crate_name {
+ Some(crate_name) => format!("{} {}", prefix, crate_name),
+ None => prefix.to_string(),
+ };
+ for (i, (k, v)) in rust_env_vars.enumerate() {
+ eprintln!("{} env[{}]: {:?}={:?}", prefix, i, k, v);
+ }
+ eprintln!("{} working directory: {}", prefix, env::current_dir().unwrap().display());
eprintln!(
- "rustc command: {:?}={:?} {:?}",
+ "{} command: {:?}={:?} {:?}",
+ prefix,
bootstrap::util::dylib_path_var(),
env::join_paths(&dylib_path).unwrap(),
cmd,
);
- eprintln!("sysroot: {:?}", sysroot);
- eprintln!("libdir: {:?}", libdir);
+ eprintln!("{} sysroot: {:?}", prefix, sysroot);
+ eprintln!("{} libdir: {:?}", prefix, libdir);
}
let start = Instant::now();
- let status = {
+ let (child, status) = {
let errmsg = format!("\nFailed to run:\n{:?}\n-------------", cmd);
- cmd.status().expect(&errmsg)
+ let mut child = cmd.spawn().expect(&errmsg);
+ let status = child.wait().expect(&errmsg);
+ (child, status)
};
- if env::var_os("RUSTC_PRINT_STEP_TIMINGS").is_some() {
+ if env::var_os("RUSTC_PRINT_STEP_TIMINGS").is_some()
+ || env::var_os("RUSTC_PRINT_STEP_RUSAGE").is_some()
+ {
if let Some(crate_name) = crate_name {
let dur = start.elapsed();
- let is_test = args.iter().any(|a| a == "--test");
+ // If the user requested resource usage data, then
+ // include that in addition to the timing output.
+ let rusage_data =
+ env::var_os("RUSTC_PRINT_STEP_RUSAGE").and_then(|_| format_rusage_data(child));
eprintln!(
- "[RUSTC-TIMING] {} test:{} {}.{:03}",
+ "[RUSTC-TIMING] {} test:{} {}.{:03}{}{}",
crate_name,
is_test,
dur.as_secs(),
- dur.subsec_millis()
+ dur.subsec_millis(),
+ if rusage_data.is_some() { " " } else { "" },
+ rusage_data.unwrap_or(String::new()),
);
}
}
}
}
}
+
+#[cfg(all(not(unix), not(windows)))]
+// In the future we can add this for more platforms
+fn format_rusage_data(_child: Child) -> Option<String> {
+ None
+}
+
+#[cfg(windows)]
+fn format_rusage_data(child: Child) -> Option<String> {
+ use std::os::windows::io::AsRawHandle;
+ use winapi::um::{processthreadsapi, psapi, timezoneapi};
+ let handle = child.as_raw_handle();
+ macro_rules! try_bool {
+ ($e:expr) => {
+ if $e != 1 {
+ return None;
+ }
+ };
+ }
+
+ let mut user_filetime = Default::default();
+ let mut user_time = Default::default();
+ let mut kernel_filetime = Default::default();
+ let mut kernel_time = Default::default();
+ let mut memory_counters = psapi::PROCESS_MEMORY_COUNTERS::default();
+
+ unsafe {
+ try_bool!(processthreadsapi::GetProcessTimes(
+ handle,
+ &mut Default::default(),
+ &mut Default::default(),
+ &mut kernel_filetime,
+ &mut user_filetime,
+ ));
+ try_bool!(timezoneapi::FileTimeToSystemTime(&user_filetime, &mut user_time));
+ try_bool!(timezoneapi::FileTimeToSystemTime(&kernel_filetime, &mut kernel_time));
+
+ // Unlike on Linux with RUSAGE_CHILDREN, this will only return memory information for the process
+ // with the given handle and none of that process's children.
+ try_bool!(psapi::GetProcessMemoryInfo(
+ handle as _,
+ &mut memory_counters as *mut _ as _,
+ std::mem::size_of::<psapi::PROCESS_MEMORY_COUNTERS_EX>() as u32,
+ ));
+ }
+
+ // Guide on interpreting these numbers:
+ // https://docs.microsoft.com/en-us/windows/win32/psapi/process-memory-usage-information
+ let peak_working_set = memory_counters.PeakWorkingSetSize / 1024;
+ let peak_page_file = memory_counters.PeakPagefileUsage / 1024;
+ let peak_paged_pool = memory_counters.QuotaPeakPagedPoolUsage / 1024;
+ let peak_nonpaged_pool = memory_counters.QuotaPeakNonPagedPoolUsage / 1024;
+ Some(format!(
+ "user: {USER_SEC}.{USER_USEC:03} \
+ sys: {SYS_SEC}.{SYS_USEC:03} \
+ peak working set (kb): {PEAK_WORKING_SET} \
+ peak page file usage (kb): {PEAK_PAGE_FILE} \
+ peak paged pool usage (kb): {PEAK_PAGED_POOL} \
+ peak non-paged pool usage (kb): {PEAK_NONPAGED_POOL} \
+ page faults: {PAGE_FAULTS}",
+ USER_SEC = user_time.wSecond + (user_time.wMinute * 60),
+ USER_USEC = user_time.wMilliseconds,
+ SYS_SEC = kernel_time.wSecond + (kernel_time.wMinute * 60),
+ SYS_USEC = kernel_time.wMilliseconds,
+ PEAK_WORKING_SET = peak_working_set,
+ PEAK_PAGE_FILE = peak_page_file,
+ PEAK_PAGED_POOL = peak_paged_pool,
+ PEAK_NONPAGED_POOL = peak_nonpaged_pool,
+ PAGE_FAULTS = memory_counters.PageFaultCount,
+ ))
+}
+
+#[cfg(unix)]
+/// Tries to build a string with human readable data for several of the rusage
+/// fields. Note that we are focusing mainly on data that we believe to be
+/// supplied on Linux (the `rusage` struct has other fields in it but they are
+/// currently unsupported by Linux).
+fn format_rusage_data(_child: Child) -> Option<String> {
+ let rusage: libc::rusage = unsafe {
+ let mut recv = std::mem::zeroed();
+ // -1 is RUSAGE_CHILDREN, which means to get the rusage for all children
+ // (and grandchildren, etc) processes that have respectively terminated
+ // and been waited for.
+ let retval = libc::getrusage(-1, &mut recv);
+ if retval != 0 {
+ return None;
+ }
+ recv
+ };
+ // Mac OS X reports the maxrss in bytes, not kb.
+ let divisor = if env::consts::OS == "macos" { 1024 } else { 1 };
+ let maxrss = rusage.ru_maxrss + (divisor - 1) / divisor;
+
+ let mut init_str = format!(
+ "user: {USER_SEC}.{USER_USEC:03} \
+ sys: {SYS_SEC}.{SYS_USEC:03} \
+ max rss (kb): {MAXRSS}",
+ USER_SEC = rusage.ru_utime.tv_sec,
+ USER_USEC = rusage.ru_utime.tv_usec,
+ SYS_SEC = rusage.ru_stime.tv_sec,
+ SYS_USEC = rusage.ru_stime.tv_usec,
+ MAXRSS = maxrss
+ );
+
+ // The remaining rusage stats vary in platform support. So we treat
+ // uniformly zero values in each category as "not worth printing", since it
+ // either means no events of that type occurred, or that the platform
+ // does not support it.
+
+ let minflt = rusage.ru_minflt;
+ let majflt = rusage.ru_majflt;
+ if minflt != 0 || majflt != 0 {
+ init_str.push_str(&format!(" page reclaims: {} page faults: {}", minflt, majflt));
+ }
+
+ let inblock = rusage.ru_inblock;
+ let oublock = rusage.ru_oublock;
+ if inblock != 0 || oublock != 0 {
+ init_str.push_str(&format!(" fs block inputs: {} fs block outputs: {}", inblock, oublock));
+ }
+
+ let nvcsw = rusage.ru_nvcsw;
+ let nivcsw = rusage.ru_nivcsw;
+ if nvcsw != 0 || nivcsw != 0 {
+ init_str.push_str(&format!(
+ " voluntary ctxt switches: {} involuntary ctxt switches: {}",
+ nvcsw, nivcsw
+ ));
+ }
+
+ return Some(init_str);
+}
projects / rustc.git / blobdiff