refactor(napi/parser, allocator): raw transfer: store buffer size and align as consts

Author: overlookmotel

.github/generated/ast_changes_watch_list.yml

@@ -3,6 +3,7 @@
 
 src:
   - '.github/generated/ast_changes_watch_list.yml'
+  - 'crates/oxc_allocator/src/generated/fixed_size_constants.rs'
   - 'crates/oxc_ast/src/ast/comment.rs'
   - 'crates/oxc_ast/src/ast/js.rs'
   - 'crates/oxc_ast/src/ast/jsx.rs'
@@ -68,6 +69,7 @@ src:
   - 'napi/parser/generated/lazy/walk.js'
   - 'napi/parser/src/generated/assert_layouts.rs'
   - 'napi/parser/src/generated/derive_estree.rs'
+  - 'napi/parser/src/generated/raw_transfer_constants.rs'
   - 'napi/parser/src/raw_transfer_types.rs'
   - 'npm/oxc-types/types.d.ts'
   - 'tasks/ast_tools/src/**'

crates/oxc_allocator/src/fixed_size.rs

@@ -5,10 +5,12 @@ use std::{
     ptr::NonNull,
 };
 
-use crate::Allocator;
+use crate::{
+    Allocator,
+    fixed_size_constants::{BUFFER_ALIGN, BUFFER_SIZE},
+};
 
 const TWO_GIB: usize = 1 << 31;
-const FOUR_GIB: usize = 1 << 32;
 
 // What we ideally want is an allocation 2 GiB in size, aligned on 4 GiB.
 // But system allocator on Mac OS refuses allocations with 4 GiB alignment.
@@ -25,10 +27,8 @@ const FOUR_GIB: usize = 1 << 32;
 // Could just use that built-in workaround, rather than implementing our own, or allocate a 6 GiB chunk
 // with alignment 16, to skip Rust's built-in workaround.
 // Note: Rust's workaround will likely commit a whole page of memory, just to store the real pointer.
-const ALLOC_SIZE: usize = FOUR_GIB;
+const ALLOC_SIZE: usize = BUFFER_SIZE + TWO_GIB;
 const ALLOC_ALIGN: usize = TWO_GIB;
-const CHUNK_SIZE: usize = TWO_GIB;
-pub const CHUNK_ALIGN: usize = FOUR_GIB;
 
 const ALLOC_LAYOUT: Layout = match Layout::from_size_align(ALLOC_SIZE, ALLOC_ALIGN) {
     Ok(layout) => layout,
@@ -71,12 +71,12 @@ impl FixedSizeAllocator {
             alloc_ptr.add(offset)
         };
 
-        debug_assert!(chunk_ptr.as_ptr() as usize % CHUNK_ALIGN == 0);
+        debug_assert!(chunk_ptr.as_ptr() as usize % BUFFER_ALIGN == 0);
 
-        // SAFETY: Memory region starting at `chunk_ptr` with `CHUNK_SIZE` bytes is within
+        // SAFETY: Memory region starting at `chunk_ptr` with `BUFFER_SIZE` bytes is within
         // the allocation we just made.
         // `chunk_ptr` has high alignment (4 GiB). `size` is large and a high power of 2 (2 GiB).
-        let allocator = unsafe { Allocator::from_raw_parts(chunk_ptr, CHUNK_SIZE) };
+        let allocator = unsafe { Allocator::from_raw_parts(chunk_ptr, BUFFER_SIZE) };
 
         // Store pointer to original allocation, so it can be used to deallocate in `drop`
         Self { allocator: ManuallyDrop::new(allocator), alloc_ptr }

crates/oxc_allocator/src/generated/fixed_size_constants.rs

@@ -0,0 +1,7 @@
+// Auto-generated code, DO NOT EDIT DIRECTLY!
+// To edit this generated file you have to edit `tasks/ast_tools/src/generators/raw_transfer.rs`.
+
+#![expect(clippy::unreadable_literal)]
+
+pub const BUFFER_SIZE: usize = 2147483648;
+pub const BUFFER_ALIGN: usize = 4294967296;

crates/oxc_allocator/src/lib.rs

@@ -65,3 +65,20 @@ pub use pool::{AllocatorGuard, AllocatorPool};
 pub use string_builder::StringBuilder;
 pub use take_in::{Dummy, TakeIn};
 pub use vec::Vec;
+
+mod generated {
+    #[cfg(all(
+        feature = "fixed_size",
+        not(feature = "disable_fixed_size"),
+        target_pointer_width = "64",
+        target_endian = "little"
+    ))]
+    pub mod fixed_size_constants;
+}
+#[cfg(all(
+    feature = "fixed_size",
+    not(feature = "disable_fixed_size"),
+    target_pointer_width = "64",
+    target_endian = "little"
+))]
+use generated::fixed_size_constants;

