@nxtedition/slice 1.0.1 → 1.0.2

package/lib/index.bench.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/index.d.ts

@@ -21,15 +21,10 @@ export declare class Slice {
     [Symbol.toStringTag](): string;
     [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string;
 }
-/**
- * A buddy allocator using XOR bitmap for efficient coalescing.
- * Each bit tracks the XOR of a buddy pair's allocation state.
- * When a bit is 0, both buddies have the same state (both free or both allocated).
- * When a bit is 1, the buddies have different states.
- */
-export declare class BuddyAllocator {
+export declare class PoolAllocator {
     #private;
     constructor(poolTotal?: number);
+    isFromPool(slice: Slice): boolean;
     realloc(slice: Slice, byteLength: number): Slice;
     get stats(): {
         size: number;
@@ -39,7 +34,5 @@ export declare class BuddyAllocator {
         poolUsed: number;
         poolSize: number;
         poolCount: number;
-        poolList: number[];
     };
-    isFromPool(slice: Slice | null | undefined): boolean;
 }

package/lib/index.js

@@ -81,7 +81,11 @@ export class Slice {
       sourceEnd += this.byteOffset
     }
 
-    if (this.buffer === target && sourceStart === targetStart) {
+    if (
+      sourceStart === targetStart &&
+      this.buffer.buffer === target.buffer &&
+      this.buffer.byteOffset === target.byteOffset
+    ) {
       return sourceEnd - sourceStart
     }
 
@@ -217,74 +221,25 @@ export class Slice {
   }
 }
 
-/**
- * A buddy allocator using XOR bitmap for efficient coalescing.
- * Each bit tracks the XOR of a buddy pair's allocation state.
- * When a bit is 0, both buddies have the same state (both free or both allocated).
- * When a bit is 1, the buddies have different states.
- */
-export class BuddyAllocator {
-  #size         = 0
-  #padding         = 0
-  #poolCount         = 0
+export class PoolAllocator {
+  #size = 0
 
+  #pools             = []
   #poolBuffer        
-  #poolTotal        
-  #minOrder        
-  #maxOrder        
-
-  // Free lists indexed by order - simple arrays with push/pop
-  #freeLists             = []
-
-  // XOR bitmap for coalescing - single contiguous buffer for cache locality
-  // Each order has a view into this buffer
-  // Bit = 0: both buddies same state, Bit = 1: different states
-  #bitmaps                = []
-  #bitmapBuffer                     = null
+  #poolOffset = 0
+  #poolSize = 0
+  #poolCount = 0
+  #padding = 0
 
   constructor(poolTotal = 128 * 1024 * 1024) {
-    // Handle invalid pool sizes gracefully - fall back to no pool
-    if (!Number.isFinite(poolTotal) || poolTotal <= 0) {
-      this.#poolBuffer = Buffer.allocUnsafe(0)
-      this.#poolTotal = 0
-      this.#minOrder = 3
-      this.#maxOrder = 0
-      return
-    }
-
-    // Round up to nearest power of 2
-    this.#maxOrder = Math.ceil(Math.log2(poolTotal))
-    this.#poolTotal = 1 << this.#maxOrder
-
-    // Minimum block size is 8 bytes (order 3)
-    this.#minOrder = 3
-
-    this.#poolBuffer = Buffer.allocUnsafe(this.#poolTotal)
-
-    // Calculate total bitmap size and offsets for each order
-    // Total pairs = 2^(maxOrder-minOrder) - 1, total words ≈ that / 32
-    let totalWords = 0
-    const offsets = []
-    for (let order = 0; order <= this.#maxOrder; order++) {
-      offsets.push(totalWords)
-      const numPairs = 1 << Math.max(0, this.#maxOrder - order - 1)
-      totalWords += Math.ceil(numPairs / 32)
-    }
-
-    // Allocate single contiguous buffer for all bitmaps
-    this.#bitmapBuffer = new ArrayBuffer(totalWords * 4)
-
-    // Create views into the buffer for each order
-    for (let order = 0; order <= this.#maxOrder; order++) {
-      this.#freeLists.push([])
-
-      const numPairs = 1 << Math.max(0, this.#maxOrder - order - 1)
-      const numWords = Math.ceil(numPairs / 32)
-      this.#bitmaps.push(new Uint32Array(this.#bitmapBuffer, offsets[order] * 4, numWords))
+    this.#poolBuffer = Buffer.allocUnsafe(Number.isFinite(poolTotal) ? poolTotal : 0)
+    for (let n = 0; 2 ** n <= 256 * 1024; n++) {
+      this.#pools.push([])
     }
+  }
 
-    // Initially, the entire buffer is one free block at max order
-    this.#freeLists[this.#maxOrder].push(0)
+  isFromPool(slice       ) {
+    return slice != null && slice.buffer === this.#poolBuffer
   }
 
   realloc(slice       , byteLength        )        {
@@ -292,35 +247,32 @@ export class BuddyAllocator {
       throw new TypeError(`Invalid byteLength: ${byteLength}`)
     }
 
-    if (slice == null) {
-      slice = new Slice()
-    } else if (!(slice instanceof Slice)) {
-      throw new TypeError('slice must be a Slice instance')
-    }
-
     if (slice.byteLength === byteLength) {
       return slice
     }
 
-    const dstOrder = byteLength === 0 ? 0 : this.#getOrder(byteLength)
+    // Ceil to nearest power of two.
+    const dstIdx = byteLength <= 8 ? 3 : 32 - Math.clz32(byteLength - 1)
 
     if (this.isFromPool(slice)) {
-      // Derive order from maxByteLength
-      const srcOrder = 31 - Math.clz32(slice.maxByteLength)
+      const srcIdx = 32 - Math.clz32(slice.maxByteLength - 1)
+
+      if (slice.maxByteLength !== 1 << srcIdx) {
+        throw new Error(`Invalid pool state`)
+      }
 
       this.#size -= slice.byteLength
       this.#padding -= slice.maxByteLength - slice.byteLength
 
-      if (srcOrder === dstOrder) {
+      if (srcIdx === dstIdx) {
         slice.byteLength = byteLength
         this.#size += slice.byteLength
         this.#padding += slice.maxByteLength - slice.byteLength
         return slice
       }
 
-      // Free the old block
-      this.#freeBlock(slice.byteOffset, srcOrder)
-      this.#poolCount--
+      this.#pools[srcIdx].push(slice.byteOffset)
+      this.#poolSize -= slice.maxByteLength
     }
 
     slice.reset()
@@ -329,134 +281,52 @@ export class BuddyAllocator {
       return slice
     }
 
-    const offset = this.#allocBlock(dstOrder)
-    if (offset == null) {
-      // Fall back to regular allocation
-      slice.buffer = Buffer.allocUnsafeSlow(byteLength)
-      slice.byteOffset = 0
+    const maxByteLength = 1 << dstIdx
+    if (this.#pools.length > 32 || maxByteLength < byteLength || (maxByteLength & 0x7) !== 0) {
+      throw new Error(`Invalid pool state`)
+    }
+
+    if (dstIdx < this.#pools.length && this.#pools[dstIdx]?.length) {
+      slice.buffer = this.#poolBuffer
+      slice.byteOffset = this.#pools[dstIdx].pop() 
       slice.byteLength = byteLength
-      slice.maxByteLength = byteLength
-    } else {
+      slice.maxByteLength = maxByteLength
+
+      this.#poolSize += maxByteLength
+    } else if (
+      dstIdx < this.#pools.length &&
+      this.#poolOffset + maxByteLength <= this.#poolBuffer.byteLength
+    ) {
       slice.buffer = this.#poolBuffer
-      slice.byteOffset = offset
+      slice.byteOffset = this.#poolOffset
       slice.byteLength = byteLength
-      slice.maxByteLength = 1 << dstOrder
+      slice.maxByteLength = maxByteLength
 
-      this.#poolCount++
-      this.#size += byteLength
-      this.#padding += slice.maxByteLength - slice.byteLength
+      this.#poolOffset += maxByteLength
+      this.#poolCount += 1
+      this.#poolSize += maxByteLength
+    } else {
+      slice.buffer = Buffer.allocUnsafeSlow(byteLength)
+      slice.byteOffset = 0
+      slice.byteLength = byteLength
+      slice.maxByteLength = byteLength
     }
 
+    this.#size += slice.byteLength
+    this.#padding += slice.maxByteLength - slice.byteLength
+
     return slice
   }
 
   get stats() {
-    // Calculate free space from all free lists
-    let freeSpace = 0
-    for (let order = this.#minOrder; order <= this.#maxOrder; order++) {
-      freeSpace += this.#freeLists[order].length << order
-    }
-
-    const poolUsed = this.#poolTotal - freeSpace
-
     return {
       size: this.#size,
       padding: this.#padding,
       ratio: this.#size > 0 ? (this.#size + this.#padding) / this.#size : 1,
-      poolTotal: this.#poolTotal,
-      poolUsed,
-      poolSize: poolUsed,
+      poolTotal: this.#poolBuffer.byteLength,
+      poolUsed: this.#poolOffset,
+      poolSize: this.#poolSize,
       poolCount: this.#poolCount,
-      poolList: this.#freeLists.map((list) => list.length),
-    }
-  }
-
-  isFromPool(slice                          )          {
-    return slice != null && slice.buffer === this.#poolBuffer
-  }
-
-  #toggleBit(offset        , order        )          {
-    if (order >= this.#maxOrder) {
-      return false
-    }
-    const pairIndex = offset >>> (order + 1)
-    const wordIndex = pairIndex >>> 5
-    const bitMask = 1 << (pairIndex & 31)
-    const bitmap = this.#bitmaps[order]
-    bitmap[wordIndex] ^= bitMask
-    return (bitmap[wordIndex] & bitMask) !== 0
-  }
-
-  #allocBlock(order        )                {
-    // Try to allocate from pool
-    if (order > this.#maxOrder || this.#poolTotal === 0) {
-      return null
-    }
-
-    // Find the smallest order with a free block
-    let currentOrder = order
-    while (currentOrder <= this.#maxOrder && this.#freeLists[currentOrder].length === 0) {
-      currentOrder++
-    }
-
-    if (currentOrder > this.#maxOrder) {
-      return null
     }
-
-    // Pop the free block
-    const offset = this.#freeLists[currentOrder].pop() 
-
-    // Found block at exact order - just toggle and return
-    if (currentOrder === order) {
-      this.#toggleBit(offset, order)
-      return offset
-    }
-
-    // Split down to the requested order
-    while (currentOrder > order) {
-      currentOrder--
-      // Add buddy to free list
-      const buddyOffset = offset ^ (1 << currentOrder)
-      this.#freeLists[currentOrder].push(buddyOffset)
-      // Toggle bit - one buddy free, one allocated/kept
-      this.#toggleBit(offset, currentOrder)
-    }
-
-    return offset
-  }
-
-  #freeBlock(offset        , order        )       {
-    while (order < this.#maxOrder) {
-      // Toggle bit and check if we can coalesce
-      const isDifferent = this.#toggleBit(offset, order)
-
-      if (isDifferent) {
-        // Bit is now 1: buddy is allocated, can't coalesce
-        this.#freeLists[order].push(offset)
-        return
-      }
-
-      // Bit is now 0: both buddies are free, coalesce
-      // Remove buddy from free list
-      const buddyOffset = offset ^ (1 << order)
-      const idx = this.#freeLists[order].indexOf(buddyOffset)
-      if (idx !== -1) {
-        // Swap with last and pop for O(1) removal
-        const last = this.#freeLists[order].length - 1
-        this.#freeLists[order][idx] = this.#freeLists[order][last]
-        this.#freeLists[order].pop()
-      }
-
-      // Move up to parent level
-      offset = offset & ~(1 << order)
-      order++
-    }
-
-    // Reached max order
-    this.#freeLists[order].push(offset)
-  }
-
-  #getOrder(byteLength        )         {
-    return byteLength <= 1 << this.#minOrder ? this.#minOrder : 32 - Math.clz32(byteLength - 1)
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/slice",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -19,6 +19,5 @@
     "amaroc": "^1.0.1",
     "rimraf": "^6.1.2",
     "typescript": "^5.9.3"
-  },
-  "gitHead": "2517ca631e010f17f7ba8be4e1b854ad18cbd746"
+  }
 }