Use WokerLocal to avoid lock when checking features

Author: mu001999

compiler/rustc_driver_impl/src/lib.rs

@@ -21,8 +21,8 @@ use std::io::{self, IsTerminal, Read, Write};
 use std::panic::{self, PanicHookInfo};
 use std::path::{Path, PathBuf};
 use std::process::{Command, ExitCode, Stdio, Termination};
+use std::sync::OnceLock;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, OnceLock};
 use std::time::Instant;
 use std::{env, str};
 
@@ -714,7 +714,7 @@ fn print_crate_info(
                 let lint_store = crate::unerased_lint_store(sess);
                 let registered_tools = rustc_resolve::registered_tools_ast(sess.dcx(), attrs);
                 let features = rustc_feature::TrackedFeatures::new(
-                    Arc::clone(&sess.used_features),
+                    sess.used_features_weak(),
                     rustc_expand::config::features(sess, attrs, crate_name),
                 );
                 let lint_levels = rustc_lint::LintLevelsBuilder::crate_root(

compiler/rustc_feature/src/unstable.rs

@@ -1,10 +1,12 @@
 //! List of the unstable feature gates.
 
+use std::cell::RefCell;
 use std::path::PathBuf;
-use std::sync::{Arc, Mutex};
+use std::sync::Weak;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use rustc_data_structures::fx::FxHashSet;
+use rustc_data_structures::sync::WorkerLocal;
 use rustc_span::{Span, Symbol, sym};
 
 use super::{Feature, to_nonzero};
@@ -45,17 +47,19 @@ macro_rules! status_to_enum {
 /// "unused features" diagnostics.
 #[derive(Clone, Debug)]
 pub struct TrackedFeatures {
-    used_features: Arc<Mutex<FxHashSet<Symbol>>>,
+    used_features: Weak<WorkerLocal<RefCell<FxHashSet<Symbol>>>>,
     features: Features,
 }
 
 impl TrackedFeatures {
-    pub fn new(used_features: Arc<Mutex<FxHashSet<Symbol>>>, features: Features) -> Self {
+    pub fn new(
+        used_features: Weak<WorkerLocal<RefCell<FxHashSet<Symbol>>>>,
+        features: Features,
+    ) -> Self {
         Self { used_features, features }
     }
 
-    pub fn unused_features(&self) -> Vec<(Symbol, Span)> {
-        let used_features = self.used_features.lock().unwrap();
+    pub fn unused_features(&self, used_features: &FxHashSet<Symbol>) -> Vec<(Symbol, Span)> {
         self.enabled_features_iter_stable_order()
             .filter(|(f, _)| {
                 !used_features.contains(f)
@@ -72,7 +76,9 @@ impl TrackedFeatures {
 
     /// Is the given feature enabled (via `#[feature(...)]`)?
     pub fn enabled(&self, feature: Symbol) -> bool {
-        self.used_features.lock().unwrap().insert(feature);
+        if let Some(used_features) = self.used_features.upgrade() {
+            used_features.borrow_mut().insert(feature);
+        }
         self.features.enabled(feature)
     }
 

compiler/rustc_interface/src/passes.rs

@@ -877,10 +877,8 @@ pub fn write_interface<'tcx>(tcx: TyCtxt<'tcx>) {
 
 pub fn tracked_features_query<'tcx>(tcx: TyCtxt<'tcx>) -> &'tcx rustc_feature::TrackedFeatures {
     let features = tcx.features_query(());
-    tcx.arena.alloc(rustc_feature::TrackedFeatures::new(
-        Arc::clone(&tcx.sess.used_features),
-        features.clone(),
-    ))
+    tcx.arena
+        .alloc(rustc_feature::TrackedFeatures::new(tcx.sess.used_features_weak(), features.clone()))
 }
 
 pub static DEFAULT_QUERY_PROVIDERS: LazyLock<Providers> = LazyLock::new(|| {

compiler/rustc_middle/src/ty/context.rs

@@ -1678,7 +1678,8 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 
     pub fn finish(self) {
-        for (feature, span) in self.features().unused_features() {
+        let used_features = self.sess.take_used_features();
+        for (feature, span) in self.features().unused_features(&used_features) {
             self.node_span_lint(
                 rustc_session::lint::builtin::UNUSED_FEATURES,
                 CRATE_HIR_ID,

compiler/rustc_session/src/session.rs

@@ -1,16 +1,19 @@
 use std::any::Any;
+use std::cell::RefCell;
 use std::path::PathBuf;
 use std::str::FromStr;
 use std::sync::atomic::AtomicBool;
-use std::sync::{Arc, Mutex};
+use std::sync::{Arc, Weak};
 use std::{env, io};
 
 use rand::{RngCore, rng};
 use rustc_data_structures::base_n::{CASE_INSENSITIVE, ToBaseN};
 use rustc_data_structures::flock;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexSet};
 use rustc_data_structures::profiling::{SelfProfiler, SelfProfilerRef};
-use rustc_data_structures::sync::{DynSend, DynSync, Lock, MappedReadGuard, ReadGuard, RwLock};
+use rustc_data_structures::sync::{
+    DynSend, DynSync, Lock, MappedReadGuard, ReadGuard, RwLock, WorkerLocal,
+};
 use rustc_errors::annotate_snippet_emitter_writer::AnnotateSnippetEmitter;
 use rustc_errors::codes::*;
 use rustc_errors::emitter::{DynEmitter, HumanReadableErrorType, OutputTheme, stderr_destination};
@@ -159,7 +162,8 @@ pub struct Session {
     /// with its own implementations.
     pub replaced_intrinsics: FxHashSet<Symbol>,
 
-    pub used_features: Arc<Mutex<FxHashSet<Symbol>>>,
+    pub used_features: Lock<Option<Arc<WorkerLocal<RefCell<FxHashSet<Symbol>>>>>>,
+    used_features_weak: Weak<WorkerLocal<RefCell<FxHashSet<Symbol>>>>,
 }
 
 #[derive(Clone, Copy)]
@@ -194,6 +198,27 @@ impl Session {
         self.miri_unleashed_features.lock().push((span, feature_gate));
     }
 
+    pub fn used_features_weak(&self) -> Weak<WorkerLocal<RefCell<FxHashSet<Symbol>>>> {
+        self.used_features_weak.clone()
+    }
+
+    // Collect used features into a single set from all threads.
+    #[allow(rustc::potential_query_instability)]
+    pub fn take_used_features(&self) -> FxHashSet<Symbol> {
+        let used_features = self.used_features.lock().take().expect("used_features must be set");
+
+        let mut result = FxHashSet::default();
+        for set in Arc::try_unwrap(used_features)
+            .ok()
+            .expect("used_features has outstanding strong references")
+            .into_inner()
+        {
+            result.extend(set.take());
+        }
+
+        result
+    }
+
     pub fn local_crate_source_file(&self) -> Option<RealFileName> {
         Some(
             self.source_map()
@@ -1066,6 +1091,8 @@ pub fn build_session(
 
     let timings = TimingSectionHandler::new(sopts.json_timings);
 
+    let used_features = Arc::new(WorkerLocal::new(|_| RefCell::new(FxHashSet::default())));
+    let used_features_weak = Arc::downgrade(&used_features);
     let sess = Session {
         target,
         host,
@@ -1090,7 +1117,8 @@ pub fn build_session(
         host_filesearch,
         invocation_temp,
         replaced_intrinsics: FxHashSet::default(), // filled by `run_compiler`
-        used_features: Arc::new(Mutex::new(FxHashSet::default())),
+        used_features: Lock::new(Some(used_features)),
+        used_features_weak,
     };
 
     validate_commandline_args_with_session_available(&sess);