From 089a38880b6e3b05a2c59644469233dbda411158 Mon Sep 17 00:00:00 2001 From: SparrowLii Date: Fri, 7 Apr 2023 21:20:26 +0800 Subject: [PATCH] correct literals for dyn thread safe --- compiler/rustc_ast/src/tokenstream.rs | 2 +- compiler/rustc_data_structures/src/marker.rs | 21 +++++++++-------- compiler/rustc_data_structures/src/sync.rs | 24 ++++++++++---------- compiler/rustc_driver_impl/src/lib.rs | 4 ++-- compiler/rustc_error_messages/src/lib.rs | 8 +++---- compiler/rustc_errors/src/lib.rs | 6 ++--- compiler/rustc_errors/src/tests.rs | 8 ++++--- compiler/rustc_interface/src/interface.rs | 2 +- compiler/rustc_middle/src/ty/list.rs | 2 +- compiler/rustc_span/src/source_map.rs | 8 ++++--- src/librustdoc/lib.rs | 4 ++-- 11 files changed, 48 insertions(+), 41 deletions(-) diff --git a/compiler/rustc_ast/src/tokenstream.rs b/compiler/rustc_ast/src/tokenstream.rs index 3b47ebef2fd..3f0b1627afa 100644 --- a/compiler/rustc_ast/src/tokenstream.rs +++ b/compiler/rustc_ast/src/tokenstream.rs @@ -48,7 +48,7 @@ pub enum TokenTree { Delimited(DelimSpan, Delimiter, TokenStream), } -// Ensure all fields of `TokenTree` is `DynSend` and `DynSync`. +// Ensure all fields of `TokenTree` are `DynSend` and `DynSync`. #[cfg(parallel_compiler)] fn _dummy() where diff --git a/compiler/rustc_data_structures/src/marker.rs b/compiler/rustc_data_structures/src/marker.rs index 62e65209d72..6dad2bac58a 100644 --- a/compiler/rustc_data_structures/src/marker.rs +++ b/compiler/rustc_data_structures/src/marker.rs @@ -8,20 +8,20 @@ cfg_if!( } else { #[rustc_on_unimplemented( message = "`{Self}` doesn't implement `DynSend`. \ - Add it to `rustc_data_structures::marker` or use `IntoDyn` if it's already `Send`" + Add it to `rustc_data_structures::marker` or use `IntoDynSyncSend` if it's already `Send`" )] // This is an auto trait for types which can be sent across threads if `sync::is_dyn_thread_safe()` // is true. These types can be wrapped in a `FromDyn` to get a `Send` type. Wrapping a - // `Send` type in `IntoDyn` will create a `DynSend` type. + // `Send` type in `IntoDynSyncSend` will create a `DynSend` type. pub unsafe auto trait DynSend {} #[rustc_on_unimplemented( message = "`{Self}` doesn't implement `DynSync`. \ - Add it to `rustc_data_structures::marker` or use `IntoDyn` if it's already `Sync`" + Add it to `rustc_data_structures::marker` or use `IntoDynSyncSend` if it's already `Sync`" )] // This is an auto trait for types which can be shared across threads if `sync::is_dyn_thread_safe()` // is true. These types can be wrapped in a `FromDyn` to get a `Sync` type. Wrapping a - // `Sync` type in `IntoDyn` will create a `DynSync` type. + // `Sync` type in `IntoDynSyncSend` will create a `DynSync` type. pub unsafe auto trait DynSync {} // Same with `Sync` and `Send`. @@ -234,15 +234,18 @@ impl const std::ops::Deref for FromDyn { } } +// A wrapper to convert a struct that is already a `Send` or `Sync` into +// an instance of `DynSend` and `DynSync`, since the compiler cannot infer +// it automatically in some cases. (e.g. Box) #[derive(Copy, Clone)] -pub struct IntoDyn(pub T); +pub struct IntoDynSyncSend(pub T); #[cfg(parallel_compiler)] -unsafe impl DynSend for IntoDyn {} +unsafe impl DynSend for IntoDynSyncSend {} #[cfg(parallel_compiler)] -unsafe impl DynSync for IntoDyn {} +unsafe impl DynSync for IntoDynSyncSend {} -impl const std::ops::Deref for IntoDyn { +impl const std::ops::Deref for IntoDynSyncSend { type Target = T; fn deref(&self) -> &T { @@ -250,7 +253,7 @@ impl const std::ops::Deref for IntoDyn { } } -impl const std::ops::DerefMut for IntoDyn { +impl const std::ops::DerefMut for IntoDynSyncSend { fn deref_mut(&mut self) -> &mut T { &mut self.0 } diff --git a/compiler/rustc_data_structures/src/sync.rs b/compiler/rustc_data_structures/src/sync.rs index 41aad2ff4e4..8a778866a77 100644 --- a/compiler/rustc_data_structures/src/sync.rs +++ b/compiler/rustc_data_structures/src/sync.rs @@ -61,25 +61,25 @@ mod mode { use std::sync::atomic::AtomicU8; const UNINITIALIZED: u8 = 0; - const DYN_NOT_SYNC: u8 = 1; - const DYN_SYNC: u8 = 2; + const DYN_NOT_THREAD_SAFE: u8 = 1; + const DYN_THREAD_SAFE: u8 = 2; - static DYN_SYNC_MODE: AtomicU8 = AtomicU8::new(UNINITIALIZED); + static DYN_THREAD_SAFE_MODE: AtomicU8 = AtomicU8::new(UNINITIALIZED); - // Weather control thread safety dynamically + // Whether thread safety is enabled (due to running under multiple threads). #[inline] pub fn is_dyn_thread_safe() -> bool { - match DYN_SYNC_MODE.load(Ordering::Relaxed) { - DYN_NOT_SYNC => false, - DYN_SYNC => true, - _ => panic!("uninitialized parallel mode!"), + match DYN_THREAD_SAFE_MODE.load(Ordering::Relaxed) { + DYN_NOT_THREAD_SAFE => false, + DYN_THREAD_SAFE => true, + _ => panic!("uninitialized dyn_thread_safe mode!"), } } // Only set by the `-Z threads` compile option - pub fn set_dyn_thread_safe_mode(parallel: bool) { - let set: u8 = if parallel { DYN_SYNC } else { DYN_NOT_SYNC }; - let previous = DYN_SYNC_MODE.compare_exchange( + pub fn set_dyn_thread_safe_mode(mode: bool) { + let set: u8 = if mode { DYN_THREAD_SAFE } else { DYN_NOT_THREAD_SAFE }; + let previous = DYN_THREAD_SAFE_MODE.compare_exchange( UNINITIALIZED, set, Ordering::Relaxed, @@ -401,7 +401,7 @@ cfg_if! { if rustc_data_structures::sync::is_dyn_thread_safe() { // Reverse the order of the later blocks since Rayon executes them in reverse order // when using a single thread. This ensures the execution order matches that - // of a single threaded rustc + // of a single threaded rustc. parallel!(impl $fblock [] [$($blocks),*]); } else { // We catch panics here ensuring that all the blocks execute. diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs index 353f49e6619..b94fb335a4e 100644 --- a/compiler/rustc_driver_impl/src/lib.rs +++ b/compiler/rustc_driver_impl/src/lib.rs @@ -255,8 +255,8 @@ fn run_compiler( let sopts = config::build_session_options(&matches); - // Set parallel mode before thread pool creation as the session will already create locks. - interface::set_parallel_mode(&sopts.unstable_opts); + // Set parallel mode before thread pool creation, which will create `Lock`s. + interface::set_thread_safe_mode(&sopts.unstable_opts); if let Some(ref code) = matches.opt_str("explain") { handle_explain(diagnostics_registry(), code, sopts.error_format); diff --git a/compiler/rustc_error_messages/src/lib.rs b/compiler/rustc_error_messages/src/lib.rs index 2b7c8dc5f3d..0accb4ab96f 100644 --- a/compiler/rustc_error_messages/src/lib.rs +++ b/compiler/rustc_error_messages/src/lib.rs @@ -11,7 +11,7 @@ extern crate tracing; use fluent_bundle::FluentResource; use fluent_syntax::parser::ParserError; use icu_provider_adapters::fallback::{LocaleFallbackProvider, LocaleFallbacker}; -use rustc_data_structures::sync::{IntoDyn, Lrc}; +use rustc_data_structures::sync::{IntoDynSyncSend, Lrc}; use rustc_fluent_macro::fluent_messages; use rustc_macros::{Decodable, Encodable}; use rustc_span::Span; @@ -38,16 +38,16 @@ pub use unic_langid::{langid, LanguageIdentifier}; fluent_messages! { "../messages.ftl" } pub type FluentBundle = - IntoDyn>; + IntoDynSyncSend>; #[cfg(not(parallel_compiler))] fn new_bundle(locales: Vec) -> FluentBundle { - IntoDyn(fluent_bundle::bundle::FluentBundle::new(locales)) + IntoDynSyncSend(fluent_bundle::bundle::FluentBundle::new(locales)) } #[cfg(parallel_compiler)] fn new_bundle(locales: Vec) -> FluentBundle { - IntoDyn(fluent_bundle::bundle::FluentBundle::new_concurrent(locales)) + IntoDynSyncSend(fluent_bundle::bundle::FluentBundle::new_concurrent(locales)) } #[derive(Debug)] diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs index f57bb8d8bdc..64fbf22c262 100644 --- a/compiler/rustc_errors/src/lib.rs +++ b/compiler/rustc_errors/src/lib.rs @@ -32,7 +32,7 @@ use emitter::{is_case_difference, Emitter, EmitterWriter}; use registry::Registry; use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet}; use rustc_data_structures::stable_hasher::{Hash128, StableHasher}; -use rustc_data_structures::sync::{self, IntoDyn, Lock, Lrc}; +use rustc_data_structures::sync::{self, IntoDynSyncSend, Lock, Lrc}; use rustc_data_structures::AtomicRef; pub use rustc_error_messages::{ fallback_fluent_bundle, fluent_bundle, DelayDm, DiagnosticMessage, FluentBundle, @@ -409,7 +409,7 @@ struct HandlerInner { err_count: usize, warn_count: usize, deduplicated_err_count: usize, - emitter: IntoDyn>, + emitter: IntoDynSyncSend>, delayed_span_bugs: Vec, delayed_good_path_bugs: Vec, /// This flag indicates that an expected diagnostic was emitted and suppressed. @@ -605,7 +605,7 @@ impl Handler { warn_count: 0, deduplicated_err_count: 0, deduplicated_warn_count: 0, - emitter: IntoDyn(emitter), + emitter: IntoDynSyncSend(emitter), delayed_span_bugs: Vec::new(), delayed_good_path_bugs: Vec::new(), suppressed_expected_diag: false, diff --git a/compiler/rustc_errors/src/tests.rs b/compiler/rustc_errors/src/tests.rs index 08b3281d9a5..0e729b71680 100644 --- a/compiler/rustc_errors/src/tests.rs +++ b/compiler/rustc_errors/src/tests.rs @@ -2,7 +2,7 @@ use crate::error::{TranslateError, TranslateErrorKind}; use crate::fluent_bundle::*; use crate::translation::Translate; use crate::FluentBundle; -use rustc_data_structures::sync::{IntoDyn, Lrc}; +use rustc_data_structures::sync::{IntoDynSyncSend, Lrc}; use rustc_error_messages::fluent_bundle::resolver::errors::{ReferenceKind, ResolverError}; use rustc_error_messages::langid; use rustc_error_messages::DiagnosticMessage; @@ -28,11 +28,13 @@ fn make_dummy(ftl: &'static str) -> Dummy { #[cfg(parallel_compiler)] let mut bundle: FluentBundle = - IntoDyn(crate::fluent_bundle::bundle::FluentBundle::new_concurrent(vec![langid_en])); + IntoDynSyncSend(crate::fluent_bundle::bundle::FluentBundle::new_concurrent(vec![ + langid_en, + ])); #[cfg(not(parallel_compiler))] let mut bundle: FluentBundle = - IntoDyn(crate::fluent_bundle::bundle::FluentBundle::new(vec![langid_en])); + IntoDynSyncSend(crate::fluent_bundle::bundle::FluentBundle::new(vec![langid_en])); bundle.add_resource(resource).expect("Failed to add FTL resources to the bundle."); diff --git a/compiler/rustc_interface/src/interface.rs b/compiler/rustc_interface/src/interface.rs index fb6c273e929..ee373f72ee9 100644 --- a/compiler/rustc_interface/src/interface.rs +++ b/compiler/rustc_interface/src/interface.rs @@ -61,7 +61,7 @@ impl Compiler { } #[allow(rustc::bad_opt_access)] -pub fn set_parallel_mode(sopts: &config::UnstableOptions) { +pub fn set_thread_safe_mode(sopts: &config::UnstableOptions) { rustc_data_structures::sync::set_dyn_thread_safe_mode(sopts.threads > 1); } diff --git a/compiler/rustc_middle/src/ty/list.rs b/compiler/rustc_middle/src/ty/list.rs index 8f99a051328..71911a5a618 100644 --- a/compiler/rustc_middle/src/ty/list.rs +++ b/compiler/rustc_middle/src/ty/list.rs @@ -199,7 +199,7 @@ impl<'a, T: Copy> IntoIterator for &'a List { unsafe impl Sync for List {} -// We need this since `List` uses extern type `OpaqueListContents` +// We need this since `List` uses extern type `OpaqueListContents`. #[cfg(parallel_compiler)] use rustc_data_structures::sync::DynSync; #[cfg(parallel_compiler)] diff --git a/compiler/rustc_span/src/source_map.rs b/compiler/rustc_span/src/source_map.rs index e0a2733a464..8238a16969d 100644 --- a/compiler/rustc_span/src/source_map.rs +++ b/compiler/rustc_span/src/source_map.rs @@ -14,7 +14,9 @@ pub use crate::*; use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::stable_hasher::{Hash128, Hash64, StableHasher}; -use rustc_data_structures::sync::{AtomicU32, IntoDyn, Lrc, MappedReadGuard, ReadGuard, RwLock}; +use rustc_data_structures::sync::{ + AtomicU32, IntoDynSyncSend, Lrc, MappedReadGuard, ReadGuard, RwLock, +}; use std::cmp; use std::hash::Hash; use std::path::{self, Path, PathBuf}; @@ -176,7 +178,7 @@ pub struct SourceMap { used_address_space: AtomicU32, files: RwLock, - file_loader: IntoDyn>, + file_loader: IntoDynSyncSend>, // This is used to apply the file path remapping as specified via // `--remap-path-prefix` to all `SourceFile`s allocated within this `SourceMap`. path_mapping: FilePathMapping, @@ -202,7 +204,7 @@ impl SourceMap { SourceMap { used_address_space: AtomicU32::new(0), files: Default::default(), - file_loader: IntoDyn(file_loader), + file_loader: IntoDynSyncSend(file_loader), path_mapping, hash_kind, } diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index ba71d0372a7..70b6ba1aced 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -730,8 +730,8 @@ fn main_args(at_args: &[String]) -> MainResult { } }; - // Set parallel mode early as the error handler will already create locks. - interface::set_parallel_mode(&options.unstable_opts); + // Set parallel mode before error handler creation, which will create `Lock`s. + interface::set_thread_safe_mode(&options.unstable_opts); let diag = core::new_handler( options.error_format,