nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-27 01:04:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

Set codegen thread names

Browse Source 
For example, gdb:

```
(gdb) info threads
  Id   Target Id                                          Frame
  1    Thread 0x7fffefa7ec40 (LWP 2905) "rustc"           __pthread_clockjoin_ex (threadid=140737214134016, thread_return=0x0, clockid=<optimized out>, abstime=<optimized out>, block=<optimized out>)
    at pthread_join_common.c:145
  2    Thread 0x7fffefa7b700 (LWP 2957) "rustc"           0x00007ffff125eaa8 in llvm::X86_MC::initLLVMToSEHAndCVRegMapping(llvm::MCRegisterInfo*) ()
   from /home/wesley/.rustup/toolchains/stage1/lib/librustc_driver-f866439e29074957.so
  3    Thread 0x7fffeef0f700 (LWP 3116) "rustc"           futex_wait_cancelable (private=0, expected=0, futex_word=0x7fffe8602ac8) at ../sysdeps/nptl/futex-internal.h:183
* 4    Thread 0x7fffeed0e700 (LWP 3123) "rustc"           rustc_codegen_ssa:🔙:write::spawn_work (cgcx=..., work=...) at /home/wesley/code/rust/rust/compiler/rustc_codegen_ssa/src/back/write.rs:1573
  6    Thread 0x7fffe113b700 (LWP 3150) "opt foof.7rcbfp" 0x00007ffff2940e62 in llvm::CallGraph::populateCallGraphNode(llvm::CallGraphNode*) ()
   from /home/wesley/.rustup/toolchains/stage1/lib/librustc_driver-f866439e29074957.so
  8    Thread 0x7fffe0d39700 (LWP 3158) "opt foof.7rcbfp" 0x00007fffefe8998e in malloc_consolidate (av=av@entry=0x7ffe2c000020) at malloc.c:4492
  9    Thread 0x7fffe0f3a700 (LWP 3162) "opt foof.7rcbfp" 0x00007fffefef27c4 in __libc_open64 (file=0x7fffe0f38608 "foof.foof.7rcbfp3g-cgu.6.rcgu.o", oflag=524865) at ../sysdeps/unix/sysv/linux/open64.c:48
(gdb)
```
This commit is contained in:
Wesley Wiser 2021-02-18 14:27:37 -05:00
parent 0ab7c1d56f
commit 9d3739d9ce
1 changed files with 77 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

124
compiler/rustc_codegen_ssa/src/back/write.rs
View File

