feat(allocator): optimize memory usage with dual allocator pools for import plugin

Add `AllocatorPool::new_dual()` to support both standard and fixed-size allocators
in a single pool, allowing runtime selection based on file purpose. This reduces
memory usage when using the import plugin by using standard allocators (~few MB)
for dependency files that are only parsed for module resolution, while reserving
fixed-size allocators (~2 GiB address space) only for entry files that need
linting with JS plugins.

Fixes #15799

Author: camc314

apps/oxlint/src/js_plugins/external_linter.rs

@@ -77,12 +77,11 @@ fn wrap_lint_file(cb: JsLintFileCb) -> ExternalLinterLintFileCb {
             let (tx, rx) = channel();
 
             // SAFETY: This function is only called when an `ExternalLinter` exists.
-            // When that is the case, the `AllocatorPool` used to create `Allocator`s is created with
-            // `AllocatorPool::new_fixed_size`, so all `Allocator`s are created via `FixedSizeAllocator`.
-            // This is somewhat sketchy, as we don't have a type-level guarantee of this invariant,
-            // but it does hold at present.
-            // When we replace `bumpalo` with a custom allocator, we can close this soundness hole.
-            // TODO: Do that.
+            // When that is the case, the `AllocatorPool` is created with `AllocatorPool::new_dual`,
+            // and `Allocator`s for files that need linting are created via `FixedSizeAllocator`
+            // using `get_maybe_fixed_size(true)`.
+            // This is validated with debug assertions in the linter runtime before calling this function.
+            // The `AllocatorGuard` tracks whether an allocator is fixed-size via the `is_fixed_size` field.
             let (buffer_id, buffer) = unsafe { get_buffer(allocator) };
 
             // Send data to JS

apps/oxlint/src/js_plugins/raw_fs.rs

@@ -14,8 +14,9 @@ use oxc_linter::RuntimeFileSystem;
 /// Identical to `OsFileSystem`, except that `read_to_arena_str` reads the file's contents into
 /// start of the allocator, instead of the end. This conforms to what raw transfer needs.
 ///
-/// Must only be used in conjunction with `AllocatorPool` created with `new_fixed_size`,
-/// which wraps `Allocator`s with a custom `Drop` impl, which makes `read_to_arena_str` safe.
+/// Must only be used with fixed-size `Allocator`s (created via `AllocatorPool::new_fixed_size`
+/// or `AllocatorPool::new_dual` with `get_maybe_fixed_size(true)`),
+/// which have a custom `Drop` impl that makes `read_to_arena_str` safe.
 ///
 /// This is a temporary solution. When we replace `bumpalo` with our own allocator, all strings
 /// will be written at start of the arena, so then `OsFileSystem` will work fine, and we can

crates/oxc_allocator/src/pool/mod.rs

@@ -18,39 +18,70 @@ pub use fixed_size::{FixedSizeAllocatorMetadata, free_fixed_size_allocator};
 
 /// A thread-safe pool for reusing [`Allocator`] instances to reduce allocation overhead.
 ///
-/// Uses either:
-/// 1. Standard allocators - suitable for general use.
-/// 2. Fixed-size allocators - compatible with raw transfer.
+/// Supports three configurations:
+/// 1. Standard allocators only - suitable for general use ([`AllocatorPool::new`]).
+/// 2. Fixed-size allocators only - compatible with raw transfer ([`AllocatorPool::new_fixed_size`]).
+/// 3. Dual mode with both types - allows choosing allocator type at runtime ([`AllocatorPool::new_dual`]).
 ///
-/// Standard allocator pool is created by [`AllocatorPool::new`].
-/// Fixed-size allocator pool is created by [`AllocatorPool::new_fixed_size`].
+/// The dual mode is useful when some allocations need raw transfer (e.g., files to be linted with JS plugins)
+/// while others don't (e.g., dependency files only parsed for module resolution).
 ///
 /// Fixed-size allocators are only supported on 64-bit little-endian platforms at present,
 /// and require the `fixed_size` Cargo feature to be enabled.
-#[repr(transparent)]
-pub struct AllocatorPool(AllocatorPoolInner);
-
-/// Inner type of [`AllocatorPool`], holding either a standard or fixed-size allocator pool.
-enum AllocatorPoolInner {
-    Standard(StandardAllocatorPool),
+pub struct AllocatorPool {
+    standard: StandardAllocatorPool,
     #[cfg(all(feature = "fixed_size", target_pointer_width = "64", target_endian = "little"))]
-    FixedSize(FixedSizeAllocatorPool),
+    fixed_size: Option<FixedSizeAllocatorPool>,
 }
 
 impl AllocatorPool {
     /// Create a new [`AllocatorPool`] for use across the specified number of threads,
-    /// which uses standard allocators.
+    /// which uses standard allocators only.
     pub fn new(thread_count: usize) -> AllocatorPool {
-        Self(AllocatorPoolInner::Standard(StandardAllocatorPool::new(thread_count)))
+        Self {
+            standard: StandardAllocatorPool::new(thread_count),
+            #[cfg(all(
+                feature = "fixed_size",
+                target_pointer_width = "64",
+                target_endian = "little"
+            ))]
+            fixed_size: None,
+        }
     }
 
     /// Create a new [`AllocatorPool`] for use across the specified number of threads,
