Merge pull request #875 from uuid-rs/fix/context-ordering

KodrAus · web-flow · commit 996dadea029e · 2026-03-27T08:04:13.000+10:00
Use LazyLock to synchronize v1/v6 context initialization
diff --git a/src/timestamp.rs b/src/timestamp.rs
@@ -482,28 +482,17 @@ pub mod context {
     mod v1_support {
         use super::*;
 
-        use atomic::{Atomic, Ordering};
-
         #[cfg(all(feature = "std", feature = "rng"))]
-        static CONTEXT: ContextV1 = ContextV1 {
-            count: Atomic::new(0),
-        };
+        use crate::std::sync::LazyLock;
 
-        #[cfg(all(feature = "std", feature = "rng"))]
-        static CONTEXT_INITIALIZED: Atomic<bool> = Atomic::new(false);
+        use atomic::{Atomic, Ordering};
 
         #[cfg(all(feature = "std", feature = "rng"))]
-        pub(crate) fn shared_context() -> &'static ContextV1 {
-            // If the context is in its initial state then assign it to a random value
-            // It doesn't matter if multiple threads observe `false` here and initialize the context
-            if CONTEXT_INITIALIZED
-                .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed)
-                .is_ok()
-            {
-                CONTEXT.count.store(crate::rng::u16(), Ordering::Release);
-            }
+        static CONTEXT: LazyLock<ContextV1> = LazyLock::new(ContextV1::new_random);
 
-            &CONTEXT
+        #[cfg(all(feature = "std", feature = "rng"))]
+        pub(crate) fn shared_context_v1() -> &'static ContextV1 {
+            &*CONTEXT
         }
 
         /// An internally synchronized, wrapping counter that produces 14-bit values for version 1 and version 6 UUIDs.
@@ -862,35 +851,7 @@ pub mod context {
             }
         }
 
