Auto merge of #112049 - Kobzol:pgo-omit-benchmarks, r=<try>

[do not merge] CI experiments

Various CI experiments for try/dist builds.

r? `@ghost`

Author: rust-bors[bot]

compiler/rustc_codegen_cranelift/src/base.rs

@@ -106,7 +106,7 @@ pub(crate) fn codegen_fn<'tcx>(
         next_ssa_var: 0,
     };
 
-    tcx.prof.generic_activity("codegen clif ir").run(|| codegen_fn_body(&mut fx, start_block));
+    codegen_fn_body(&mut fx, start_block);
     fx.bcx.seal_all_blocks();
     fx.bcx.finalize();
 
@@ -136,14 +136,11 @@ pub(crate) fn codegen_fn<'tcx>(
 
 pub(crate) fn compile_fn(
     cx: &mut crate::CodegenCx,
-    profiler: &SelfProfilerRef,
+    _profiler: &SelfProfilerRef,
     cached_context: &mut Context,
     module: &mut dyn Module,
     codegened_func: CodegenedFunction,
 ) {
-    let _timer =
-        profiler.generic_activity_with_arg("compile function", &*codegened_func.symbol_name);
-
     let clif_comments = codegened_func.clif_comments;
 
     // Store function in context
@@ -180,36 +177,34 @@ pub(crate) fn compile_fn(
     };
 
     // Define function
-    profiler.generic_activity("define function").run(|| {
-        context.want_disasm = cx.should_write_ir;
-        match module.define_function(codegened_func.func_id, context) {
-            Ok(()) => {}
-            Err(ModuleError::Compilation(CodegenError::ImplLimitExceeded)) => {
-                let early_dcx = rustc_session::EarlyDiagCtxt::new(
-                    rustc_session::config::ErrorOutputType::default(),
-                );
-                early_dcx.early_fatal(format!(
-                    "backend implementation limit exceeded while compiling {name}",
-                    name = codegened_func.symbol_name
-                ));
-            }
-            Err(ModuleError::Compilation(CodegenError::Verifier(err))) => {
-                let early_dcx = rustc_session::EarlyDiagCtxt::new(
-                    rustc_session::config::ErrorOutputType::default(),
-                );
-                let _ = early_dcx.early_err(format!("{:?}", err));
-                let pretty_error = cranelift_codegen::print_errors::pretty_verifier_error(
-                    &context.func,
-                    Some(Box::new(&clif_comments)),
-                    err,
-                );
-                early_dcx.early_fatal(format!("cranelift verify error:\n{}", pretty_error));
-            }
-            Err(err) => {
-                panic!("Error while defining {name}: {err:?}", name = codegened_func.symbol_name);
-            }
+    context.want_disasm = cx.should_write_ir;
+    match module.define_function(codegened_func.func_id, context) {
+        Ok(()) => {}
+        Err(ModuleError::Compilation(CodegenError::ImplLimitExceeded)) => {
+            let early_dcx = rustc_session::EarlyDiagCtxt::new(
+                rustc_session::config::ErrorOutputType::default(),
+            );
+            early_dcx.early_fatal(format!(
+                "backend implementation limit exceeded while compiling {name}",
+                name = codegened_func.symbol_name
+            ));
         }
-    });
+        Err(ModuleError::Compilation(CodegenError::Verifier(err))) => {
+            let early_dcx = rustc_session::EarlyDiagCtxt::new(
+                rustc_session::config::ErrorOutputType::default(),
+            );
+            let _ = early_dcx.early_err(format!("{:?}", err));
+            let pretty_error = cranelift_codegen::print_errors::pretty_verifier_error(
+                &context.func,
+                Some(Box::new(&clif_comments)),
+                err,
+            );
+            early_dcx.early_fatal(format!("cranelift verify error:\n{}", pretty_error));
+        }
+        Err(err) => {
+            panic!("Error while defining {name}: {err:?}", name = codegened_func.symbol_name);
+        }
+    }
 
     if cx.should_write_ir {
         // Write optimized function to file for debugging
@@ -233,37 +228,33 @@ pub(crate) fn compile_fn(
 
     // Define debuginfo for function
     let debug_context = &mut cx.debug_context;
-    profiler.generic_activity("generate debug info").run(|| {
-        if let Some(debug_context) = debug_context {
-            codegened_func.func_debug_cx.unwrap().finalize(
-                debug_context,
-                codegened_func.func_id,
-                context,
-            );
-        }
-    });
+    if let Some(debug_context) = debug_context {
+        codegened_func.func_debug_cx.unwrap().finalize(
+            debug_context,
+            codegened_func.func_id,
+            context,
+        );
+    }
 }
 
 fn verify_func(tcx: TyCtxt<'_>, writer: &crate::pretty_clif::CommentWriter, func: &Function) {
     if !enable_verifier(tcx.sess) {
         return;
     }
 
-    tcx.prof.generic_activity("verify clif ir").run(|| {
-        let flags = cranelift_codegen::settings::Flags::new(cranelift_codegen::settings::builder());
-        match cranelift_codegen::verify_function(&func, &flags) {
-            Ok(_) => {}
-            Err(err) => {
-                tcx.dcx().err(format!("{:?}", err));
-                let pretty_error = cranelift_codegen::print_errors::pretty_verifier_error(
-                    &func,
-                    Some(Box::new(writer)),
-                    err,
-                );
-                tcx.dcx().fatal(format!("cranelift verify error:\n{}", pretty_error));
-            }
+    let flags = cranelift_codegen::settings::Flags::new(cranelift_codegen::settings::builder());
+    match cranelift_codegen::verify_function(&func, &flags) {
+        Ok(_) => {}
+        Err(err) => {
+            tcx.dcx().err(format!("{:?}", err));
+            let pretty_error = cranelift_codegen::print_errors::pretty_verifier_error(
+                &func,
+                Some(Box::new(writer)),
+                err,
+            );
+            tcx.dcx().fatal(format!("cranelift verify error:\n{}", pretty_error));
         }
-    });
+    }
 }
 
 fn codegen_fn_body(fx: &mut FunctionCx<'_, '_, '_>, start_block: Block) {
@@ -277,10 +268,7 @@ fn codegen_fn_body(fx: &mut FunctionCx<'_, '_, '_>, start_block: Block) {
         fx.bcx.ins().trap(TrapCode::user(1 /* unreachable */).unwrap());
         return;
     }
-    fx.tcx
-        .prof
-        .generic_activity("codegen prelude")
-        .run(|| crate::abi::codegen_fn_prelude(fx, start_block));
+    crate::abi::codegen_fn_prelude(fx, start_block);
 
     let reachable_blocks = traversal::mono_reachable_as_bitset(fx.mir, fx.tcx, fx.instance);
 
@@ -475,19 +463,15 @@ fn codegen_fn_body(fx: &mut FunctionCx<'_, '_, '_>, start_block: Block) {
                 fn_span,
                 unwind,
                 call_source: _,
-            } => {
-                fx.tcx.prof.generic_activity("codegen call").run(|| {
-                    crate::abi::codegen_terminator_call(
-                        fx,
-                        mir::SourceInfo { span: *fn_span, ..source_info },
-                        func,
-                        args,
-                        *destination,
-                        *target,
-                        *unwind,
-                    )
-                });
-            }
+            } => crate::abi::codegen_terminator_call(
+                fx,
+                mir::SourceInfo { span: *fn_span, ..source_info },
+                func,
+                args,
+                *destination,
+                *target,
+                *unwind,
+            ),
             // FIXME(explicit_tail_calls): add support for tail calls to the cranelift backend, once cranelift supports tail calls
             TerminatorKind::TailCall { fn_span, .. } => span_bug!(
                 *fn_span,

compiler/rustc_codegen_cranelift/src/driver/aot.rs

@@ -595,46 +595,38 @@ fn module_codegen(
     let profiler = tcx.prof.clone();
 
     OngoingModuleCodegen::Async(std::thread::spawn(move || {
-        profiler.clone().generic_activity_with_arg("compile functions", &*cgu_name).run(|| {
-            cranelift_codegen::timing::set_thread_profiler(Box::new(super::MeasuremeProfiler(
-                profiler.clone(),
-            )));
-
-            let mut cached_context = Context::new();
-            for codegened_func in codegened_functions {
-                crate::base::compile_fn(
-                    &mut cx,
-                    &profiler,
-                    &mut cached_context,
-                    &mut module,
-                    codegened_func,
-                );
-            }
-        });
+        cranelift_codegen::timing::set_thread_profiler(Box::new(super::MeasuremeProfiler(
+            profiler.clone(),
+        )));
+
+        let mut cached_context = Context::new();
+        for codegened_func in codegened_functions {
+            crate::base::compile_fn(
+                &mut cx,
+                &profiler,
+                &mut cached_context,
+                &mut module,
+                codegened_func,
+            );
+        }
 
-        let global_asm_object_file =
-            profiler.generic_activity_with_arg("compile assembly", &*cgu_name).run(|| {
-                crate::global_asm::compile_global_asm(
-                    &global_asm_config,
-                    &cgu_name,
-                    &cx.global_asm,
-                    cx.invocation_temp.as_deref(),
-                )
-            })?;
-
-        let codegen_result =
-            profiler.generic_activity_with_arg("write object file", &*cgu_name).run(|| {
-                emit_cgu(
-                    &global_asm_config.output_filenames,
-                    cx.invocation_temp.as_deref(),
-                    &profiler,
-                    cgu_name,
-                    module,
-                    cx.debug_context,
-                    global_asm_object_file,
-                    &producer,
-                )
-            });
+        let global_asm_object_file = crate::global_asm::compile_global_asm(
+            &global_asm_config,
+            &cgu_name,
+            &cx.global_asm,
+            cx.invocation_temp.as_deref(),
+        )?;
+
+        let codegen_result = emit_cgu(
+            &global_asm_config.output_filenames,
+            cx.invocation_temp.as_deref(),
+            &profiler,
+            cgu_name,
+            module,
+            cx.debug_context,
+            global_asm_object_file,
+            &producer,
+        );
         std::mem::drop(token);
         codegen_result
     }))

compiler/rustc_codegen_cranelift/src/driver/mod.rs

@@ -19,40 +19,37 @@ fn predefine_mono_items<'tcx>(
     module: &mut dyn Module,
     mono_items: &[(MonoItem<'tcx>, MonoItemData)],
 ) {
-    tcx.prof.generic_activity("predefine functions").run(|| {
-        let is_compiler_builtins = tcx.is_compiler_builtins(LOCAL_CRATE);
-        for &(mono_item, data) in mono_items {
-            match mono_item {
-                MonoItem::Fn(instance) => {
-                    let name = tcx.symbol_name(instance).name;
-                    let _inst_guard = crate::PrintOnPanic(|| format!("{:?} {}", instance, name));
-                    let sig =
-                        get_function_sig(tcx, module.target_config().default_call_conv, instance);
-                    let linkage = crate::linkage::get_clif_linkage(
-                        mono_item,
-                        data.linkage,
-                        data.visibility,
-                        is_compiler_builtins,
-                    );
-                    let is_naked = tcx
-                        .codegen_fn_attrs(instance.def_id())
-                        .flags
-                        .contains(CodegenFnAttrFlags::NAKED);
-                    module
-                        .declare_function(
-                            name,
-                            // Naked functions are defined in a separate object
-                            // file from the codegen unit rustc expects them to
-                            // be defined in.
-                            if is_naked { Linkage::Import } else { linkage },
-                            &sig,
-                        )
-                        .unwrap();
-                }
-                MonoItem::Static(_) | MonoItem::GlobalAsm(_) => {}
+    let is_compiler_builtins = tcx.is_compiler_builtins(LOCAL_CRATE);
+    for &(mono_item, data) in mono_items {
+        match mono_item {
+            MonoItem::Fn(instance) => {
+                let name = tcx.symbol_name(instance).name;
+                let _inst_guard = crate::PrintOnPanic(|| format!("{:?} {}", instance, name));
+                let sig = get_function_sig(tcx, module.target_config().default_call_conv, instance);
+                let linkage = crate::linkage::get_clif_linkage(
+                    mono_item,
+                    data.linkage,
+                    data.visibility,
+                    is_compiler_builtins,
+                );
+                let is_naked = tcx
+                    .codegen_fn_attrs(instance.def_id())
+                    .flags
+                    .contains(CodegenFnAttrFlags::NAKED);
+                module
+                    .declare_function(
+                        name,
+                        // Naked functions are defined in a separate object
+                        // file from the codegen unit rustc expects them to
+                        // be defined in.
+                        if is_naked { Linkage::Import } else { linkage },
+                        &sig,
+                    )
+                    .unwrap();
             }
+            MonoItem::Static(_) | MonoItem::GlobalAsm(_) => {}
         }
-    });
+    }
 }
 
 struct MeasuremeProfiler(SelfProfilerRef);
@@ -72,15 +69,11 @@ impl Drop for TimingGuard {
 }
 
 impl cranelift_codegen::timing::Profiler for MeasuremeProfiler {
-    fn start_pass(&self, pass: cranelift_codegen::timing::Pass) -> Box<dyn std::any::Any> {
-        let mut timing_guard = Box::new(TimingGuard {
+    fn start_pass(&self, _pass: cranelift_codegen::timing::Pass) -> Box<dyn std::any::Any> {
+        let timing_guard = Box::new(TimingGuard {
             profiler: std::mem::ManuallyDrop::new(self.0.clone()),
             inner: None,
         });
-        timing_guard.inner = Some(
-            unsafe { &*(&*timing_guard.profiler as &SelfProfilerRef as *const SelfProfilerRef) }
-                .generic_activity(pass.description()),
-        );
         timing_guard
     }
 }