Add a AtomicOnce type

Author: Zoxc

src/librustc/ty/context.rs

@@ -50,9 +50,8 @@ use rustc_data_structures::stable_hasher::{HashStable, hash_stable_hashmap,
                                            StableHasher, StableHasherResult,
                                            StableVec};
 use arena::{TypedArena, SyncDroplessArena};
-use rustc_data_structures::cold_path;
 use rustc_data_structures::indexed_vec::{Idx, IndexVec};
-use rustc_data_structures::sync::{Lrc, Lock, WorkerLocal, AtomicCell};
+use rustc_data_structures::sync::{Lrc, Lock, WorkerLocal, AtomicOnce};
 use std::any::Any;
 use std::borrow::Borrow;
 use std::cmp::Ordering;
@@ -1031,7 +1030,7 @@ pub struct GlobalCtxt<'tcx> {
 
     pub hir_defs: hir::map::Definitions,
 
-    hir_map: AtomicCell<Option<&'tcx hir_map::Map<'tcx>>>,
+    hir_map: AtomicOnce<&'tcx hir_map::Map<'tcx>>,
 
     /// A map from DefPathHash -> DefId. Includes DefIds from the local crate
     /// as well as all upstream crates. Only populated in incremental mode.
@@ -1104,18 +1103,11 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
     }
 
     #[inline(always)]
-    pub fn hir(self) -> &'a hir_map::Map<'gcx> {
-        let value = self.hir_map.load();
-        if unlikely!(value.is_none()) {
+    pub fn hir(self) -> &'gcx hir_map::Map<'gcx> {
+        self.hir_map.get_or_init(|| {
             // We can use `with_ignore` here because the hir map does its own tracking
-            cold_path(|| self.dep_graph.with_ignore(|| {
-                let map = self.hir_map(LOCAL_CRATE);
-                self.hir_map.store(Some(map));
-                map
-            }))
-        } else {
-            value.unwrap()
-        }
+            self.dep_graph.with_ignore(|| self.hir_map(LOCAL_CRATE))
+        })
     }
 
     pub fn alloc_generics(self, generics: ty::Generics) -> &'gcx ty::Generics {
@@ -1307,7 +1299,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
             extern_prelude: resolutions.extern_prelude,
             hir_forest,
             hir_defs,
-            hir_map: AtomicCell::new(None),
+            hir_map: AtomicOnce::new(),
             def_path_hash_to_def_id,
             queries: query::Queries::new(
                 providers,

src/librustc_data_structures/sync.rs

@@ -21,6 +21,7 @@ use std::collections::HashMap;
 use std::hash::{Hash, BuildHasher};
 use std::marker::PhantomData;
 use std::ops::{Deref, DerefMut};
+use crate::cold_path;
 use crate::owning_ref::{Erased, OwningRef};
 
 pub fn serial_join<A, B, RA, RB>(oper_a: A, oper_b: B) -> (RA, RB)
@@ -573,6 +574,34 @@ impl<T> Once<T> {
     }
 }
 
+/// A type whose inner value can be written once and then will stay read-only
+pub struct AtomicOnce<T: Copy>(AtomicCell<Option<T>>);
+
+impl<T: Copy> AtomicOnce<T> {
+    /// Creates an AtomicOnce value which is uninitialized
+    #[inline]
+    pub fn new() -> Self {
+        AtomicOnce(AtomicCell::new(None))
+    }
+
+    /// Gets the inner value. If the value is not already initalized.
+    /// It will be initalized by the closure. The closure may be called
+    /// concurrently by many threads.
+    #[inline(always)]
+    pub fn get_or_init(&self, f: impl FnOnce() -> T) -> T {
+        let value = self.0.load();
+        if unlikely!(value.is_none()) {
+            cold_path(|| {
+                let value = f();
+                self.0.store(Some(value));
+                value
+            })
+        } else {
+            value.unwrap()
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct Lock<T>(InnerLock<T>);