-    /// which uses fixed-size allocators (suitable for raw transfer).
+    /// which uses fixed-size allocators only (suitable for raw transfer).
     #[cfg(feature = "fixed_size")]
     pub fn new_fixed_size(thread_count: usize) -> AllocatorPool {
         #[cfg(all(target_pointer_width = "64", target_endian = "little"))]
         {
-            Self(AllocatorPoolInner::FixedSize(FixedSizeAllocatorPool::new(thread_count)))
+            Self {
+                standard: StandardAllocatorPool::new(0), // Not used, but need to initialize
+                fixed_size: Some(FixedSizeAllocatorPool::new(thread_count)),
+            }
+        }
+
+        #[cfg(not(all(target_pointer_width = "64", target_endian = "little")))]
+        {
+            let _thread_count = thread_count; // Avoid unused vars lint warning
+            panic!("Fixed size allocators are only supported on 64-bit little-endian platforms");
+        }
+    }
+
+    /// Create a new [`AllocatorPool`] for use across the specified number of threads,
+    /// which contains both standard and fixed-size allocators.
+    ///
+    /// This allows choosing the allocator type at runtime via [`AllocatorPool::get_maybe_fixed_size`].
+    /// Useful when some allocations need raw transfer (e.g., files to be linted with JS plugins)
+    /// while others don't (e.g., dependency files only parsed for module resolution).
+    #[cfg(feature = "fixed_size")]
+    pub fn new_dual(thread_count: usize) -> AllocatorPool {
+        #[cfg(all(target_pointer_width = "64", target_endian = "little"))]
+        {
+            Self {
+                standard: StandardAllocatorPool::new(thread_count),
+                fixed_size: Some(FixedSizeAllocatorPool::new(thread_count)),
+            }
         }
 
         #[cfg(not(all(target_pointer_width = "64", target_endian = "little")))]
@@ -64,21 +95,87 @@ impl AllocatorPool {
     ///
     /// Returns an [`AllocatorGuard`] that gives access to the allocator.
     ///
+    /// If the pool was created with [`AllocatorPool::new_fixed_size`], returns a fixed-size allocator.
+    /// Otherwise, returns a standard allocator.
+    ///
     /// # Panics
     ///
     /// Panics if the underlying mutex is poisoned.
     pub fn get(&self) -> AllocatorGuard<'_> {
-        let allocator = match &self.0 {
-            AllocatorPoolInner::Standard(pool) => pool.get(),
+        #[cfg(all(feature = "fixed_size", target_pointer_width = "64", target_endian = "little"))]
+        {
+            if let Some(ref fixed_size_pool) = self.fixed_size {
+                let allocator = fixed_size_pool.get();
+                return AllocatorGuard {
+                    allocator: ManuallyDrop::new(allocator),
+                    is_fixed_size: true,
+                    pool: self,
+                };
+            }
+        }
+
+        let allocator = self.standard.get();
+        AllocatorGuard {
+            allocator: ManuallyDrop::new(allocator),
             #[cfg(all(
                 feature = "fixed_size",
                 target_pointer_width = "64",
                 target_endian = "little"
             ))]
-            AllocatorPoolInner::FixedSize(pool) => pool.get(),
-        };
+            is_fixed_size: false,
+            pool: self,
+        }
+    }
+
+    /// Retrieve an [`Allocator`] from the pool, choosing between standard and fixed-size allocators.
+    ///
+    /// Returns an [`AllocatorGuard`] that gives access to the allocator.
+    ///
+    /// # Parameters
+    ///
+    /// * `fixed_size` - If `true`, returns a fixed-size allocator (suitable for raw transfer).
+    ///   If `false`, returns a standard allocator.
+    ///
+    /// # Panics
+    ///
+    /// Panics if:
+    /// - The underlying mutex is poisoned.
+    /// - `fixed_size` is `true` but the pool was not created with [`AllocatorPool::new_dual`] or [`AllocatorPool::new_fixed_size`].
+    #[cfg(feature = "fixed_size")]
+    pub fn get_maybe_fixed_size(&self, fixed_size: bool) -> AllocatorGuard<'_> {
+        #[cfg(all(target_pointer_width = "64", target_endian = "little"))]
+        {
+            if fixed_size {
+                let Some(ref fixed_size_pool) = self.fixed_size else {
+                    panic!(
+                        "Requested fixed-size allocator but pool was not created with new_dual() or new_fixed_size()"
+                    );
+                };
+                let allocator = fixed_size_pool.get();
+                return AllocatorGuard {
+                    allocator: ManuallyDrop::new(allocator),
+                    is_fixed_size: true,
+                    pool: self,
+                };
+            }
+        }
 