crates/oxc_allocator/src/pool.rs

@@ -117,10 +117,7 @@ mod wrapper {
     target_endian = "little"
 ))]
 mod wrapper {
-    use crate::{
-        Allocator,
-        fixed_size::{CHUNK_ALIGN, FixedSizeAllocator},
-    };
+    use crate::{Allocator, fixed_size::FixedSizeAllocator, fixed_size_constants::BUFFER_ALIGN};
 
     /// Structure which wraps an [`Allocator`] with fixed size of 2 GiB, and aligned on 4 GiB.
     ///
@@ -144,12 +141,12 @@ mod wrapper {
             self.0.reset();
 
             // Set data pointer back to start.
-            // SAFETY: Fixed-size allocators have data pointer originally aligned on `CHUNK_ALIGN`,
-            // and size less than `CHUNK_ALIGN`. So we can restore original data pointer by rounding down
-            // to next multiple of `CHUNK_ALIGN`.
+            // SAFETY: Fixed-size allocators have data pointer originally aligned on `BUFFER_ALIGN`,
+            // and size less than `BUFFER_ALIGN`. So we can restore original data pointer by rounding down
+            // to next multiple of `BUFFER_ALIGN`.
             unsafe {
                 let data_ptr = self.0.data_ptr();
-                let offset = data_ptr.as_ptr() as usize % CHUNK_ALIGN;
+                let offset = data_ptr.as_ptr() as usize % BUFFER_ALIGN;
                 let data_ptr = data_ptr.sub(offset);
                 self.0.set_data_ptr(data_ptr);
             }

napi/parser/generated/constants.js

@@ -1,8 +1,16 @@
 // Auto-generated code, DO NOT EDIT DIRECTLY!
 // To edit this generated file you have to edit `tasks/ast_tools/src/generators/raw_transfer.rs`.
 
-const DATA_POINTER_POS_32 = 536870908,
+const BUFFER_SIZE = 2147483648,
+  BUFFER_ALIGN = 4294967296,
+  DATA_POINTER_POS_32 = 536870908,
   IS_TS_FLAG_POS = 2147483636,
   PROGRAM_OFFSET = 0;
 
-module.exports = { DATA_POINTER_POS_32, IS_TS_FLAG_POS, PROGRAM_OFFSET };
+module.exports = {
+  BUFFER_SIZE,
+  BUFFER_ALIGN,
+  DATA_POINTER_POS_32,
+  IS_TS_FLAG_POS,
+  PROGRAM_OFFSET,
+};

napi/parser/raw-transfer/common.js

@@ -7,7 +7,7 @@ const {
   parseAsyncRaw: parseAsyncRawBinding,
   getBufferOffset,
 } = require('../bindings.js');
-const { IS_TS_FLAG_POS } = require('../generated/constants.js');
+const { BUFFER_SIZE, BUFFER_ALIGN, IS_TS_FLAG_POS } = require('../generated/constants.js');
 
 module.exports = {
   parseSyncRawImpl,
@@ -141,9 +141,8 @@ async function parseAsyncRawImpl(filename, sourceText, options, convert) {
   return data;
 }
 
-const ONE_GIB = 1 << 30,
-  TWO_GIB = ONE_GIB * 2,
-  SIX_GIB = ONE_GIB * 6;
+const ARRAY_BUFFER_SIZE = BUFFER_SIZE + BUFFER_ALIGN;
+const ONE_GIB = 1 << 30;
 
 // We keep a cache of buffers for raw transfer, so we can reuse them as much as possible.
 //
@@ -277,10 +276,10 @@ function clearBuffersCache() {
  * @returns {Uint8Array} - Buffer
  */
 function createBuffer() {
-  const arrayBuffer = new ArrayBuffer(SIX_GIB);
+  const arrayBuffer = new ArrayBuffer(ARRAY_BUFFER_SIZE);
   const offset = getBufferOffset(new Uint8Array(arrayBuffer));
-  const buffer = new Uint8Array(arrayBuffer, offset, TWO_GIB);
-  buffer.uint32 = new Uint32Array(arrayBuffer, offset, TWO_GIB / 4);
-  buffer.float64 = new Float64Array(arrayBuffer, offset, TWO_GIB / 8);
+  const buffer = new Uint8Array(arrayBuffer, offset, BUFFER_SIZE);
+  buffer.uint32 = new Uint32Array(arrayBuffer, offset, BUFFER_SIZE / 4);
+  buffer.float64 = new Float64Array(arrayBuffer, offset, BUFFER_SIZE / 8);
   return buffer;
 }

napi/parser/src/generated/raw_transfer_constants.rs

@@ -0,0 +1,7 @@
+// Auto-generated code, DO NOT EDIT DIRECTLY!
+// To edit this generated file you have to edit `tasks/ast_tools/src/generators/raw_transfer.rs`.
+
+#![expect(clippy::unreadable_literal)]
+
+pub const BUFFER_SIZE: usize = 2147483648;
+pub const BUFFER_ALIGN: usize = 4294967296;

napi/parser/src/lib.rs

@@ -49,7 +49,11 @@ mod generated {
     // Note: We intentionally don't import `generated/derive_estree.rs`. It's not needed.
     #[cfg(debug_assertions)]
     pub mod assert_layouts;
+    #[cfg(all(target_pointer_width = "64", target_endian = "little"))]
+    pub mod raw_transfer_constants;
 }
+#[cfg(all(target_pointer_width = "64", target_endian = "little"))]
+use generated::raw_transfer_constants;
 
 #[derive(Clone, Copy, PartialEq, Eq)]
 enum AstType {

napi/parser/src/raw_transfer.rs

@@ -19,6 +19,7 @@ use oxc_napi::get_source_type;
 
 use crate::{
     AstType, ParserOptions, get_ast_type, parse,
+    raw_transfer_constants::{BUFFER_ALIGN, BUFFER_SIZE},
     raw_transfer_types::{EcmaScriptModule, Error, RawTransferData},
 };
 
@@ -35,22 +36,19 @@ use crate::{
 // 2. JS bitwise operators work only on signed 32-bit integers, with 32nd bit as sign bit.
 //    So avoiding the 32nd bit being set enables using `>>` bitshift operator, which may be cheaper
 //    than `>>>`, without offsets being interpreted as negative.
-const TWO_GIB: usize = 1 << 31;
-const FOUR_GIB: usize = 1 << 32;
 
-const BUFFER_SIZE: usize = TWO_GIB;
-const BUFFER_ALIGN: usize = FOUR_GIB;
 const BUMP_ALIGN: usize = 16;
 
-/// Get offset within a `Uint8Array` which is aligned on 4 GiB.
+/// Get offset within a `Uint8Array` which is aligned on `BUFFER_ALIGN`.
 ///
 /// Does not check that the offset is within bounds of `buffer`.
-/// To ensure it always is, provide a `Uint8Array` of at least 4 GiB size.
+/// To ensure it always is, provide a `Uint8Array` of at least `BUFFER_SIZE` bytes.
 #[napi(skip_typescript)]
 pub fn get_buffer_offset(buffer: Uint8Array) -> u32 {
     let buffer = &*buffer;
-    let buffer_addr32 = buffer.as_ptr() as u32;
-    0u32.wrapping_sub(buffer_addr32)
+    let offset = BUFFER_ALIGN - (buffer.as_ptr() as usize % BUFFER_ALIGN);
+    #[expect(clippy::cast_possible_truncation)]
+    return offset as u32;
 }
 
 /// Parse AST into provided `Uint8Array` buffer, synchronously.