listened to reason and made my life so much easier

Author: nia-e

src/alloc/alloc_bytes.rs

@@ -1,6 +1,8 @@
 use std::alloc::Layout;
 use std::borrow::Cow;
 use std::{alloc, slice};
+#[cfg(target_os = "linux")]
+use std::{rc::Rc, cell::RefCell};
 
 use rustc_abi::{Align, Size};
 use rustc_middle::mir::interpret::AllocBytes;
@@ -9,10 +11,11 @@ use rustc_middle::mir::interpret::AllocBytes;
 use crate::alloc::isolated_alloc::IsolatedAlloc;
 use crate::helpers::ToU64 as _;
 
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Debug)]
 pub enum MiriAllocParams {
     Global,
-    Isolated(u64),
+    #[cfg(target_os = "linux")]
+    Isolated(Rc<RefCell<IsolatedAlloc>>),
 }
 
 /// Allocation bytes that explicitly handle the layout of the data they're storing.
@@ -35,7 +38,7 @@ 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, self.params)
+        MiriAllocBytes::from_bytes(bytes, align, self.params.clone())
     }
 }
 
@@ -51,12 +54,11 @@ impl Drop for MiriAllocBytes {
 
         // SAFETY: Invariant, `self.ptr` points to memory allocated with `self.layout`.
         unsafe {
-            match self.params {
+            match self.params.clone() {
                 MiriAllocParams::Global => alloc::dealloc(self.ptr, alloc_layout),
                 #[cfg(target_os = "linux")]
-                MiriAllocParams::Isolated(id) => IsolatedAlloc::dealloc(self.ptr, alloc_layout, id),
-                #[cfg(not(target_os = "linux"))]
-                MiriAllocParams::Isolated(_) => unreachable!(),
+                MiriAllocParams::Isolated(alloc) =>
+                    alloc.borrow_mut().dealloc(self.ptr, alloc_layout),
             }
         }
     }
@@ -117,14 +119,13 @@ impl AllocBytes for MiriAllocBytes {
         let slice = slice.into();
         let size = slice.len();
         let align = align.bytes();
+        let p_clone = params.clone();
         // SAFETY: `alloc_fn` will only be used with `size != 0`.
         let alloc_fn = |layout| unsafe {
-            match params {
+            match p_clone {
                 MiriAllocParams::Global => alloc::alloc(layout),
                 #[cfg(target_os = "linux")]
-                MiriAllocParams::Isolated(id) => IsolatedAlloc::alloc(layout, id),
-                #[cfg(not(target_os = "linux"))]
-                MiriAllocParams::Isolated(_) => unreachable!(),
+                MiriAllocParams::Isolated(alloc) => alloc.borrow_mut().alloc(layout),
             }
         };
         let alloc_bytes = MiriAllocBytes::alloc_with(size.to_u64(), align, params, alloc_fn)
@@ -140,14 +141,13 @@ impl AllocBytes for MiriAllocBytes {
     fn zeroed(size: Size, align: Align, params: MiriAllocParams) -> Option<Self> {
         let size = size.bytes();
         let align = align.bytes();
+        let p_clone = params.clone();
         // SAFETY: `alloc_fn` will only be used with `size != 0`.
         let alloc_fn = |layout| unsafe {
-            match params {
+            match p_clone {
                 MiriAllocParams::Global => alloc::alloc_zeroed(layout),
                 #[cfg(target_os = "linux")]
-                MiriAllocParams::Isolated(id) => IsolatedAlloc::alloc_zeroed(layout, id),
-                #[cfg(not(target_os = "linux"))]
-                MiriAllocParams::Isolated(_) => unreachable!(),
+                MiriAllocParams::Isolated(alloc) => alloc.borrow_mut().alloc_zeroed(layout),
             }
         };
         MiriAllocBytes::alloc_with(size, align, params, alloc_fn).ok()

src/alloc/isolated_alloc.rs

@@ -1,27 +1,11 @@
 use std::alloc::{self, Layout};
-use std::collections::HashMap;
-use std::hash::{BuildHasherDefault, DefaultHasher};
-use std::sync;
 
 use rustc_index::bit_set::DenseBitSet;
 
-static ALLOCATOR: sync::Mutex<IsolatedAlloc> = sync::Mutex::new(IsolatedAlloc::empty());
-
-pub struct IsolatedAlloc {
-    /// A map of machine ID to allocator. If running in multi-seeded mode,
-    /// each machine should have its own pool of memory that can be accessed
-    /// separately. We use the normal `HashMap` type so that it's available
-    /// in a `const` context.
-    #[allow(rustc::default_hash_types)]
-    allocators: HashMap<u64, IsolatedAllocInner, BuildHasherDefault<DefaultHasher>>,
-    /// The host (not emulated) page size, or 0 if it has not yet been set.
-    page_size: usize,
-}
-
 /// A dedicated allocator for interpreter memory contents, ensuring they are stored on dedicated
 /// pages (not mixed with Miri's own memory). This is very useful for native-lib mode.
 #[derive(Debug)]
-pub struct IsolatedAllocInner {
+pub struct IsolatedAlloc {
     /// Pointers to page-aligned memory that has been claimed by the allocator.
     /// Every pointer here must point to a page-sized allocation claimed via
     /// the global allocator.
@@ -38,80 +22,19 @@ pub struct IsolatedAllocInner {
     /// indexing into it should be done with a value one-eighth of the corresponding
     /// offset on the matching `page_ptrs` element.
     page_infos: Vec<DenseBitSet<usize>>,
+    /// The host (not emulated) page size, or 0 if it has not yet been set.
+    page_size: usize,
 }
 
-// SAFETY: We only point to heap-allocated data
-unsafe impl Send for IsolatedAlloc {}
-
 impl IsolatedAlloc {
-    /// 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 {
-        // We need this to be `const`
-        #[allow(rustc::default_hash_types)]
-        Self { allocators: HashMap::with_hasher(BuildHasherDefault::new()), page_size: 0 }
-    }
-
-    /// Allocates memory as described in `Layout`, from the pool marked by
-    /// `id`. Note that the same `id` must be used upon calling `dealloc`.
-    ///
-    /// SAFETY: See `alloc::alloc()`.
-    pub unsafe fn alloc(layout: Layout, id: u64) -> *mut u8 {
-        unsafe { Self::alloc_inner(layout, id, false) }
-    }
-
-    /// Same as `alloc()`, but zeroes out data before allocating.
-    ///
-    /// SAFETY: See `alloc::alloc_zeroed()`.
-    pub unsafe fn alloc_zeroed(layout: Layout, id: u64) -> *mut u8 {
-        unsafe { Self::alloc_inner(layout, id, true) }
-    }
-
-    /// Abstracts over `alloc` and `alloc_zeroed`.
-    ///
-    /// SAFETY: See `alloc::alloc()`/`alloc::alloc_zeroed()`.
-    unsafe fn alloc_inner(layout: Layout, id: u64, zeroed: bool) -> *mut u8 {
-        let mut alloc = ALLOCATOR.lock().unwrap();
-        if alloc.page_size == 0 {
-            unsafe {
-                alloc.page_size = libc::sysconf(libc::_SC_PAGESIZE).try_into().unwrap();
-            }
-        }
-        // Store this this AFTER setting the page size
-        let page_size = alloc.page_size;
-
-        match alloc.allocators.get_mut(&id) {
-            Some(alloc_inner) => unsafe { alloc_inner.allocate(layout, page_size, zeroed) },
-            None => {
-                let mut new_inner = IsolatedAllocInner::new();
-                let ret = unsafe { new_inner.allocate(layout, page_size, zeroed) };
-                alloc.allocators.insert(id, new_inner);
-                ret
-            }
-        }
-    }
-
-    /// Deallocates a pointer from the memory pool associated with a given `id`.
-    ///
-    /// SAFETY: See `alloc::dealloc()`, with the extra caveat that `id` must
-    /// correspond to the `id` used upon first allocating the memory.
-    pub unsafe fn dealloc(ptr: *mut u8, layout: Layout, id: u64) {
-        let mut alloc = ALLOCATOR.lock().unwrap();
-        let page_size = alloc.page_size;
-        let alloc_inner = alloc.allocators.get_mut(&id).unwrap();
-        unsafe { alloc_inner.deallocate(ptr, layout, page_size) };
-        // Remove if the machine with that id no longer has any memory
-        if alloc_inner.huge_ptrs.is_empty() && alloc_inner.page_ptrs.is_empty() {
-            alloc.allocators.remove(&id);
-        }
-    }
-}
-
-impl IsolatedAllocInner {
     /// Creates an empty allocator.
-    const fn new() -> Self {
-        Self { page_ptrs: Vec::new(), huge_ptrs: Vec::new(), page_infos: Vec::new() }
+    pub fn new() -> Self {
+        Self {
+            page_ptrs: Vec::new(),
+            huge_ptrs: Vec::new(),
+            page_infos: Vec::new(),
+            page_size: unsafe { libc::sysconf(libc::_SC_PAGESIZE).try_into().unwrap() },
+        }
     }
 
     /// Expands the available memory pool by adding one page.
@@ -137,24 +60,40 @@ impl IsolatedAllocInner {
         (size, align)
     }
 
+    /// Allocates memory as described in `Layout`. This memory should be deallocated
+    /// by calling `dealloc` on this same allocator.
+    ///
+    /// SAFETY: See `alloc::alloc()`
+    pub fn alloc(&mut self, layout: Layout) -> *mut u8 {
+        unsafe { self.allocate(layout, false) }
+    }
+
+    /// Same as `alloc`, but zeroes out the memory.
+    ///
+    /// SAFETY: See `alloc::alloc_zeroed()`
+    pub fn alloc_zeroed(&mut self, layout: Layout) -> *mut u8 {
+        unsafe { self.allocate(layout, true) }
+    }
+
     /// Abstracts over the logic of `alloc_zeroed` vs `alloc`, as determined by
     /// the `zeroed` argument.
     ///
     /// SAFETY: See `alloc::alloc()`, with the added restriction that `page_size`
     /// corresponds to the host pagesize.
-    unsafe fn allocate(&mut self, layout: Layout, page_size: usize, zeroed: bool) -> *mut u8 {
-        if layout.align() > page_size || layout.size() > page_size {
+    unsafe fn allocate(&mut self, layout: Layout, zeroed: bool) -> *mut u8 {
+        if layout.align() > self.page_size || layout.size() > self.page_size {
             unsafe { self.alloc_multi_page(layout, zeroed) }
         } else {
             for (&mut page, pinfo) in std::iter::zip(&mut self.page_ptrs, &mut self.page_infos) {
                 if let Some(ptr) =
-                    unsafe { Self::alloc_from_page(page_size, layout, page, pinfo, zeroed) }
+                    unsafe { Self::alloc_from_page(self.page_size, layout, page, pinfo, zeroed) }
                 {
                     return ptr;
                 }
             }
 
             // We get here only if there's no space in our existing pages
+            let page_size = self.page_size;
             let (page, pinfo) = self.add_page(page_size);
             unsafe { Self::alloc_from_page(page_size, layout, page, pinfo, zeroed).unwrap() }
         }
@@ -171,7 +110,7 @@ impl IsolatedAllocInner {
         pinfo: &mut DenseBitSet<usize>,
         zeroed: bool,
     ) -> Option<*mut u8> {
-        let (size, align) = IsolatedAllocInner::normalized_layout(layout);
+        let (size, align) = IsolatedAlloc::normalized_layout(layout);
 
         // Check every alignment-sized block and see if there exists a `size`
         // chunk of empty space i.e. forall idx . !pinfo.contains(idx / 8)
@@ -213,15 +152,14 @@ impl IsolatedAllocInner {
     ///
     /// SAFETY: This pointer must have been allocated by calling `alloc()` (or
     /// `alloc_zeroed()`) with the same layout as the one passed on this same
-    /// `IsolatedAllocInner`, and `page_size` must correspond to the host
-    /// pagesize.
-    unsafe fn deallocate(&mut self, ptr: *mut u8, layout: Layout, page_size: usize) {
-        let (size, align) = IsolatedAllocInner::normalized_layout(layout);
+    /// `IsolatedAlloc`.
+    pub unsafe fn dealloc(&mut self, ptr: *mut u8, layout: Layout) {
+        let (size, align) = IsolatedAlloc::normalized_layout(layout);
 
-        let ptr_idx = ptr.addr() % page_size;
+        let ptr_idx = ptr.addr() % self.page_size;
         let page_addr = ptr.addr() - ptr_idx;
 
-        if align > page_size || size > page_size {
+        if align > self.page_size || size > self.page_size {
             unsafe {
                 self.dealloc_multi_page(ptr, layout);
             }
@@ -242,7 +180,8 @@ impl IsolatedAllocInner {
         }
 
         let mut free = vec![];
-        let page_layout = unsafe { Layout::from_size_align_unchecked(page_size, page_size) };
+        let page_layout =
+            unsafe { Layout::from_size_align_unchecked(self.page_size, self.page_size) };
         for (idx, pinfo) in self.page_infos.iter().enumerate() {
             if pinfo.is_empty() {
                 free.push(idx);
@@ -271,7 +210,7 @@ impl IsolatedAllocInner {
         }
     }
 }
-
+/*
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -365,3 +304,4 @@ mod tests {
         assert!(!alloc.allocators.contains_key(&4));
     }
 }
+*/

src/concurrency/thread.rs

@@ -906,7 +906,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     interp_ok(MiriAllocBytes::from_bytes(
                         std::borrow::Cow::Borrowed(bytes),
                         align,
-                        params,
+                        params.clone(),
                     ))
                 },
                 |ptr| this.global_root_pointer(ptr),

src/machine.rs

@@ -532,10 +532,9 @@ pub struct MiriMachine<'tcx> {
     /// Needs to be queried by ptr_to_int, hence needs interior mutability.
     pub(crate) rng: RefCell<StdRng>,
 
-    /// The seed for the RNG, also used as a unique identifier for the machine.
-    /// If multiple machines exist, this must be different for each.
+    /// The allocator used for the machine's `AllocBytes`.
     #[cfg(target_os = "linux")]
-    pub(crate) seed: u64,
+    pub(crate) allocator: Rc<RefCell<crate::alloc::isolated_alloc::IsolatedAlloc>>,
 
     /// The allocation IDs to report when they are being allocated
     /// (helps for debugging memory leaks and use after free bugs).
@@ -722,7 +721,7 @@ impl<'tcx> MiriMachine<'tcx> {
             extern_statics: FxHashMap::default(),
             rng: RefCell::new(rng),
             #[cfg(target_os = "linux")]
-            seed,
+            allocator: Rc::new(RefCell::new(crate::alloc::isolated_alloc::IsolatedAlloc::new())),
             tracked_alloc_ids: config.tracked_alloc_ids.clone(),
             track_alloc_accesses: config.track_alloc_accesses,
             check_alignment: config.check_alignment,
@@ -926,7 +925,7 @@ impl VisitProvenance for MiriMachine<'_> {
             local_crates: _,
             rng: _,
             #[cfg(target_os = "linux")]
-            seed: _,
+            allocator: _,
             tracked_alloc_ids: _,
             track_alloc_accesses: _,
             check_alignment: _,
@@ -1819,7 +1818,7 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
 
         #[cfg(target_os = "linux")]
         if self.native_lib.is_some() {
-            MiriAllocParams::Isolated(self.seed)
+            MiriAllocParams::Isolated(self.allocator.clone())
         } else {
             MiriAllocParams::Global
         }