-        AllocatorGuard { allocator: ManuallyDrop::new(allocator), pool: self }
+        #[cfg(not(all(target_pointer_width = "64", target_endian = "little")))]
+        if fixed_size {
+            panic!("Fixed size allocators are only supported on 64-bit little-endian platforms");
+        }
+
+        let allocator = self.standard.get();
+        AllocatorGuard {
+            allocator: ManuallyDrop::new(allocator),
+            #[cfg(all(
+                feature = "fixed_size",
+                target_pointer_width = "64",
+                target_endian = "little"
+            ))]
+            is_fixed_size: false,
+            pool: self,
+        }
     }
 
     /// Add an [`Allocator`] to the pool.
@@ -88,20 +185,37 @@ impl AllocatorPool {
     /// # Panics
     ///
     /// Panics if the underlying mutex is poisoned.
+    #[cfg(all(feature = "fixed_size", target_pointer_width = "64", target_endian = "little"))]
+    fn add(&self, allocator: Allocator, is_fixed_size: bool) {
+        // SAFETY: This method is only called from `AllocatorGuard::drop`.
+        // `AllocatorGuard`s are only created by `AllocatorPool::get` or `AllocatorPool::get_maybe_fixed_size`,
+        // so the `Allocator` must have been created by this pool. Therefore, it is the correct type for the pool.
+        unsafe {
+            if is_fixed_size {
+                if let Some(ref fixed_size_pool) = self.fixed_size {
+                    fixed_size_pool.add(allocator);
+                } else {
+                    // This should never happen if `AllocatorGuard` is used correctly
+                    unreachable!("Fixed-size allocator returned to pool without fixed-size pool");
+                }
+            } else {
+                self.standard.add(allocator);
+            }
+        }
+    }
+
+    /// Add an [`Allocator`] to the pool (for platforms without fixed-size support).
+    #[cfg(not(all(
+        feature = "fixed_size",
+        target_pointer_width = "64",
+        target_endian = "little"
+    )))]
     fn add(&self, allocator: Allocator) {
         // SAFETY: This method is only called from `AllocatorGuard::drop`.
         // `AllocatorGuard`s are only created by `AllocatorPool::get`, so the `Allocator` must have
         // been created by this pool. Therefore, it is the correct type for the pool.
         unsafe {
-            match &self.0 {
-                AllocatorPoolInner::Standard(pool) => pool.add(allocator),
-                #[cfg(all(
-                    feature = "fixed_size",
-                    target_pointer_width = "64",
-                    target_endian = "little"
-                ))]
-                AllocatorPoolInner::FixedSize(pool) => pool.add(allocator),
-            }
+            self.standard.add(allocator);
         }
     }
 }
@@ -111,9 +225,19 @@ impl AllocatorPool {
 /// On drop, the `Allocator` is reset and returned to the pool.
 pub struct AllocatorGuard<'alloc_pool> {
     allocator: ManuallyDrop<Allocator>,
+    #[cfg(all(feature = "fixed_size", target_pointer_width = "64", target_endian = "little"))]
+    is_fixed_size: bool,
     pool: &'alloc_pool AllocatorPool,
 }
 