-        #[derive(Debug)]
-        struct Adjust {
-            by_ns: u128,
-        }
-
-        impl Adjust {
-            #[inline]
-            fn by_millis(millis: u32) -> Self {
-                Adjust {
-                    by_ns: (millis as u128).saturating_mul(1_000_000),
-                }
-            }
-
-            #[inline]
-            fn apply(&self, seconds: u64, subsec_nanos: u32) -> (u64, u32) {
-                if self.by_ns == 0 {
-                    // No shift applied
-                    return (seconds, subsec_nanos);
-                }
-
-                let ts = (seconds as u128)
-                    .saturating_mul(1_000_000_000)
-                    .saturating_add(subsec_nanos as u128)
-                    .saturating_add(self.by_ns);
-
-                ((ts / 1_000_000_000) as u64, (ts % 1_000_000_000) as u32)
-            }
-        }
-
+        /// A timestamp that keeps track of whether a reseed is necessary.
         #[derive(Debug, Default, Clone, Copy)]
         struct ReseedingTimestamp {
             last_seed: u64,
@@ -899,6 +860,21 @@ pub mod context {
         }
 
         impl ReseedingTimestamp {
+            #[inline]
+            fn from_ts(seconds: u64, subsec_nanos: u32) -> Self {
+                // Reseed when the millisecond advances
+                let last_seed = seconds
+                    .saturating_mul(1_000)
+                    .saturating_add((subsec_nanos / 1_000_000) as u64);
+
+                ReseedingTimestamp {
+                    last_seed,
+                    seconds,
+                    subsec_nanos,
+                }
+            }
+
+            /// Advance the timestamp to a new value, returning whether a reseed is necessary.
             #[inline]
             fn advance(&self, seconds: u64, subsec_nanos: u32) -> (Self, bool) {
                 let incoming = ReseedingTimestamp::from_ts(seconds, subsec_nanos);
@@ -916,20 +892,7 @@ pub mod context {
                 }
             }
 
-            #[inline]
-            fn from_ts(seconds: u64, subsec_nanos: u32) -> Self {
-                // Reseed when the millisecond advances
-                let last_seed = seconds
-                    .saturating_mul(1_000)
-                    .saturating_add((subsec_nanos / 1_000_000) as u64);
-
-                ReseedingTimestamp {
-                    last_seed,
-                    seconds,
-                    subsec_nanos,
-                }
-            }
-
+            /// Advance the timestamp by a millisecond.
             #[inline]
             fn increment(&self) -> Self {
                 let (seconds, subsec_nanos) =
@@ -944,6 +907,76 @@ pub mod context {
             }
         }
 
+        /// A counter that initializes to a safe random seed and tracks overflow.
+        #[derive(Debug, Clone, Copy)]
+        struct Counter {
+            value: u64,
+        }
+
+        impl Counter {
+            #[inline]
+            fn reseed(precision: &Precision, timestamp: &ReseedingTimestamp) -> Self {
+                Counter {
+                    value: precision.apply(crate::rng::u64() & RESEED_MASK, timestamp),
+                }
+            }
+
+            /// Advance the counter.
+            #[inline]
+            fn increment(&self, precision: &Precision, timestamp: &ReseedingTimestamp) -> Self {
+                let mut counter = Counter {
+                    value: precision.apply(self.value, timestamp),
+                };
+
+                // We unconditionally increment the counter even though the precision
+                // may have set higher bits already. This could technically be avoided,
+                // but the higher bits are a coarse approximation so we just avoid the
+                // `if` branch and increment it either way
+
+                // Guaranteed to never overflow u64
+                counter.value += 1;
+
+                counter
+            }
+
+            #[inline]
+            fn has_overflowed(&self) -> bool {
+                self.value > MAX_COUNTER
+            }
+        }
+
+        /// A utility that adjusts an input timestamp by a given number of nanoseconds.
+        #[derive(Debug)]
+        struct Adjust {
+            by_ns: u128,
+        }
+
+        impl Adjust {
+            #[inline]
+            fn by_millis(millis: u32) -> Self {
+                Adjust {
+                    by_ns: (millis as u128).saturating_mul(1_000_000),
+                }
+            }
+
+            /// Apply the adjustment, returning the adjusted timestamp.
+            #[inline]
+            fn apply(&self, seconds: u64, subsec_nanos: u32) -> (u64, u32) {
+                if self.by_ns == 0 {
+                    // No shift applied
+                    return (seconds, subsec_nanos);
+                }
+
+                let ts = (seconds as u128)
+                    .saturating_mul(1_000_000_000)
+                    .saturating_add(subsec_nanos as u128)
+                    .saturating_add(self.by_ns);
+
+                ((ts / 1_000_000_000) as u64, (ts % 1_000_000_000) as u32)
+            }
+        }
+
+        /// A utility that overwrites some number of counter bits with additional timestamp precision.
         #[derive(Debug)]
         struct Precision {
             bits: usize,
@@ -971,52 +1004,17 @@ pub mod context {
                 }
             }
 
+            /// Apply additional precision from the given timestamp to the counter.
             #[inline]
-            fn apply(&self, value: u64, timestamp: &ReseedingTimestamp) -> u64 {
+            fn apply(&self, counter: u64, timestamp: &ReseedingTimestamp) -> u64 {
                 if self.bits == 0 {
                     // No additional precision is being used
-                    return value;
+                    return counter;
                 }
 
                 let additional = timestamp.submilli_nanos() as u64 / self.factor;
 
-                (value & self.mask) | (additional << self.shift)
-            }
-        }
-
-        #[derive(Debug, Clone, Copy)]
-        struct Counter {
-            value: u64,
-        }
-
-        impl Counter {
-            #[inline]
-            fn reseed(precision: &Precision, timestamp: &ReseedingTimestamp) -> Self {
-                Counter {
-                    value: precision.apply(crate::rng::u64() & RESEED_MASK, timestamp),
-                }
-            }
-
-            #[inline]
-            fn increment(&self, precision: &Precision, timestamp: &ReseedingTimestamp) -> Self {
-                let mut counter = Counter {
-                    value: precision.apply(self.value, timestamp),
-                };
-
-                // We unconditionally increment the counter even though the precision
-                // may have set higher bits already. This could technically be avoided,
-                // but the higher bits are a coarse approximation so we just avoid the
-                // `if` branch and increment it either way
-
-                // Guaranteed to never overflow u64
-                counter.value += 1;
-
-                counter
-            }
-
-            #[inline]
-            fn has_overflowed(&self) -> bool {
-                self.value > MAX_COUNTER
+                (counter & self.mask) | (additional << self.shift)
             }
         }
 
diff --git a/src/v1.rs b/src/v1.rs
@@ -21,7 +21,7 @@ impl Uuid {
     /// to be enabled.
     #[cfg(all(feature = "std", feature = "rng"))]
     pub fn now_v1(node_id: &[u8; 6]) -> Self {
-        let ts = Timestamp::now(crate::timestamp::context::shared_context());
+        let ts = Timestamp::now(crate::timestamp::context::shared_context_v1());
 
         Self::new_v1(ts, node_id)
     }
diff --git a/src/v6.rs b/src/v6.rs
@@ -17,7 +17,7 @@ impl Uuid {
     /// to be enabled.
     #[cfg(all(feature = "std", feature = "rng"))]
     pub fn now_v6(node_id: &[u8; 6]) -> Self {
-        let ts = Timestamp::now(crate::timestamp::context::shared_context());
+        let ts = Timestamp::now(crate::timestamp::context::shared_context_v1());
 
         Self::new_v6(ts, node_id)
     }
diff --git a/src/v7.rs b/src/v7.rs
@@ -3,7 +3,9 @@
 //! Note that you need to enable the `v7` Cargo feature
 //! in order to use this module.
 
-use crate::{rng, std::cmp, timestamp::Timestamp, Builder, Uuid};
+use core::cmp;
+
+use crate::{rng, timestamp::Timestamp, Builder, Uuid};
 
 impl Uuid {
     /// Create a new version 7 UUID using the current time value.

Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ impl Uuid {`
`21`	`21`	`/// to be enabled.`
`22`	`22`	`#[cfg(all(feature = "std", feature = "rng"))]`
`23`	`23`	`pub fn now_v1(node_id: &[u8; 6]) -> Self {`
`24`		`- let ts = Timestamp::now(crate::timestamp::context::shared_context());`
	`24`	`+ let ts = Timestamp::now(crate::timestamp::context::shared_context_v1());`
`25`	`25`
`26`	`26`	`Self::new_v1(ts, node_id)`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ impl Uuid {`
`17`	`17`	`/// to be enabled.`
`18`	`18`	`#[cfg(all(feature = "std", feature = "rng"))]`
`19`	`19`	`pub fn now_v6(node_id: &[u8; 6]) -> Self {`
`20`		`- let ts = Timestamp::now(crate::timestamp::context::shared_context());`
	`20`	`+ let ts = Timestamp::now(crate::timestamp::context::shared_context_v1());`
`21`	`21`
`22`	`22`	`Self::new_v6(ts, node_id)`
`23`	`23`	`}`