perf(oxfmt): Use AllocatorPool to reuse allocator between threads (#15412)

leaysgur · leaysgur · commit a6808a0be585 · 2025-11-07T06:15:59.000Z
According to my local benchmark for the `outline` repo, it will be slightly better.
diff --git a/apps/oxfmt/Cargo.toml b/apps/oxfmt/Cargo.toml
@@ -21,7 +21,7 @@ path = "src/lib.rs"
 doctest = false
 
 [dependencies]
-oxc_allocator = { workspace = true }
+oxc_allocator = { workspace = true, features = ["pool"] }
 oxc_diagnostics = { workspace = true }
 oxc_formatter = { workspace = true }
 oxc_parser = { workspace = true }
diff --git a/apps/oxfmt/src/format.rs b/apps/oxfmt/src/format.rs
@@ -6,6 +6,7 @@ use std::{
     time::Instant,
 };
 
+use oxc_allocator::AllocatorPool;
 use oxc_diagnostics::DiagnosticService;
 use oxc_formatter::Oxfmtrc;
 
@@ -110,14 +111,21 @@ impl FormatRunner {
             print_and_flush_stdout(stdout, "Checking formatting...\n");
         }
 
+        let num_of_threads = rayon::current_num_threads();
+        // Create allocator pool for reuse across parallel formatting tasks
+        let allocator_pool = AllocatorPool::new(num_of_threads);
+
         let output_options_clone = output_options.clone();
         #[cfg(feature = "napi")]
         let external_formatter_clone = self.external_formatter;
+
         // Spawn a thread to run formatting service with streaming entries
         rayon::spawn(move || {
-            let format_service = FormatService::new(cwd, output_options_clone, format_options);
+            let format_service =
+                FormatService::new(allocator_pool, cwd, output_options_clone, format_options);
             #[cfg(feature = "napi")]
             let format_service = format_service.with_external_formatter(external_formatter_clone);
+
             format_service.run_streaming(rx_entry, &tx_error, tx_count);
         });
 
@@ -127,12 +135,11 @@ impl FormatRunner {
         // Count the processed files
         let target_files_count = rx_count.iter().count();
         let print_stats = |stdout| {
+            let elapsed_ms = start_time.elapsed().as_millis();
             print_and_flush_stdout(
                 stdout,
                 &format!(
-                    "Finished in {}ms on {target_files_count} files using {} threads.\n",
-                    start_time.elapsed().as_millis(),
-                    rayon::current_num_threads()
+                    "Finished in {elapsed_ms}ms on {target_files_count} files using {num_of_threads} threads.\n",
                 ),
             );
         };
diff --git a/apps/oxfmt/src/service.rs b/apps/oxfmt/src/service.rs
@@ -3,14 +3,15 @@ use std::{fs, path::Path, sync::mpsc, time::Instant};
 use cow_utils::CowUtils;
 use rayon::prelude::*;
 
-use oxc_allocator::Allocator;
+use oxc_allocator::AllocatorPool;
 use oxc_diagnostics::{DiagnosticSender, DiagnosticService, OxcDiagnostic};
 use oxc_formatter::{FormatOptions, Formatter, enable_jsx_source_type, get_parse_options};
 use oxc_parser::Parser;
 
 use crate::{command::OutputOptions, walk::WalkEntry};
 
 pub struct FormatService {
+    allocator_pool: AllocatorPool,
     cwd: Box<Path>,
     output_options: OutputOptions,
     format_options: FormatOptions,
@@ -19,11 +20,17 @@ pub struct FormatService {
 }
 
 impl FormatService {
-    pub fn new<T>(cwd: T, output_options: OutputOptions, format_options: FormatOptions) -> Self
+    pub fn new<T>(
+        allocator_pool: AllocatorPool,
+        cwd: T,
+        output_options: OutputOptions,
+        format_options: FormatOptions,
+    ) -> Self
     where
         T: Into<Box<Path>>,
     {
         Self {
+            allocator_pool,
             cwd: cwd.into(),
             output_options,
             format_options,
@@ -69,10 +76,8 @@ impl FormatService {
         let path = &entry.path;
         let source_type = enable_jsx_source_type(entry.source_type);
 
-        // TODO: Use `read_to_arena_str()` like `oxlint`?
+        let allocator = self.allocator_pool.get();
         let source_text = fs::read_to_string(path).expect("Failed to read file");
-        // TODO: Use `AllocatorPool.get()` like `oxlint`?
-        let allocator = Allocator::new();
 
         let ret = Parser::new(&allocator, &source_text, source_type)
             .with_options(get_parse_options())
