@nxtedition/slice 1.0.10 → 1.0.12

package/lib/index.d.ts

@@ -26,6 +26,7 @@ export declare class PoolAllocator {
     constructor(poolTotal?: number);
     get size(): number;
     isFromPool(slice: Slice | null | undefined): boolean;
+    realloc(byteLength: number): Slice;
     realloc(slice: Slice, byteLength: number): Slice;
     get stats(): {
         size: number;
@@ -35,5 +36,10 @@ export declare class PoolAllocator {
         poolUsed: number;
         poolSize: number;
         poolCount: number;
+        buckets: {
+            free: number;
+            used: number;
+            size: number;
+        }[];
     };
 }

package/lib/index.js

@@ -228,7 +228,8 @@ export class PoolAllocator {
   #size = 0
   #padding = 0
 
-  #pools             = []
+  #poolsBucket             = []
+  #poolsBucketUsed           = []
   #poolBuffer        
   #poolOffset = 0
   #poolSize = 0
@@ -237,7 +238,8 @@ export class PoolAllocator {
   constructor(poolTotal = 128 * 1024 * 1024) {
     this.#poolBuffer = Buffer.allocUnsafe(Number.isFinite(poolTotal) ? poolTotal : 0)
     for (let n = 0; 2 ** n <= 256 * 1024; n++) {
-      this.#pools.push([])
+      this.#poolsBucket.push([])
+      this.#poolsBucketUsed.push(0)
     }
   }
 
@@ -249,19 +251,28 @@ export class PoolAllocator {
     return slice != null && slice.buffer === this.#poolBuffer
   }
 
-  realloc(slice       , byteLength        )        {
-    if (!Number.isInteger(byteLength) || byteLength < 0) {
+                                    
+                                                  
+  realloc(slice                , byteLength         )        {
+    if (typeof slice === 'number') {
+      byteLength = slice
+      slice = new Slice()
+    }
+
+    if (byteLength == null || !Number.isInteger(byteLength) || byteLength < 0) {
       throw new TypeError(`Invalid byteLength: ${byteLength}`)
     }
 
-    if (slice.byteLength === byteLength) {
+    if (slice == null) {
+      slice = new Slice()
+    } else if (slice.byteLength === byteLength) {
       return slice
     }
 
     // Ceil to nearest power of two.
     const dstIdx = byteLength <= 8 ? 3 : 32 - Math.clz32(byteLength - 1)
 
-    if (slice != null && slice.buffer === this.#poolBuffer) {
+    if (slice.buffer === this.#poolBuffer) {
       const srcIdx = 32 - Math.clz32(slice.maxByteLength - 1)
 
       if (slice.maxByteLength !== 1 << srcIdx) {
@@ -278,7 +289,8 @@ export class PoolAllocator {
         return slice
       }
 
-      this.#pools[srcIdx].push(slice.byteOffset)
+      this.#poolsBucket[srcIdx].push(slice.byteOffset)
+      this.#poolsBucketUsed[srcIdx] -= 1
       this.#poolSize -= slice.maxByteLength
     }
 
@@ -289,19 +301,26 @@ export class PoolAllocator {
     }
 
     const maxByteLength = 1 << dstIdx
-    if (this.#pools.length > 32 || maxByteLength < byteLength || (maxByteLength & 0x7) !== 0) {
+    if (
+      this.#poolsBucket.length > 32 ||
+      maxByteLength < byteLength ||
+      (maxByteLength & 0x7) !== 0
+    ) {
       throw new Error(`Invalid pool state`)
     }
 
-    if (dstIdx < this.#pools.length && this.#pools[dstIdx]?.length) {
+    if (dstIdx < this.#poolsBucket.length && this.#poolsBucket[dstIdx]?.length) {
       slice.buffer = this.#poolBuffer
-      slice.byteOffset = this.#pools[dstIdx].pop() 
+      slice.byteOffset = this.#poolsBucket[dstIdx].pop() 
       slice.byteLength = byteLength
       slice.maxByteLength = maxByteLength
 
+      this.#poolsBucketUsed[dstIdx] += 1
       this.#poolSize += maxByteLength
+      this.#size += maxByteLength
+      this.#padding += maxByteLength - byteLength
     } else if (
-      dstIdx < this.#pools.length &&
+      dstIdx < this.#poolsBucket.length &&
       this.#poolOffset + maxByteLength <= this.#poolBuffer.byteLength
     ) {
       slice.buffer = this.#poolBuffer
@@ -311,7 +330,10 @@ export class PoolAllocator {
 
       this.#poolOffset += maxByteLength
       this.#poolCount += 1
+      this.#poolsBucketUsed[dstIdx] += 1
       this.#poolSize += maxByteLength
+      this.#size += maxByteLength
+      this.#padding += maxByteLength - byteLength
     } else {
       slice.buffer = Buffer.allocUnsafeSlow(byteLength)
       slice.byteOffset = 0
@@ -319,9 +341,6 @@ export class PoolAllocator {
       slice.maxByteLength = byteLength
     }
 
-    this.#size += slice.maxByteLength
-    this.#padding += slice.maxByteLength - slice.byteLength
-
     return slice
   }
 
@@ -334,6 +353,11 @@ export class PoolAllocator {
       poolUsed: this.#poolOffset,
       poolSize: this.#poolSize,
       poolCount: this.#poolCount,
+      buckets: this.#poolsBucket.map((pool, i) => ({
+        free: pool.length,
+        used: this.#poolsBucketUsed[i],
+        size: pool.length + this.#poolsBucketUsed[i],
+      })),
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/slice",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -28,5 +28,5 @@
     "rimraf": "^6.1.3",
     "typescript": "^5.9.3"
   },
-  "gitHead": "b58c17cb0fdb8c6781ea35addb2c3b4348dba0d6"
+  "gitHead": "cfc529e921c93a1fb0292018e2026f2b326ec998"
 }