Auto merge of #59749 - petrochenkov:upspan, r=<try>

[do not merge] Measure upper limit for performance of 32 bit `Span`

What would happen if span interner accesses were cheap and didn't require any synchronization?

r? @ghost

Author: bors

src/bootstrap/builder.rs

@@ -438,8 +438,8 @@ impl<'a> Builder<'a> {
                 doc::EditionGuide,
             ),
             Kind::Dist => describe!(
-                dist::Docs,
-                dist::RustcDocs,
+                // dist::Docs,
+                // dist::RustcDocs,
                 dist::Mingw,
                 dist::Rustc,
                 dist::DebuggerScripts,

src/bootstrap/doc.rs

@@ -310,14 +310,15 @@ impl Step for TheBook {
         });
 
         // build the redirect pages
-        builder.info(&format!("Documenting book redirect pages ({})", target));
-        for file in t!(fs::read_dir(builder.src.join("src/doc/book/redirects"))) {
-            let file = t!(file);
-            let path = file.path();
-            let path = path.to_str().unwrap();
-
-            invoke_rustdoc(builder, compiler, target, path);
-        }
+        // builder.info(&format!("Documenting book redirect pages ({})", target));
+        // for file in t!(fs::read_dir(builder.src.join("src/doc/book/redirects"))) {
+        //     let file = t!(file);
+        //     let path = file.path();
+        //     let path = path.to_str().unwrap();
+
+        //     invoke_rustdoc(builder, compiler, target, path);
+        // }
+        let _ = invoke_rustdoc;
     }
 }
 

src/librustc_data_structures/sync.rs

@@ -517,7 +517,7 @@ impl<T> Once<T> {
 }
 
 #[derive(Debug)]
