Restructure and rename std thread_local internals to make it less of a maze #110861
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,13 +1,14 @@ | ||
| use super::lazy::LazyKeyInner; | ||
| use crate::cell::Cell; | ||
| use crate::sys::thread_local_dtor::register_dtor; | ||
| use crate::{fmt, mem, panic}; | ||
|
|
||
| #[doc(hidden)] | ||
| #[allow_internal_unstable(thread_local_internals, cfg_target_thread_local, thread_local)] | ||
| #[allow_internal_unsafe] | ||
| #[unstable(feature = "thread_local_internals", issue = "none")] | ||
| #[rustc_macro_transparency = "semitransparent"] | ||
| pub macro thread_local_inner { | ||
| // used to generate the `LocalKey` value for const-initialized thread locals | ||
| (@key $t:ty, const $init:expr) => {{ | ||
| #[cfg_attr(not(bootstrap), inline)] | ||
|
|
@@ -49,7 +50,7 @@ macro_rules! __thread_local_inner { | |
| // 0 == we haven't registered a destructor, so do | ||
| // so now. | ||
| 0 => { | ||
| $crate::thread::local_impl::Key::<$t>::register_dtor( | ||
| $crate::ptr::addr_of_mut!(VAL) as *mut $crate::primitive::u8, | ||
| destroy, | ||
| ); | ||
|
|
@@ -69,7 +70,7 @@ macro_rules! __thread_local_inner { | |
| unsafe { | ||
| $crate::thread::LocalKey::new(__getit) | ||
| } | ||
| }}, | ||
|
|
||
| // used to generate the `LocalKey` value for `thread_local!` | ||
| (@key $t:ty, $init:expr) => { | ||
|
|
@@ -82,8 +83,8 @@ macro_rules! __thread_local_inner { | |
| init: $crate::option::Option<&mut $crate::option::Option<$t>>, | ||
| ) -> $crate::option::Option<&'static $t> { | ||
| #[thread_local] | ||
| static __KEY: $crate::thread::local_impl::Key<$t> = | ||
| $crate::thread::local_impl::Key::<$t>::new(); | ||
|
|
||
| // FIXME: remove the #[allow(...)] marker when macros don't | ||
| // raise warning for missing/extraneous unsafe blocks anymore. | ||
|
|
@@ -107,148 +108,140 @@ macro_rules! __thread_local_inner { | |
| $crate::thread::LocalKey::new(__getit) | ||
| } | ||
| } | ||
| }, | ||
| ($(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $($init:tt)*) => { | ||
| $(#[$attr])* $vis const $name: $crate::thread::LocalKey<$t> = | ||
| $crate::thread::local_impl::thread_local_inner!(@key $t, $($init)*); | ||
| }, | ||
| } | ||
|
|
||
| #[derive(Copy, Clone)] | ||
| enum DtorState { | ||
| Unregistered, | ||
| Registered, | ||
| RunningOrHasRun, | ||
| } | ||
|
|
||
| // This data structure has been carefully constructed so that the fast path | ||
| // only contains one branch on x86. That optimization is necessary to avoid | ||
| // duplicated tls lookups on OSX. | ||
| // | ||
| // LLVM issue: https://bugs.llvm.org/show_bug.cgi?id=41722 | ||
|
Comment on lines
+125
to
+129
There was a problem hiding this comment. While we're doing spring cleaning: This comment is 4 years old. While the LLVM issue hasn't been closed, is this concern re: assembly generation still true? Well, I suppose that can be another issue. llvm/llvm-project#41067 |
||
| pub struct Key<T> { | ||
| // If `LazyKeyInner::get` returns `None`, that indicates either: | ||
| // * The value has never been initialized | ||
| // * The value is being recursively initialized | ||
| // * The value has already been destroyed or is being destroyed | ||
| // To determine which kind of `None`, check `dtor_state`. | ||
| // | ||
| // This is very optimizer friendly for the fast path - initialized but | ||
| // not yet dropped. | ||
| inner: LazyKeyInner<T>, | ||
|
|
||
| // Metadata to keep track of the state of the destructor. Remember that | ||
| // this variable is thread-local, not global. | ||
| dtor_state: Cell<DtorState>, | ||
| } | ||
|
|
||
| impl<T> fmt::Debug for Key<T> { | ||
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { | ||
| f.debug_struct("Key").finish_non_exhaustive() | ||
| } | ||
| } | ||
|
|
||
| impl<T> Key<T> { | ||
| pub const fn new() -> Key<T> { | ||
| Key { inner: LazyKeyInner::new(), dtor_state: Cell::new(DtorState::Unregistered) } | ||
| } | ||
|
|
||
| // note that this is just a publicly-callable function only for the | ||
| // const-initialized form of thread locals, basically a way to call the | ||
| // free `register_dtor` function defined elsewhere in std. | ||
| pub unsafe fn register_dtor(a: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) { | ||
| unsafe { | ||
| register_dtor(a, dtor); | ||
| } | ||
| } | ||
|
|
||
| pub unsafe fn get<F: FnOnce() -> T>(&self, init: F) -> Option<&'static T> { | ||
| // SAFETY: See the definitions of `LazyKeyInner::get` and | ||
| // `try_initialize` for more information. | ||
| // | ||
| // The caller must ensure no mutable references are ever active to | ||
| // the inner cell or the inner T when this is called. | ||
| // The `try_initialize` is dependant on the passed `init` function | ||
| // for this. | ||
| unsafe { | ||
| match self.inner.get() { | ||
| Some(val) => Some(val), | ||
| None => self.try_initialize(init), | ||
| } | ||
| } | ||
| } | ||
|
|
||
| // `try_initialize` is only called once per fast thread local variable, | ||
| // except in corner cases where thread_local dtors reference other | ||
| // thread_local's, or it is being recursively initialized. | ||
| // | ||
| // Macos: Inlining this function can cause two `tlv_get_addr` calls to | ||
workingjubilee marked this conversation as resolved.
Show resolved
Hide resolved
|
||
| // be performed for every call to `Key::get`. | ||
| // LLVM issue: https://bugs.llvm.org/show_bug.cgi?id=41722 | ||
| #[inline(never)] | ||
| unsafe fn try_initialize<F: FnOnce() -> T>(&self, init: F) -> Option<&'static T> { | ||
| // SAFETY: See comment above (this function doc). | ||
| if !mem::needs_drop::<T>() || unsafe { self.try_register_dtor() } { | ||
| // SAFETY: See comment above (this function doc). | ||
| Some(unsafe { self.inner.initialize(init) }) | ||
| } else { | ||
| None | ||
| } | ||
| } | ||
|
|
||
| // `try_register_dtor` is only called once per fast thread local | ||
| // variable, except in corner cases where thread_local dtors reference | ||
| // other thread_local's, or it is being recursively initialized. | ||
workingjubilee marked this conversation as resolved.
Show resolved
Hide resolved
|
||
| unsafe fn try_register_dtor(&self) -> bool { | ||
| match self.dtor_state.get() { | ||
| DtorState::Unregistered => { | ||
| // SAFETY: dtor registration happens before initialization. | ||
| // Passing `self` as a pointer while using `destroy_value<T>` | ||
| // is safe because the function will build a pointer to a | ||
| // Key<T>, which is the type of self and so find the correct | ||
| // size. | ||
| unsafe { register_dtor(self as *const _ as *mut u8, destroy_value::<T>) }; | ||
| self.dtor_state.set(DtorState::Registered); | ||
| true | ||
| } | ||
| DtorState::Registered => { | ||
| // recursively initialized | ||
| true | ||
| } | ||
| DtorState::RunningOrHasRun => false, | ||
| } | ||
| } | ||
| } | ||
|
|
||
| unsafe extern "C" fn destroy_value<T>(ptr: *mut u8) { | ||
| let ptr = ptr as *mut Key<T>; | ||
|
|
||
| // SAFETY: | ||
| // | ||
| // The pointer `ptr` has been built just above and comes from | ||
| // `try_register_dtor` where it is originally a Key<T> coming from `self`, | ||
| // making it non-NUL and of the correct type. | ||
workingjubilee marked this conversation as resolved.
Show resolved
Hide resolved
|
||
| // | ||
| // Right before we run the user destructor be sure to set the | ||
| // `Option<T>` to `None`, and `dtor_state` to `RunningOrHasRun`. This | ||
| // causes future calls to `get` to run `try_initialize_drop` again, | ||
| // which will now fail, and return `None`. | ||
| // | ||
| // Wrap the call in a catch to ensure unwinding is caught in the event | ||
| // a panic takes place in a destructor. | ||
| if let Err(_) = panic::catch_unwind(panic::AssertUnwindSafe(|| unsafe { | ||
| let value = (*ptr).inner.take(); | ||
| (*ptr).dtor_state.set(DtorState::RunningOrHasRun); | ||
| drop(value); | ||
| })) { | ||
| rtabort!("thread local panicked on drop"); | ||
| } | ||
| } | ||
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
BeRunning?
BeganRunning
RunningStart
WouldEnglishPleaseGetARealPerfectiveTense
( these are silly thoughts, pay me no mind. )