bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Remove tx_to_llvm_workers from TyCtxt

Browse source 
This can be kept within the codegen backend crates entirely
This commit is contained in:
Mark Rousskov 2019-09-25 13:14:43 -04:00
parent 6c2c29c432
commit b8a040fc5f
10 changed files with 42 additions and 70 deletions
Download patch file Download diff file Expand all files Collapse all files

11
src/librustc/ty/context.rs
View file

@ -64,7 +64,6 @@ use std::fmt;
use std::mem;
use std::ops::{Deref, Bound};
use std::iter;
use std::sync::mpsc;
use std::sync::Arc;
use rustc_target::spec::abi;
use rustc_macros::HashStable;
@ -1064,14 +1063,6 @@ pub struct GlobalCtxt<'tcx> {
layout_interner: ShardedHashMap<&'tcx LayoutDetails, ()>,
/// A general purpose channel to throw data out the back towards LLVM worker
/// threads.
///
/// This is intended to only get used during the codegen phase of the compiler
/// when satisfying the query for a particular codegen unit. Internally in
/// the query it'll send data along this channel to get processed later.
pub tx_to_llvm_workers: Lock<mpsc::Sender<Box<dyn Any + Send>>>,
output_filenames: Arc<OutputFilenames>,
}
@ -1184,7 +1175,6 @@ impl<'tcx> TyCtxt<'tcx> {
hir: hir_map::Map<'tcx>,
on_disk_query_result_cache: query::OnDiskCache<'tcx>,
crate_name: &str,
tx: mpsc::Sender<Box<dyn Any + Send>>,
output_filenames: &OutputFilenames,
) -> GlobalCtxt<'tcx> {
let data_layout = TargetDataLayout::parse(&s.target.target).unwrap_or_else(|err| {
@ -1291,7 +1281,6 @@ impl<'tcx> TyCtxt<'tcx> {
stability_interner: Default::default(),
allocation_interner: Default::default(),
alloc_map: Lock::new(interpret::AllocMap::new()),
tx_to_llvm_workers: Lock::new(tx),
output_filenames: Arc::new(output_filenames.clone()),
}
}

8
src/librustc_codegen_llvm/base.rs
View file

@ -103,7 +103,11 @@ pub fn iter_globals(llmod: &'ll llvm::Module) -> ValueIter<'ll> {
}
}
pub fn compile_codegen_unit(tcx: TyCtxt<'tcx>, cgu_name: InternedString) {
pub fn compile_codegen_unit(
tcx: TyCtxt<'tcx>,
cgu_name: InternedString,
tx_to_llvm_workers: &std::sync::mpsc::Sender<Box<dyn std::any::Any + Send>>,
) {
let start_time = Instant::now();
let dep_node = tcx.codegen_unit(cgu_name).codegen_dep_node(tcx);
@ -121,7 +125,7 @@ pub fn compile_codegen_unit(tcx: TyCtxt<'tcx>, cgu_name: InternedString) {
let cost = time_to_codegen.as_secs() * 1_000_000_000 +
time_to_codegen.subsec_nanos() as u64;
submit_codegened_module_to_llvm(&LlvmCodegenBackend(()), tcx, module, cost);
submit_codegened_module_to_llvm(&LlvmCodegenBackend(()), tx_to_llvm_workers, module, cost);
fn module_codegen(
tcx: TyCtxt<'_>,

13
src/librustc_codegen_llvm/lib.rs
View file

@ -52,7 +52,7 @@ use syntax::ext::allocator::AllocatorKind;
use syntax_pos::symbol::InternedString;
pub use llvm_util::target_features;
use std::any::Any;
use std::sync::{mpsc, Arc};
use std::sync::Arc;
use std::ffi::CStr;
use rustc::dep_graph::DepGraph;
@ -122,8 +122,12 @@ impl ExtraBackendMethods for LlvmCodegenBackend {
) {
unsafe { allocator::codegen(tcx, mods, kind) }
}
fn compile_codegen_unit(&self, tcx: TyCtxt<'_>, cgu_name: InternedString) {
base::compile_codegen_unit(tcx, cgu_name);
fn compile_codegen_unit(
&self, tcx: TyCtxt<'_>,
cgu_name: InternedString,
tx: &std::sync::mpsc::Sender<Box<dyn Any + Send>>,
) {
base::compile_codegen_unit(tcx, cgu_name, tx);
}
fn target_machine_factory(
&self,
@ -284,10 +288,9 @@ impl CodegenBackend for LlvmCodegenBackend {
tcx: TyCtxt<'tcx>,
metadata: EncodedMetadata,
need_metadata_module: bool,
rx: mpsc::Receiver<Box<dyn Any + Send>>,
) -> Box<dyn Any> {
box rustc_codegen_ssa::base::codegen_crate(
LlvmCodegenBackend(()), tcx, metadata, need_metadata_module, rx)
LlvmCodegenBackend(()), tcx, metadata, need_metadata_module)
}
fn join_codegen_and_link(

23
src/librustc_codegen_ssa/back/write.rs
View file

@ -376,9 +376,9 @@ pub fn start_async_codegen<B: ExtraBackendMethods>(
backend: B,
tcx: TyCtxt<'_>,
metadata: EncodedMetadata,
coordinator_receive: Receiver<Box<dyn Any + Send>>,
total_cgus: usize,
) -> OngoingCodegen<B> {
let (coordinator_send, coordinator_receive) = channel();
let sess = tcx.sess;
let crate_name = tcx.crate_name(LOCAL_CRATE);
let crate_hash = tcx.crate_hash(LOCAL_CRATE);
@ -500,7 +500,8 @@ pub fn start_async_codegen<B: ExtraBackendMethods>(
sess.jobserver.clone(),
Arc::new(modules_config),
Arc::new(metadata_config),
Arc::new(allocator_config));
Arc::new(allocator_config),
coordinator_send.clone());
OngoingCodegen {
backend,
@ -511,7 +512,7 @@ pub fn start_async_codegen<B: ExtraBackendMethods>(
linker_info,
crate_info,
coordinator_send: tcx.tx_to_llvm_workers.lock().clone(),
coordinator_send,
codegen_worker_receive,
shared_emitter_main,
future: coordinator_thread,
@ -1005,8 +1006,9 @@ fn start_executing_work<B: ExtraBackendMethods>(
modules_config: Arc<ModuleConfig>,
metadata_config: Arc<ModuleConfig>,
allocator_config: Arc<ModuleConfig>,
tx_to_llvm_workers: Sender<Box<dyn Any + Send>>,
) -> thread::JoinHandle<Result<CompiledModules, ()>> {
let coordinator_send = tcx.tx_to_llvm_workers.lock().clone();
let coordinator_send = tx_to_llvm_workers;
let sess = tcx.sess;
// Compute the set of symbols we need to retain when doing LTO (if we need to)
@ -1857,7 +1859,7 @@ impl<B: ExtraBackendMethods> OngoingCodegen<B> {
// These are generally cheap and won't throw off scheduling.
let cost = 0;
submit_codegened_module_to_llvm(&self.backend, tcx, module, cost);
submit_codegened_module_to_llvm(&self.backend, &self.coordinator_send, module, cost);
}
pub fn codegen_finished(&self, tcx: TyCtxt<'_>) {
@ -1899,12 +1901,12 @@ impl<B: ExtraBackendMethods> OngoingCodegen<B> {
pub fn submit_codegened_module_to_llvm<B: ExtraBackendMethods>(
_backend: &B,
tcx: TyCtxt<'_>,
tx_to_llvm_workers: &Sender<Box<dyn Any + Send>>,
module: ModuleCodegen<B::Module>,
cost: u64,
) {
let llvm_work_item = WorkItem::Optimize(module);
drop(tcx.tx_to_llvm_workers.lock().send(Box::new(Message::CodegenDone::<B> {
drop(tx_to_llvm_workers.send(Box::new(Message::CodegenDone::<B> {
llvm_work_item,
cost,
})));
@ -1912,11 +1914,11 @@ pub fn submit_codegened_module_to_llvm<B: ExtraBackendMethods>(
pub fn submit_post_lto_module_to_llvm<B: ExtraBackendMethods>(
_backend: &B,
tcx: TyCtxt<'_>,
tx_to_llvm_workers: &Sender<Box<dyn Any + Send>>,
module: CachedModuleCodegen,
) {
let llvm_work_item = WorkItem::CopyPostLtoArtifacts(module);
drop(tcx.tx_to_llvm_workers.lock().send(Box::new(Message::CodegenDone::<B> {
drop(tx_to_llvm_workers.send(Box::new(Message::CodegenDone::<B> {
llvm_work_item,
cost: 0,
})));
@ -1925,6 +1927,7 @@ pub fn submit_post_lto_module_to_llvm<B: ExtraBackendMethods>(
pub fn submit_pre_lto_module_to_llvm<B: ExtraBackendMethods>(
_backend: &B,
tcx: TyCtxt<'_>,
tx_to_llvm_workers: &Sender<Box<dyn Any + Send>>,
module: CachedModuleCodegen,
) {
let filename = pre_lto_bitcode_filename(&module.name);
@ -1939,7 +1942,7 @@ pub fn submit_pre_lto_module_to_llvm<B: ExtraBackendMethods>(
})
};
// Schedule the module to be loaded
drop(tcx.tx_to_llvm_workers.lock().send(Box::new(Message::AddImportOnlyModule::<B> {
drop(tx_to_llvm_workers.send(Box::new(Message::AddImportOnlyModule::<B> {
module_data: SerializedModule::FromUncompressedFile(mmap),
work_product: module.source,
})));

25
src/librustc_codegen_ssa/base.rs
View file

@ -43,11 +43,9 @@ use crate::mir;
use crate::traits::*;
use std::any::Any;
use std::cmp;
use std::ops::{Deref, DerefMut};
use std::time::{Instant, Duration};
use std::sync::mpsc;
use syntax_pos::Span;
use syntax::attr;
use rustc::hir;
@ -482,19 +480,13 @@ pub fn codegen_crate<B: ExtraBackendMethods>(
tcx: TyCtxt<'tcx>,
metadata: EncodedMetadata,
need_metadata_module: bool,
rx: mpsc::Receiver<Box<dyn Any + Send>>,
) -> OngoingCodegen<B> {
check_for_rustc_errors_attr(tcx);
// Skip crate items and just output metadata in -Z no-codegen mode.
if tcx.sess.opts.debugging_opts.no_codegen ||
!tcx.sess.opts.output_types.should_codegen() {
let ongoing_codegen = start_async_codegen(
backend,
tcx,
metadata,
rx,
1);
let ongoing_codegen = start_async_codegen(backend, tcx, metadata, 1);
ongoing_codegen.codegen_finished(tcx);
@ -523,12 +515,7 @@ pub fn codegen_crate<B: ExtraBackendMethods>(
}
}
let ongoing_codegen = start_async_codegen(
backend.clone(),
tcx,
metadata,
rx,
codegen_units.len());
let ongoing_codegen = start_async_codegen(backend.clone(), tcx, metadata, codegen_units.len());
let ongoing_codegen = AbortCodegenOnDrop::<B>(Some(ongoing_codegen));
// Codegen an allocator shim, if necessary.
@ -614,20 +601,22 @@ pub fn codegen_crate<B: ExtraBackendMethods>(
CguReuse::No => {
tcx.sess.profiler(|p| p.start_activity(format!("codegen {}", cgu.name())));
let start_time = Instant::now();
backend.compile_codegen_unit(tcx, *cgu.name());
backend.compile_codegen_unit(tcx, *cgu.name(), &ongoing_codegen.coordinator_send);
total_codegen_time += start_time.elapsed();
tcx.sess.profiler(|p| p.end_activity(format!("codegen {}", cgu.name())));
false
}
CguReuse::PreLto => {
submit_pre_lto_module_to_llvm(&backend, tcx, CachedModuleCodegen {
submit_pre_lto_module_to_llvm(&backend, tcx, &ongoing_codegen.coordinator_send,
CachedModuleCodegen {
name: cgu.name().to_string(),
source: cgu.work_product(tcx),
});
true
}
CguReuse::PostLto => {
submit_post_lto_module_to_llvm(&backend, tcx, CachedModuleCodegen {
submit_post_lto_module_to_llvm(&backend, &ongoing_codegen.coordinator_send,
CachedModuleCodegen {
name: cgu.name().to_string(),
source: cgu.work_product(tcx),
});

8
src/librustc_codegen_ssa/traits/backend.rs
View file

@ -8,6 +8,7 @@ use rustc::session::{Session, config};
use rustc::ty::TyCtxt;
use rustc_codegen_utils::codegen_backend::CodegenBackend;
use std::sync::Arc;
use std::sync::mpsc;
use syntax::ext::allocator::AllocatorKind;
use syntax_pos::symbol::InternedString;
@ -44,7 +45,12 @@ pub trait ExtraBackendMethods: CodegenBackend + WriteBackendMethods + Sized + Se
mods: &mut Self::Module,
kind: AllocatorKind,
);
fn compile_codegen_unit(&self, tcx: TyCtxt<'_>, cgu_name: InternedString);
fn compile_codegen_unit(
&self,
tcx: TyCtxt<'_>,
cgu_name: InternedString,
tx_to_llvm_workers: &mpsc::Sender<Box<dyn std::any::Any + Send>>,
);
// If find_features is true this won't access `sess.crate_types` by assuming
// that `is_pie_binary` is false. When we discover LLVM target features
// `sess.crate_types` is uninitialized so we cannot access it.

2
src/librustc_codegen_utils/codegen_backend.rs
View file

@ -7,7 +7,6 @@
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/")]
use std::any::Any;
use std::sync::mpsc;
use syntax::symbol::Symbol;
use rustc::session::Session;
@ -36,7 +35,6 @@ pub trait CodegenBackend {
tcx: TyCtxt<'tcx>,
metadata: EncodedMetadata,
need_metadata_module: bool,
rx: mpsc::Receiver<Box<dyn Any + Send>>,
) -> Box<dyn Any>;
/// This is called on the returned `Box<dyn Any>` from `codegen_backend`

6
src/librustc_interface/passes.rs
View file

@ -54,7 +54,6 @@ use std::fs;
use std::io::{self, Write};
use std::iter;
use std::path::PathBuf;
use std::sync::mpsc;
use std::cell::RefCell;
use std::rc::Rc;
@ -816,7 +815,6 @@ pub fn create_global_ctxt(
defs: hir::map::Definitions,
resolutions: Resolutions,
outputs: OutputFilenames,
tx: mpsc::Sender<Box<dyn Any + Send>>,
crate_name: &str,
) -> BoxedGlobalCtxt {
let sess = compiler.session().clone();
@ -858,7 +856,6 @@ pub fn create_global_ctxt(
hir_map,
query_result_on_disk_cache,
&crate_name,
tx,
&outputs
);
@ -1068,7 +1065,6 @@ fn encode_and_write_metadata(
pub fn start_codegen<'tcx>(
codegen_backend: &dyn CodegenBackend,
tcx: TyCtxt<'tcx>,
rx: mpsc::Receiver<Box<dyn Any + Send>>,
outputs: &OutputFilenames,
) -> Box<dyn Any> {
if log_enabled!(::log::Level::Info) {
@ -1082,7 +1078,7 @@ pub fn start_codegen<'tcx>(
tcx.sess.profiler(|p| p.start_activity("codegen crate"));
let codegen = time(tcx.sess, "codegen", move || {
codegen_backend.codegen_crate(tcx, metadata, need_metadata_module, rx)
codegen_backend.codegen_crate(tcx, metadata, need_metadata_module)
});
tcx.sess.profiler(|p| p.end_activity("codegen crate"));

15
src/librustc_interface/queries.rs
View file

@ -10,7 +10,6 @@ use rustc::ty::steal::Steal;
use rustc::dep_graph::DepGraph;
use std::cell::{Ref, RefMut, RefCell};
use std::rc::Rc;
use std::sync::mpsc;
use std::any::Any;
use std::mem;
use syntax::{self, ast};
@ -80,8 +79,6 @@ pub(crate) struct Queries {
dep_graph: Query<DepGraph>,
lower_to_hir: Query<(Steal<hir::map::Forest>, ExpansionResult)>,
prepare_outputs: Query<OutputFilenames>,
codegen_channel: Query<(Steal<mpsc::Sender<Box<dyn Any + Send>>>,
Steal<mpsc::Receiver<Box<dyn Any + Send>>>)>,
global_ctxt: Query<BoxedGlobalCtxt>,
ongoing_codegen: Query<Box<dyn Any>>,
link: Query<()>,
@ -211,14 +208,6 @@ impl Compiler {
})
}
pub fn codegen_channel(&self) -> Result<&Query<(Steal<mpsc::Sender<Box<dyn Any + Send>>>,
Steal<mpsc::Receiver<Box<dyn Any + Send>>>)>> {
self.queries.codegen_channel.compute(|| {
let (tx, rx) = mpsc::channel();
Ok((Steal::new(tx), Steal::new(rx)))
})
}
pub fn global_ctxt(&self) -> Result<&Query<BoxedGlobalCtxt>> {
self.queries.global_ctxt.compute(|| {
let crate_name = self.crate_name()?.peek().clone();
@ -226,21 +215,18 @@ impl Compiler {
let hir = self.lower_to_hir()?;
let hir = hir.peek();
let (ref hir_forest, ref expansion) = *hir;
let tx = self.codegen_channel()?.peek().0.steal();
Ok(passes::create_global_ctxt(
self,
hir_forest.steal(),
expansion.defs.steal(),
expansion.resolutions.steal(),
outputs,
tx,
&crate_name))
})
}
pub fn ongoing_codegen(&self) -> Result<&Query<Box<dyn Any>>> {
self.queries.ongoing_codegen.compute(|| {
let rx = self.codegen_channel()?.peek().1.steal();
let outputs = self.prepare_outputs()?;
self.global_ctxt()?.peek_mut().enter(|tcx| {
tcx.analysis(LOCAL_CRATE).ok();
@ -251,7 +237,6 @@ impl Compiler {
Ok(passes::start_codegen(
&***self.codegen_backend(),
tcx,
rx,
&*outputs.peek()
))
})

1
src/test/run-make-fulldeps/hotplug_codegen_backend/the_backend.rs
View file

@ -64,7 +64,6 @@ impl CodegenBackend for TheBackend {
tcx: TyCtxt<'tcx>,
_metadata: EncodedMetadata,
_need_metadata_module: bool,
_rx: mpsc::Receiver<Box<Any + Send>>
) -> Box<Any> {
use rustc::hir::def_id::LOCAL_CRATE;