perf(allocator): remove Arc from AllocatorPool (#11760)

Follow-on after #11736. Remove the overhead of `Arc` from `AllocatorPool`.

This does introduce more lifetimes in linter, which is unwelcome, but as well as removing the synchronization overhead of `Arc`, I think it reflects the semantics of what we're trying to do more correctly.

`AllocatorPool` solely owns the `Vec<Allocator>` pool. It doesn't need to (and shouldn't) share ownership of it with `AllocatorGuard`s, which `Arc` does. So `AllocatorGuard`s can just hold a reference to the `AllocatorPool`.

Author: overlookmotel

crates/oxc_allocator/src/pool.rs

@@ -1,7 +1,7 @@
 use std::{
     mem::ManuallyDrop,
     ops::{Deref, DerefMut},
-    sync::{Arc, Mutex},
+    sync::Mutex,
 };
 
 use crate::Allocator;
@@ -11,14 +11,14 @@ use crate::Allocator;
 /// Internally uses a `Vec` protected by a `Mutex` to store available allocators.
 #[derive(Default)]
 pub struct AllocatorPool {
-    allocators: Arc<Mutex<Vec<Allocator>>>,
+    allocators: Mutex<Vec<Allocator>>,
 }
 
 impl AllocatorPool {
     /// Creates a new `AllocatorPool` pre-filled with the given number of default `Allocator` instances.
     pub fn new(size: usize) -> AllocatorPool {
         let allocators = std::iter::repeat_with(Allocator::default).take(size).collect();
-        AllocatorPool { allocators: Arc::new(Mutex::new(allocators)) }
+        AllocatorPool { allocators: Mutex::new(allocators) }
     }
 
     /// Retrieves an `Allocator` from the pool, or creates a new one if the pool is empty.
@@ -34,41 +34,50 @@ impl AllocatorPool {
             allocators.pop().unwrap_or_default()
         };
 
-        AllocatorGuard {
-            allocator: ManuallyDrop::new(allocator),
-            pool: Arc::clone(&self.allocators),
-        }
+        AllocatorGuard { allocator: ManuallyDrop::new(allocator), pool: self }
+    }
+
+    /// Add an `Allocator` to the pool.
+    ///
+    /// The `Allocator` should be empty, ready to be re-used.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the underlying mutex is poisoned.
+    fn add(&self, allocator: Allocator) {
+        let mut allocators = self.allocators.lock().unwrap();
+        allocators.push(allocator);
     }
 }
 
 /// A guard object representing exclusive access to an `Allocator` from the pool.
 ///
 /// On drop, the `Allocator` is reset and returned to the pool.
-pub struct AllocatorGuard {
+pub struct AllocatorGuard<'alloc_pool> {
     allocator: ManuallyDrop<Allocator>,
-    pool: Arc<Mutex<Vec<Allocator>>>,
+    pool: &'alloc_pool AllocatorPool,
 }
 
-impl Deref for AllocatorGuard {
+impl Deref for AllocatorGuard<'_> {
     type Target = Allocator;
 
     fn deref(&self) -> &Self::Target {
         &self.allocator
     }
 }
 
-impl DerefMut for AllocatorGuard {
+impl DerefMut for AllocatorGuard<'_> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.allocator
     }
 }
 
-impl Drop for AllocatorGuard {
+impl Drop for AllocatorGuard<'_> {
+    /// Return `Allocator` back to the pool.
     fn drop(&mut self) {
-        // SAFETY: we're taking ownership and promise not to drop `allocator` again.
+        // SAFETY: After taking ownership of the `Allocator`, we do not touch the `ManuallyDrop` again
         let mut allocator = unsafe { ManuallyDrop::take(&mut self.allocator) };
         allocator.reset();
-        let mut allocators = self.pool.lock().unwrap();
-        allocators.push(allocator);
+        self.pool.add(allocator);
     }
 }

crates/oxc_linter/src/service/runtime.rs

@@ -47,16 +47,16 @@ pub struct Runtime<'l> {
 }
 
 /// Output of `Runtime::process_path`
-struct ModuleProcessOutput {
+struct ModuleProcessOutput<'alloc_pool> {
     /// All paths in `Runtime` are stored as `OsStr`, because `OsStr` hash is faster
     /// than `Path` - go checkout their source code.
     path: Arc<OsStr>,
-    processed_module: ProcessedModule,
+    processed_module: ProcessedModule<'alloc_pool>,
 }
 
 /// A module processed from a path
 #[derive(Default)]
-struct ProcessedModule {
+struct ProcessedModule<'alloc_pool> {
     /// Module records of source sections, or diagnostics if parsing failed on that section.
     ///
     /// Modules with special extensions such as .vue could contain multiple source sections (see `PartialLoader::PartialLoader`).
@@ -71,7 +71,7 @@ struct ProcessedModule {
     ///
     /// Note that `content` is `Some` even if parsing is unsuccessful as long as the source to lint is valid utf-8.
     /// It is designed this way to cover the case where some but not all the sections fail to parse.
-    content: Option<ModuleContent>,
+    content: Option<ModuleContent<'alloc_pool>>,
 }
 
 struct ResolvedModuleRequest {
@@ -86,18 +86,18 @@ struct ResolvedModuleRecord {
 }
 
 self_cell! {
-    struct ModuleContent {
-        owner: ModuleContentOwner,
+    struct ModuleContent<'alloc_pool> {
+        owner: ModuleContentOwner<'alloc_pool>,
         #[not_covariant]
         dependent: SectionContents,
     }
 }
 // Safety: dependent borrows from owner. They're safe to be sent together.
-unsafe impl Send for ModuleContent {}
+unsafe impl Send for ModuleContent<'_> {}
 
-struct ModuleContentOwner {
+struct ModuleContentOwner<'alloc_pool> {
     source_text: String,
-    allocator: AllocatorGuard,
+    allocator: AllocatorGuard<'alloc_pool>,
 }
 
 /// source text and semantic for each source section. They are in the same order as `ProcessedModule.section_module_records`
@@ -113,13 +113,16 @@ struct SectionContent<'a> {
 ///
 /// A `ModuleWithContent` is generated for each path in `runtime.paths`. It's basically the same
 /// as `ProcessedModule`, except `content` is non-Option.
-struct ModuleToLint {
+struct ModuleToLint<'alloc_pool> {
     path: Arc<OsStr>,
     section_module_records: SmallVec<[Result<Arc<ModuleRecord>, Vec<OxcDiagnostic>>; 1]>,
-    content: ModuleContent,
+    content: ModuleContent<'alloc_pool>,
 }
-impl ModuleToLint {
-    fn from_processed_module(path: Arc<OsStr>, processed_module: ProcessedModule) -> Option<Self> {
+impl<'alloc_pool> ModuleToLint<'alloc_pool> {
+    fn from_processed_module(
+        path: Arc<OsStr>,
+        processed_module: ProcessedModule<'alloc_pool>,
+    ) -> Option<Self> {
         processed_module.content.map(|content| Self {
             path,
             section_module_records: processed_module