+impl AllocatorGuard<'_> {
+    /// Returns `true` if this allocator is a fixed-size allocator (suitable for raw transfer).
+    #[cfg(all(feature = "fixed_size", target_pointer_width = "64", target_endian = "little"))]
+    pub fn is_fixed_size(&self) -> bool {
+        self.is_fixed_size
+    }
+}
+
 impl Deref for AllocatorGuard<'_> {
     type Target = Allocator;
 
@@ -127,6 +251,102 @@ impl Drop for AllocatorGuard<'_> {
     fn drop(&mut self) {
         // SAFETY: After taking ownership of the `Allocator`, we do not touch the `ManuallyDrop` again
         let allocator = unsafe { ManuallyDrop::take(&mut self.allocator) };
+
+        #[cfg(all(feature = "fixed_size", target_pointer_width = "64", target_endian = "little"))]
+        self.pool.add(allocator, self.is_fixed_size);
+
+        #[cfg(not(all(
+            feature = "fixed_size",
+            target_pointer_width = "64",
+            target_endian = "little"
+        )))]
         self.pool.add(allocator);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_standard_pool() {
+        let pool = AllocatorPool::new(2);
+        let guard1 = pool.get();
+        let guard2 = pool.get();
+
+        // Allocate something to ensure allocators work
+        let _ = guard1.alloc(42);
+        let _ = guard2.alloc(24);
+
+        drop(guard1);
+        drop(guard2);
+
+        // Get allocators again to ensure they were returned to pool
+        let guard3 = pool.get();
+        let _ = guard3.alloc(100);
+    }
+
+    #[test]
+    #[cfg(feature = "fixed_size")]
+    fn test_fixed_size_pool() {
+        let pool = AllocatorPool::new_fixed_size(2);
+        let guard = pool.get();
+
+        #[cfg(all(target_pointer_width = "64", target_endian = "little"))]
+        assert!(guard.is_fixed_size());
+
+        let _ = guard.alloc(42);
+    }
+
+    #[test]
+    #[cfg(feature = "fixed_size")]
+    fn test_dual_pool() {
+        #[cfg(all(target_pointer_width = "64", target_endian = "little"))]
+        {
+            let pool = AllocatorPool::new_dual(2);
+
+            // Get a standard allocator
+            let standard_guard = pool.get_maybe_fixed_size(false);
+            assert!(!standard_guard.is_fixed_size());
+            let _ = standard_guard.alloc(42);
+            drop(standard_guard);
+
+            // Get a fixed-size allocator
+            let fixed_guard = pool.get_maybe_fixed_size(true);
+            assert!(fixed_guard.is_fixed_size());
+            let _ = fixed_guard.alloc(24);
+            drop(fixed_guard);
+
+            // Get them again to ensure they were returned to their respective pools
+            let standard_guard2 = pool.get_maybe_fixed_size(false);
+            assert!(!standard_guard2.is_fixed_size());
+
+            let fixed_guard2 = pool.get_maybe_fixed_size(true);
+            assert!(fixed_guard2.is_fixed_size());
+        }
+
+        #[cfg(not(all(target_pointer_width = "64", target_endian = "little")))]
+        {
+            // On non-64-bit platforms, fixed-size allocators are not supported
+            // This test should still compile but won't run the dual pool test
+        }
+    }
+
+    #[test]
+    #[cfg(feature = "fixed_size")]
+    #[should_panic(
+        expected = "Requested fixed-size allocator but pool was not created with new_dual() or new_fixed_size()"
+    )]
+    fn test_get_fixed_size_from_standard_pool_panics() {
+        #[cfg(all(target_pointer_width = "64", target_endian = "little"))]
+        {
+            let pool = AllocatorPool::new(2);
+            let _ = pool.get_maybe_fixed_size(true); // Should panic
+        }
+
+        #[cfg(not(all(target_pointer_width = "64", target_endian = "little")))]
+        panic!(
+            "Requested fixed-size allocator but pool was not created with new_dual() or new_fixed_size()"
+        );
+    }
+}

crates/oxc_linter/Cargo.toml

@@ -14,7 +14,8 @@ rust-version.workspace = true
 description.workspace = true
 
 [features]
-default = []
+default = ["fixed_size"]
+fixed_size = ["oxc_allocator/fixed_size"]
 ruledocs = ["oxc_macros/ruledocs"] # Enables the `ruledocs` feature for conditional compilation
 force_test_reporter = []