@ -712,6 +712,33 @@ impl<B: WriteBackendMethods> WorkItem<B> {
} }
} }
} }
/// Generate a short description of this work item suitable for use as a thread name.
fn short_description(&self) -> String {
// `pthread_setname()` on *nix is limited to 15 characters and longer names are ignored.
// Use very short descriptions in this case to maximize the space available for the module name.
// Windows does not have that limitation so use slightly more descriptive names there.
match self {
WorkItem::Optimize(m) => {
#[cfg(windows)]
return format!("optimize module {}", m.name);
#[cfg(not(windows))]
return format!("opt {}", m.name);
}
WorkItem::CopyPostLtoArtifacts(m) => {
#[cfg(windows)]
return format!("copy LTO artifacts for {}", m.name);
#[cfg(not(windows))]
return format!("copy {}", m.name);
}
WorkItem::LTO(m) => {
#[cfg(windows)]
return format!("LTO module {}", m.name());
#[cfg(not(windows))]
return format!("LTO {}", m.name());
}
}
}
} }
enum WorkItemResult<B: WriteBackendMethods> { enum WorkItemResult<B: WriteBackendMethods> {
@ -1609,56 +1636,59 @@ fn start_executing_work<B: ExtraBackendMethods>(
pub struct WorkerFatalError; pub struct WorkerFatalError;
fn spawn_work<B: ExtraBackendMethods>(cgcx: CodegenContext<B>, work: WorkItem<B>) { fn spawn_work<B: ExtraBackendMethods>(cgcx: CodegenContext<B>, work: WorkItem<B>) {
thread::spawn(move || { let builder = thread::Builder::new().name(work.short_description());
// Set up a destructor which will fire off a message that we're done as builder
// we exit. .spawn(move || {
struct Bomb<B: ExtraBackendMethods> { // Set up a destructor which will fire off a message that we're done as
coordinator_send: Sender<Box<dyn Any + Send>>, // we exit.
result: Option<Result<WorkItemResult<B>, FatalError>>, struct Bomb<B: ExtraBackendMethods> {
worker_id: usize, coordinator_send: Sender<Box<dyn Any + Send>>,
} result: Option<Result<WorkItemResult<B>, FatalError>>,
impl<B: ExtraBackendMethods> Drop for Bomb<B> { worker_id: usize,
fn drop(&mut self) { }
let worker_id = self.worker_id; impl<B: ExtraBackendMethods> Drop for Bomb<B> {
let msg = match self.result.take() { fn drop(&mut self) {
Some(Ok(WorkItemResult::Compiled(m))) => { let worker_id = self.worker_id;
Message::Done::<B> { result: Ok(m), worker_id } let msg = match self.result.take() {
} Some(Ok(WorkItemResult::Compiled(m))) => {
Some(Ok(WorkItemResult::NeedsLink(m))) => { Message::Done::<B> { result: Ok(m), worker_id }
Message::NeedsLink::<B> { module: m, worker_id } }
} Some(Ok(WorkItemResult::NeedsLink(m))) => {
Some(Ok(WorkItemResult::NeedsFatLTO(m))) => { Message::NeedsLink::<B> { module: m, worker_id }
Message::NeedsFatLTO::<B> { result: m, worker_id } }
} Some(Ok(WorkItemResult::NeedsFatLTO(m))) => {
Some(Ok(WorkItemResult::NeedsThinLTO(name, thin_buffer))) => { Message::NeedsFatLTO::<B> { result: m, worker_id }
Message::NeedsThinLTO::<B> { name, thin_buffer, worker_id } }
} Some(Ok(WorkItemResult::NeedsThinLTO(name, thin_buffer))) => {
Some(Err(FatalError)) => { Message::NeedsThinLTO::<B> { name, thin_buffer, worker_id }
Message::Done::<B> { result: Err(Some(WorkerFatalError)), worker_id } }
} Some(Err(FatalError)) => {
None => Message::Done::<B> { result: Err(None), worker_id }, Message::Done::<B> { result: Err(Some(WorkerFatalError)), worker_id }
}; }
drop(self.coordinator_send.send(Box::new(msg))); None => Message::Done::<B> { result: Err(None), worker_id },
};
drop(self.coordinator_send.send(Box::new(msg)));
}
} }
}
let mut bomb = Bomb::<B> { let mut bomb = Bomb::<B> {
coordinator_send: cgcx.coordinator_send.clone(), coordinator_send: cgcx.coordinator_send.clone(),
result: None, result: None,
worker_id: cgcx.worker, worker_id: cgcx.worker,
}; };
// Execute the work itself, and if it finishes successfully then flag // Execute the work itself, and if it finishes successfully then flag
// ourselves as a success as well. // ourselves as a success as well.
// //
// Note that we ignore any `FatalError` coming out of `execute_work_item`, // Note that we ignore any `FatalError` coming out of `execute_work_item`,
// as a diagnostic was already sent off to the main thread - just // as a diagnostic was already sent off to the main thread - just
// surface that there was an error in this worker. // surface that there was an error in this worker.
bomb.result = { bomb.result = {
let _prof_timer = work.start_profiling(&cgcx); let _prof_timer = work.start_profiling(&cgcx);
Some(execute_work_item(&cgcx, work)) Some(execute_work_item(&cgcx, work))
}; };
}); })
.expect("failed to spawn thread");
} }
enum SharedEmitterMessage { enum SharedEmitterMessage {