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

@@ -1,3 +1,5 @@
+#![allow(unused)]
+
 use std::any::Any;
 use std::cell::{Cell, RefCell};
 use std::collections::BTreeSet;
@@ -326,120 +328,23 @@ pub enum Kind {
 impl<'a> Builder<'a> {
     fn get_step_descriptions(kind: Kind) -> Vec<StepDescription> {
         macro_rules! describe {
-            ($($rule:ty),+ $(,)?) => {{
-                vec![$(StepDescription::from::<$rule>()),+]
+            ($($rule:ty),* $(,)?) => {{
+                vec![$(StepDescription::from::<$rule>()),*]
             }};
         }
         match kind {
             Kind::Build => describe!(
-                compile::Std,
-                compile::Test,
-                compile::Rustc,
-                compile::CodegenBackend,
-                compile::StartupObjects,
-                tool::BuildManifest,
-                tool::Rustbook,
-                tool::ErrorIndex,
-                tool::UnstableBookGen,
-                tool::Tidy,
-                tool::Linkchecker,
-                tool::CargoTest,
-                tool::Compiletest,
-                tool::RemoteTestServer,
-                tool::RemoteTestClient,
-                tool::RustInstaller,
-                tool::Cargo,
-                tool::Rls,
-                tool::Rustdoc,
-                tool::Clippy,
-                native::Llvm,
-                tool::Rustfmt,
-                tool::Miri,
-                native::Lld
             ),
             Kind::Check => describe!(
-                check::Std,
-                check::Test,
-                check::Rustc,
-                check::CodegenBackend,
-                check::Rustdoc
             ),
             Kind::Test => describe!(
                 test::Tidy,
-                test::Ui,
-                test::RunPass,
-                test::CompileFail,
-                test::RunFail,
-                test::RunPassValgrind,
-                test::MirOpt,
-                test::Codegen,
-                test::CodegenUnits,
-                test::Assembly,
-                test::Incremental,
-                test::Debuginfo,
-                test::UiFullDeps,
-                test::RunPassFullDeps,
-                test::Rustdoc,
-                test::Pretty,
-                test::RunPassPretty,
-                test::RunFailPretty,
-                test::RunPassValgrindPretty,
-                test::Crate,
-                test::CrateLibrustc,
-                test::CrateRustdoc,
-                test::Linkcheck,
-                test::Cargotest,
-                test::Cargo,
-                test::Rls,
-                test::ErrorIndex,
-                test::Distcheck,
-                test::RunMakeFullDeps,
-                test::Nomicon,
-                test::Reference,
-                test::RustdocBook,
-                test::RustByExample,
-                test::TheBook,
-                test::UnstableBook,
-                test::RustcBook,
-                test::EmbeddedBook,
-                test::EditionGuide,
-                test::Rustfmt,
-                test::Miri,
-                test::Clippy,
-                test::CompiletestTest,
-                test::RustdocJSStd,
-                test::RustdocJSNotStd,
-                test::RustdocTheme,
-                test::RustdocUi,
-                // Run bootstrap close to the end as it's unlikely to fail
-                test::Bootstrap,
-                // Run run-make last, since these won't pass without make on Windows
-                test::RunMake,
             ),
-            Kind::Bench => describe!(test::Crate, test::CrateLibrustc),
+            Kind::Bench => describe!(
+            ),
             Kind::Doc => describe!(
-                doc::UnstableBook,
-                doc::UnstableBookGen,
-                doc::TheBook,
-                doc::Standalone,
-                doc::Std,
-                doc::Test,
-                doc::WhitelistedRustc,
-                doc::Rustc,
-                doc::Rustdoc,
-                doc::ErrorIndex,
-                doc::Nomicon,
-                doc::Reference,
-                doc::RustdocBook,
-                doc::RustByExample,
-                doc::RustcBook,
-                doc::CargoBook,
-                doc::EmbeddedBook,
-                doc::EditionGuide,
             ),
             Kind::Dist => describe!(
-                dist::Docs,
-                dist::RustcDocs,
                 dist::Mingw,
                 dist::Rustc,
                 dist::DebuggerScripts,
@@ -458,16 +363,6 @@ impl<'a> Builder<'a> {
                 dist::HashSign
             ),
             Kind::Install => describe!(
-                install::Docs,
-                install::Std,
-                install::Cargo,
-                install::Rls,
-                install::Rustfmt,
-                install::Clippy,
-                install::Miri,
-                install::Analysis,
-                install::Src,
-                install::Rustc
             ),
         }
     }

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();