add rustc-pr-pending changes

Author: nia-e

miri-script/src/commands.rs

@@ -1,4 +1,4 @@
-use std::collections::BTreeMap;
+use std::collections::HashMap;
 use std::ffi::{OsStr, OsString};
 use std::fmt::Write as _;
 use std::fs::{self, File};
@@ -489,9 +489,7 @@ impl Command {
             sh.read_dir(benches_dir)?
                 .into_iter()
                 .filter(|path| path.is_dir())
-                // Only keep the basename: that matches the usage with a manual bench list,
-                // and it ensure the path concatenations below work as intended.
-                .map(|path| path.file_name().unwrap().to_owned().into_string().unwrap())
+                .map(|path| path.into_os_string().into_string().unwrap())
                 .collect()
         } else {
             benches.into_iter().collect()
@@ -532,16 +530,14 @@ impl Command {
             stddev: f64,
         }
 
-        let gather_results = || -> Result<BTreeMap<&str, BenchResult>> {
+        let gather_results = || -> Result<HashMap<&str, BenchResult>> {
             let baseline_temp_dir = results_json_dir.unwrap();
-            let mut results = BTreeMap::new();
+            let mut results = HashMap::new();
             for bench in &benches {
-                let result = File::open(path!(baseline_temp_dir / format!("{bench}.bench.json")))
-                    .context("failed to read hyperfine JSON")?;
-                let mut result: serde_json::Value = serde_json::from_reader(BufReader::new(result))
-                    .context("failed to parse hyperfine JSON")?;
-                let result: BenchResult = serde_json::from_value(result["results"][0].take())
-                    .context("failed to interpret hyperfine JSON")?;
+                let result = File::open(path!(baseline_temp_dir / format!("{bench}.bench.json")))?;
+                let mut result: serde_json::Value =
+                    serde_json::from_reader(BufReader::new(result))?;
+                let result: BenchResult = serde_json::from_value(result["results"][0].take())?;
                 results.insert(bench as &str, result);
             }
             Ok(results)
@@ -553,15 +549,15 @@ impl Command {
             serde_json::to_writer_pretty(BufWriter::new(baseline), &results)?;
         } else if let Some(baseline_file) = load_baseline {
             let new_results = gather_results()?;
-            let baseline_results: BTreeMap<String, BenchResult> = {
+            let baseline_results: HashMap<String, BenchResult> = {
                 let f = File::open(baseline_file)?;
                 serde_json::from_reader(BufReader::new(f))?
             };
             println!(
                 "Comparison with baseline (relative speed, lower is better for the new results):"
             );
-            for (bench, new_result) in new_results {
-                let Some(baseline_result) = baseline_results.get(bench) else { continue };
+            for (bench, new_result) in new_results.iter() {
+                let Some(baseline_result) = baseline_results.get(*bench) else { continue };
 
                 // Compare results (inspired by hyperfine)
                 let ratio = new_result.mean / baseline_result.mean;

rust-version

@@ -1 +1 @@
-e7f4317ea0e891296163414c6f681ccec976abc3
+2b96ddca1272960623e41829439df8dae82d20af

src/alloc/alloc_bytes.rs

@@ -9,6 +9,12 @@ use rustc_middle::mir::interpret::AllocBytes;
 use crate::alloc::discrete_alloc::MachineAlloc;
 use crate::helpers::ToU64 as _;
 
+#[derive(Clone, Copy, Debug)]
+pub enum MiriByteMdata {
+    Global,
+    Isolated,
+}
+
 /// Allocation bytes that explicitly handle the layout of the data they're storing.
 /// This is necessary to interface with native code that accesses the program store in Miri.
 #[derive(Debug)]
@@ -21,15 +27,15 @@ pub struct MiriAllocBytes {
     /// * Otherwise, `self.ptr` points to memory allocated with `self.layout`.
     ptr: *mut u8,
     /// Whether this instance of `MiriAllocBytes` had its allocation created by calling `alloc::alloc()`
-    /// (true) or the discrete allocator (false)
-    alloc_is_global: bool,
+    /// (`Global`) or the discrete allocator (`Isolated`)
+    dsc: MiriByteMdata,
 }
 
 impl Clone for MiriAllocBytes {
     fn clone(&self) -> Self {
         let bytes: Cow<'_, [u8]> = Cow::Borrowed(self);
         let align = Align::from_bytes(self.layout.align().to_u64()).unwrap();
-        MiriAllocBytes::from_bytes(bytes, align)
+        MiriAllocBytes::from_bytes(bytes, align, self.dsc)
     }
 }
 
@@ -45,16 +51,15 @@ impl Drop for MiriAllocBytes {
 
         // SAFETY: Invariant, `self.ptr` points to memory allocated with `self.layout`.
         unsafe {
-            #[cfg(target_os = "linux")]
-            {
-                if self.alloc_is_global {
-                    alloc::dealloc(self.ptr, alloc_layout);
-                } else {
-                    MachineAlloc::dealloc(self.ptr, alloc_layout);
-                }
+            match self.dsc {
+                MiriByteMdata::Global => alloc::dealloc(self.ptr, alloc_layout),
+                MiriByteMdata::Isolated => {
+                    #[cfg(target_os = "linux")]
+                    {MachineAlloc::dealloc(self.ptr, alloc_layout)}
+                    #[cfg(not(target_os = "linux"))]
+                    {unreachable!()}
+                },
             }
-            #[cfg(not(target_os = "linux"))]
-            alloc::dealloc(self.ptr, alloc_layout);
         }
     }
 }
@@ -84,41 +89,45 @@ impl MiriAllocBytes {
     fn alloc_with(
         size: u64,
         align: u64,
-        alloc_fn: impl FnOnce(Layout) -> (*mut u8, bool),
+        dsc: MiriByteMdata,
+        alloc_fn: impl FnOnce(Layout) -> *mut u8,
     ) -> Result<MiriAllocBytes, ()> {
         let size = usize::try_from(size).map_err(|_| ())?;
         let align = usize::try_from(align).map_err(|_| ())?;
         let layout = Layout::from_size_align(size, align).map_err(|_| ())?;
         // When size is 0 we allocate 1 byte anyway, to ensure each allocation has a unique address.
         let alloc_layout =
             if size == 0 { Layout::from_size_align(1, align).unwrap() } else { layout };
-        let (ptr, alloc_is_global) = alloc_fn(alloc_layout);
+        let ptr = alloc_fn(alloc_layout);
         if ptr.is_null() {
             Err(())
         } else {
             // SAFETY: All `MiriAllocBytes` invariants are fulfilled.
-            Ok(Self { ptr, layout, alloc_is_global })
+            Ok(Self { ptr, layout, dsc })
         }
     }
 }
 
 impl AllocBytes for MiriAllocBytes {
-    fn from_bytes<'a>(slice: impl Into<Cow<'a, [u8]>>, align: Align) -> Self {
+    type ByteMetadata = MiriByteMdata;
+
+    fn from_bytes<'a>(slice: impl Into<Cow<'a, [u8]>>, align: Align, dsc: MiriByteMdata) -> Self {
         let slice = slice.into();
         let size = slice.len();
         let align = align.bytes();
         // SAFETY: `alloc_fn` will only be used with `size != 0`.
         let alloc_fn = |layout| unsafe {
-            #[cfg(target_os = "linux")]
-            {
-                MachineAlloc::alloc(layout)
-            }
-            #[cfg(not(target_os = "linux"))]
-            {
-                (alloc::alloc(layout), true)
+            match dsc {
+                MiriByteMdata::Global => alloc::alloc(layout),
+                MiriByteMdata::Isolated => {
+                    #[cfg(target_os = "linux")]
+                    {MachineAlloc::alloc(layout)}
+                    #[cfg(not(target_os = "linux"))]
+                    {unreachable!()}
+                },
             }
         };
-        let alloc_bytes = MiriAllocBytes::alloc_with(size.to_u64(), align, alloc_fn)
+        let alloc_bytes = MiriAllocBytes::alloc_with(size.to_u64(), align, dsc, alloc_fn)
             .unwrap_or_else(|()| {
                 panic!("Miri ran out of memory: cannot create allocation of {size} bytes")
             });
@@ -128,21 +137,22 @@ impl AllocBytes for MiriAllocBytes {
         alloc_bytes
     }
 
-    fn zeroed(size: Size, align: Align) -> Option<Self> {
+    fn zeroed(size: Size, align: Align, dsc: MiriByteMdata) -> Option<Self> {
         let size = size.bytes();
         let align = align.bytes();
         // SAFETY: `alloc_fn` will only be used with `size != 0`.
         let alloc_fn = |layout| unsafe {
-            #[cfg(target_os = "linux")]
-            {
-                MachineAlloc::alloc_zeroed(layout)
-            }
-            #[cfg(not(target_os = "linux"))]
-            {
-                (alloc::alloc_zeroed(layout), true)
+            match dsc {
+                MiriByteMdata::Global => alloc::alloc_zeroed(layout),
+                MiriByteMdata::Isolated => {
+                    #[cfg(target_os = "linux")]
+                    {MachineAlloc::alloc_zeroed(layout)}
+                    #[cfg(not(target_os = "linux"))]
+                    {unreachable!()}
+                },
             }
         };
-        MiriAllocBytes::alloc_with(size, align, alloc_fn).ok()
+        MiriAllocBytes::alloc_with(size, align, dsc, alloc_fn).ok()
     }
 
     fn as_mut_ptr(&mut self) -> *mut u8 {
@@ -152,4 +162,8 @@ impl AllocBytes for MiriAllocBytes {
     fn as_ptr(&self) -> *const u8 {
         self.ptr
     }
+
+    fn get_mdata(&self) -> MiriByteMdata {
+        self.dsc
+    }
 }

src/alloc/discrete_alloc.rs

@@ -25,38 +25,21 @@ pub struct MachineAlloc {
     allocated: Vec<Box<[u8]>>,
     /// The host (not emulated) page size.
     page_size: usize,
-    /// If false, calls to `alloc()` and `alloc_zeroed()` just wrap the corresponding
-    /// function in the global allocator. Otherwise, uses the pages tracked
-    /// internally.
-    enabled: bool,
 }
 
 // SAFETY: We only point to heap-allocated data
 unsafe impl Send for MachineAlloc {}
 
 impl MachineAlloc {
-    /// Initializes the allocator. `page_size` is set to 4k as a placeholder to
-    /// allow this function to be `const`; it is updated to its real value when
-    /// `enable()` is called.
+    /// Initializes the allocator. `page_size` is set to 0 as a placeholder to
+    /// allow this function to be `const`; it is updated to its real value on
+    /// the first call to `alloc()` or `alloc_zeroed()`.
     const fn empty() -> Self {
         Self {
             pages: Vec::new(),
             huge_allocs: Vec::new(),
             allocated: Vec::new(),
-            page_size: 4096,
-            enabled: true,
-        }
-    }
-
-    /// Enables the allocator. From this point onwards, calls to `alloc()` and
-    /// `alloc_zeroed()` will return `(ptr, false)`.
-    pub fn enable() {
-        let mut alloc = ALLOCATOR.lock().unwrap();
-        alloc.enabled = true;
-        // This needs to specifically be the system pagesize!
-        alloc.page_size = unsafe {
-            // If sysconf errors, better to just panic
-            libc::sysconf(libc::_SC_PAGE_SIZE).try_into().unwrap()
+            page_size: 0,
         }
     }
 
@@ -79,45 +62,35 @@ impl MachineAlloc {
         (size, align)
     }
 
-    /// Allocates memory as described in `Layout`. If `MachineAlloc::enable()`
-    /// has *not* been called yet, this is just a wrapper for `(alloc::alloc(),
-    /// true)`. Otherwise, it will allocate from its own memory pool and
-    /// return `(ptr, false)`. The latter field is meant to correspond with the
-    /// field `alloc_is_global` for `MiriAllocBytes`.
+    /// Allocates memory as described in `Layout`.
     ///
-    /// SAFETY: See alloc::alloc()
+    /// SAFETY: `See alloc::alloc()`
     #[inline]
-    pub unsafe fn alloc(layout: Layout) -> (*mut u8, bool) {
+    pub unsafe fn alloc(layout: Layout) -> *mut u8 {
         let mut alloc = ALLOCATOR.lock().unwrap();
         unsafe {
-            if alloc.enabled {
-                (alloc.alloc_inner(layout, false), false)
-            } else {
-                (alloc::alloc(layout), true)
-            }
+            alloc.alloc_inner(layout, false)
         }
     }
 
-    /// Same as `alloc()`, but zeroes out data before allocating. Instead
-    /// wraps `alloc::alloc_zeroed()` if `MachineAlloc::enable()` has not been
-    /// called yet.
+    /// Same as `alloc()`, but zeroes out data before allocating.
     ///
-    /// SAFETY: See alloc::alloc_zeroed()
-    pub unsafe fn alloc_zeroed(layout: Layout) -> (*mut u8, bool) {
+    /// SAFETY: See `alloc::alloc_zeroed()`
+    pub unsafe fn alloc_zeroed(layout: Layout) -> *mut u8 {
         let mut alloc = ALLOCATOR.lock().unwrap();
-        if alloc.enabled {
-            let ptr = unsafe { alloc.alloc_inner(layout, true) };
-            (ptr, false)
-        } else {
-            unsafe { (alloc::alloc_zeroed(layout), true) }
-        }
+        unsafe { alloc.alloc_inner(layout, true) }
     }
 
-    /// SAFETY: The allocator must have been `enable()`d already and
-    /// the `layout` must be valid.
+    /// SAFETY: See `alloc::alloc()`
     unsafe fn alloc_inner(&mut self, layout: Layout, zeroed: bool) -> *mut u8 {
         let (size, align) = MachineAlloc::normalized_layout(layout);
 
+        if self.page_size == 0 {
+            unsafe {
+                self.page_size = libc::sysconf(libc::_SC_PAGESIZE).try_into().unwrap();
+            }
+        }
+
         if align > self.page_size || size > self.page_size {
             unsafe { self.alloc_multi_page(layout, zeroed) }
         } else {
@@ -160,13 +133,10 @@ impl MachineAlloc {
         ret
     }
 
-    /// Deallocates a pointer from the machine allocator. While not unsound,
-    /// attempting to deallocate a pointer if `MachineAlloc` has not been enabled
-    /// will likely result in a panic.
+    /// Deallocates a pointer from the isolated allocator.
     ///
     /// SAFETY: This pointer must have been allocated with `MachineAlloc::alloc()`
-    /// (or `alloc_zeroed()`) which must have returned `(ptr, false)` specifically!
-    /// If it returned `(ptr, true)`, then deallocate it with `alloc::dealloc()` instead.
+    /// (or `alloc_zeroed()`) with the same layout as the one passed.
     pub unsafe fn dealloc(ptr: *mut u8, layout: Layout) {
         let mut alloc_guard = ALLOCATOR.lock().unwrap();
         // Doing it this way lets us grab 2 mutable references to different fields at once

src/alloc/mod.rs

@@ -2,4 +2,4 @@ mod alloc_bytes;
 #[cfg(target_os = "linux")]
 pub mod discrete_alloc;
 
-pub use self::alloc_bytes::MiriAllocBytes;
+pub use self::alloc_bytes::{MiriAllocBytes, MiriByteMdata};

src/alloc_addresses/mod.rs

@@ -135,11 +135,12 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
         if this.machine.native_lib.is_some() {
             // In native lib mode, we use the "real" address of the bytes for this allocation.
             // This ensures the interpreted program and native code have the same view of memory.
+            let dsc = this.machine.get_default_byte_mdata();
             let base_ptr = match info.kind {
                 AllocKind::LiveData => {
                     if memory_kind == MiriMemoryKind::Global.into() {
                         // For new global allocations, we always pre-allocate the memory to be able use the machine address directly.
-                        let prepared_bytes = MiriAllocBytes::zeroed(info.size, info.align)
+                        let prepared_bytes = MiriAllocBytes::zeroed(info.size, info.align, dsc)
                             .unwrap_or_else(|| {
                                 panic!("Miri ran out of memory: cannot create allocation of {size:?} bytes", size = info.size)
                             });
@@ -159,7 +160,7 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 AllocKind::Function | AllocKind::VTable => {
                     // Allocate some dummy memory to get a unique address for this function/vtable.
                     let alloc_bytes =
-                        MiriAllocBytes::from_bytes(&[0u8; 1], Align::from_bytes(1).unwrap());
+                        MiriAllocBytes::from_bytes(&[0u8; 1], Align::from_bytes(1).unwrap(), dsc);
                     let ptr = alloc_bytes.as_ptr();
                     // Leak the underlying memory to ensure it remains unique.
                     std::mem::forget(alloc_bytes);
@@ -429,7 +430,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             prepared_alloc_bytes.copy_from_slice(bytes);
             interp_ok(prepared_alloc_bytes)
         } else {
-            interp_ok(MiriAllocBytes::from_bytes(std::borrow::Cow::Borrowed(bytes), align))
+            let dsc = this.machine.get_default_byte_mdata();
+            interp_ok(MiriAllocBytes::from_bytes(std::borrow::Cow::Borrowed(bytes), align, dsc))
         }
     }
 

src/concurrency/thread.rs

@@ -894,12 +894,13 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             if tcx.is_foreign_item(def_id) {
                 throw_unsup_format!("foreign thread-local statics are not supported");
             }
+            let dsc = this.machine.get_default_byte_mdata();
             let alloc = this.ctfe_query(|tcx| tcx.eval_static_initializer(def_id))?;
             // We make a full copy of this allocation.
             let mut alloc = alloc.inner().adjust_from_tcx(
                 &this.tcx,
                 |bytes, align| {
-                    interp_ok(MiriAllocBytes::from_bytes(std::borrow::Cow::Borrowed(bytes), align))
+                    interp_ok(MiriAllocBytes::from_bytes(std::borrow::Cow::Borrowed(bytes), align, dsc))
                 },
                 |ptr| this.global_root_pointer(ptr),
             )?;