On nightly, use std::thread::current_id()

This avoids the performance problems with std::thread::current(),
meaning StdThreadId can just wrap the stdlib without needing a thread_local.

Author: Techcable

benchmarks/Cargo.toml

@@ -4,13 +4,16 @@ description = "Benchmarks for the threadid crate"
 version = "0.0.0"
 license = "Apache-2.0 OR MIT"
 repository = "https://github.com/Techcable/threadid.rs"
-publish = false  # internal use only
+publish = false # internal use only
 edition = "2021"
 
 [dev-dependencies]
 threadid.path = ".."
 criterion = "0.8"
 
+[build-dependencies]
+rustversion = "1"
+
 [[bench]]
 name = "access"
 required-features = []

benchmarks/benches/access.rs

@@ -1,5 +1,7 @@
 #![allow(clippy::redundant_closure)] // slightly cleaner
+#![cfg_attr(nightly, feature(current_thread_id))]
 
+use cfg_if::cfg_if;
 use criterion::{Criterion, criterion_group, criterion_main};
 use threadid::{LiveThreadId, StdThreadId, UniqueThreadId};
 
@@ -9,7 +11,19 @@ fn std_current(c: &mut Criterion) {
     });
 }
 
-fn std_id_current(c: &mut Criterion) {
+fn std_current_id(c: &mut Criterion) {
+    cfg_if! {
+        if #[cfg(has_thread_current_id)] {
+            c.bench_function("std::thread::current_id()", |x| {
+                x.iter(|| std::thread::current_id())
+            });
+        } else {
+            let _ = c;
+        }
+    }
+}
+
+fn threadid_std_current(c: &mut Criterion) {
     c.bench_function("threadid::StdThreadId::current()", |x| {
         x.iter(|| StdThreadId::current())
     });
@@ -27,5 +41,12 @@ fn live_id_current(c: &mut Criterion) {
     });
 }
 
-criterion_group!(access, std_current, std_id_current, unique_id_current, live_id_current);
+criterion_group!(
+    access,
+    std_current,
+    std_current_id,
+    threadid_std_current,
+    unique_id_current,
+    live_id_current
+);
 criterion_main!(access);

benchmarks/build.rs

@@ -0,0 +1,8 @@
+pub fn main() {
+    println!("cargo:rustc-check-cfg=cfg(has_thread_current_id)");
+    println!("cargo:rustc-check-cfg=cfg(nightly)");
+    if rustversion::cfg!(nightly) {
+        println!("cargo:rustc-cfg=has_thread_current_id");
+        println!("cargo:rustc-cfg=nightly");
+    }
+}

src/lib.rs

@@ -31,6 +31,8 @@
     feature(
         // used to make UniqueThreadId match std::thread::ThreadId
         thread_id_value,
+        // used to quickly access the std thread id
+        current_thread_id,
     )
 )]
 #![cfg_attr(feature = "nightly-docs", feature(doc_cfg))]

src/std.rs

@@ -1,11 +1,14 @@
 //! Wraps [`std::thread::ThreadId`], providng faster lookup.
 use core::borrow::Borrow;
+#[cfg(not(feature = "nightly"))]
 use core::cell::Cell;
 use core::ops::Deref;
 use std::thread::ThreadId;
 
+use cfg_if::cfg_if;
 use equivalent::Equivalent;
 
+#[cfg(not(feature = "nightly"))]
 fast_thread_local! {
     static STD_TID: Cell<Option<StdThreadId>> = Cell::new(None);
 }
@@ -24,14 +27,20 @@ impl StdThreadId {
     /// Lookup the [`std::thread::ThreadId`] of the current thread.
     #[inline]
     pub fn current() -> Self {
-        STD_TID.with(|cell| match cell.get() {
-            None => {
-                let new_id = Self::acquire();
-                cell.set(Some(new_id));
-                new_id
+        cfg_if! {
+            if #[cfg(feature = "nightly")] {
+                StdThreadId(std::thread::current_id())
+            } else {
+                STD_TID.with(|cell| match cell.get() {
+                    None => {
+                        let new_id = Self::acquire();
+                        cell.set(Some(new_id));
+                        new_id
+                    }
+                    Some(existing) => existing,
+                })
             }
-            Some(existing) => existing,
-        })
+        }
     }
 }
 #[cfg_attr(feature = "nightly-docs", doc(cfg(feature = "std")))]
@@ -55,6 +64,7 @@ unsafe impl crate::IThreadId for ThreadId {
 }
 impl StdThreadId {
     #[cold]
+    #[cfg(not(feature = "nightly"))]
     fn acquire() -> StdThreadId {
         StdThreadId(std::thread::current().id())
     }