-pub struct Lock<T>(InnerLock<T>);
+pub struct Lock<T>(pub InnerLock<T>);
 
 impl<T> Lock<T> {
     #[inline(always)]

src/libsyntax/lib.rs

@@ -98,7 +98,11 @@ pub fn with_globals<F, R>(f: F) -> R
 {
     let globals = Globals::new();
     GLOBALS.set(&globals, || {
-        syntax_pos::GLOBALS.set(&globals.syntax_pos_globals, f)
+        syntax_pos::GLOBALS.set(&globals.syntax_pos_globals, unsafe {
+            syntax_pos::SPAN_INTERNER_BACKDOOR =
+                globals.syntax_pos_globals.span_interner.0.as_ptr();
+            f
+        })
     })
 }
 

src/libsyntax_pos/hygiene.rs

@@ -218,14 +218,17 @@ pub fn clear_markings() {
 }
 
 impl SyntaxContext {
+    #[inline]
     pub const fn empty() -> Self {
         SyntaxContext(0)
     }
 
+    #[inline]
     crate fn as_u32(self) -> u32 {
         self.0
     }
 
+    #[inline]
     crate fn from_u32(raw: u32) -> SyntaxContext {
         SyntaxContext(raw)
     }

src/libsyntax_pos/lib.rs

@@ -18,6 +18,7 @@
 #![feature(rustc_attrs)]
 #![feature(specialization)]
 #![feature(step_trait)]
+#![feature(stmt_expr_attributes)]
 
 use serialize::{Encodable, Decodable, Encoder, Decoder};
 
@@ -29,7 +30,7 @@ pub mod hygiene;
 pub use hygiene::{Mark, SyntaxContext, ExpnInfo, ExpnFormat, CompilerDesugaringKind};
 
 mod span_encoding;
-pub use span_encoding::{Span, DUMMY_SP};
+pub use span_encoding::{Span, DUMMY_SP, SPAN_INTERNER_BACKDOOR};
 
 pub mod symbol;
 
@@ -48,7 +49,7 @@ use std::path::PathBuf;
 
 pub struct Globals {
     symbol_interner: Lock<symbol::Interner>,
-    span_interner: Lock<span_encoding::SpanInterner>,
+    pub span_interner: Lock<span_encoding::SpanInterner>,
     hygiene_data: Lock<hygiene::HygieneData>,
 }
 

src/libsyntax_pos/span_encoding.rs

@@ -4,45 +4,19 @@
 // The encoding format for inline spans were obtained by optimizing over crates in rustc/libstd.
 // See https://internals.rust-lang.org/t/rfc-compiler-refactoring-spans/1357/28
 
-use crate::GLOBALS;
 use crate::{BytePos, SpanData};
 use crate::hygiene::SyntaxContext;
 
 use rustc_data_structures::fx::FxHashMap;
-use std::hash::{Hash, Hasher};
 
 /// A compressed span.
 /// Contains either fields of `SpanData` inline if they are small, or index into span interner.
 /// The primary goal of `Span` is to be as small as possible and fit into other structures
 /// (that's why it uses `packed` as well). Decoding speed is the second priority.
 /// See `SpanData` for the info on span fields in decoded representation.
-#[repr(packed)]
+#[derive(Clone, Copy, Eq, PartialEq, Hash)]
 pub struct Span(u32);
 
-impl Copy for Span {}
-impl Clone for Span {
-    #[inline]
-    fn clone(&self) -> Span {
-        *self
-    }
-}
-impl PartialEq for Span {
-    #[inline]
-    fn eq(&self, other: &Span) -> bool {
-        let a = self.0;
-        let b = other.0;
-        a == b
-    }
-}
-impl Eq for Span {}
-impl Hash for Span {
-    #[inline]
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        let a = self.0;
-        a.hash(state)
-    }
-}
-
 /// Dummy span, both position and length are zero, syntax context is zero as well.
 /// This span is kept inline and encoded with format 0.
 pub const DUMMY_SP: Span = Span(0);
@@ -98,7 +72,7 @@ fn encode(sd: &SpanData) -> Span {
         (base << INLINE_OFFSETS[BASE_INDEX]) | (len << INLINE_OFFSETS[LEN_INDEX]) |
         (ctxt << INLINE_OFFSETS[CTXT_INDEX]) | TAG_INLINE
     } else {
-        let index = with_span_interner(|interner| interner.intern(sd));
+        let index = unsafe { (*SPAN_INTERNER_BACKDOOR).intern(sd) };
         (index << INTERNED_INDEX_OFFSET) | TAG_INTERNED
     };
     Span(val)
@@ -109,7 +83,7 @@ fn decode(span: Span) -> SpanData {
     let val = span.0;
 
     // Extract a field at position `pos` having size `size`.
-    let extract = |pos: u32, size: u32| {
+    let extract = #[inline] |pos: u32, size: u32| {
         let mask = ((!0u32) as u64 >> (32 - size)) as u32; // Can't shift u32 by 32
         (val >> pos) & mask
     };
@@ -120,7 +94,7 @@ fn decode(span: Span) -> SpanData {
         extract(INLINE_OFFSETS[CTXT_INDEX], INLINE_SIZES[CTXT_INDEX]),
     )} else {
         let index = extract(INTERNED_INDEX_OFFSET, INTERNED_INDEX_SIZE);
-        return with_span_interner(|interner| *interner.get(index));
+        return unsafe { *(*SPAN_INTERNER_BACKDOOR).get(index) };
     };
     SpanData { lo: BytePos(base), hi: BytePos(base + len), ctxt: SyntaxContext::from_u32(ctxt) }
 }
@@ -149,8 +123,4 @@ impl SpanInterner {
     }
 }
 
-// If an interner exists, return it. Otherwise, prepare a fresh one.
-#[inline]
-fn with_span_interner<T, F: FnOnce(&mut SpanInterner) -> T>(f: F) -> T {
-    GLOBALS.with(|globals| f(&mut *globals.span_interner.lock()))
-}
+pub static mut SPAN_INTERNER_BACKDOOR: *mut SpanInterner = std::ptr::null_mut();