Rename ArrayBufferPool to ResourcePool for other uses.

also make sure that you can't freely call ResourcePool methods,
that would break the assumption made by DirectContextModel.

Author: lifthrasiir

README.md

@@ -123,7 +123,7 @@ The actual memory usage can be as low as a half of the specified due to the inte
 
 * Level 2 runs a thorough search with about 300 sets of parameters and takes about a minute or two. This is best useful for the release build and you would like to save best parameters for later uses.
 
-While not strictly required, `Packer.optimize` in the API strongly recommends the use of `arrayBufferPool` in the options object. Otherwise the optimization can run slower especially with larger memory. The pool can be created via `new ArrayBufferPool()`.
+While not strictly required, `Packer.optimize` in the API strongly recommends the use of `resourcePool` in the options object. Otherwise the optimization can run slower especially with larger memory. The pool can be created via `new ResourcePool()`.
 
 ### Advanced Configuration
 

cli.mjs

@@ -2,7 +2,7 @@
 
 import * as fs from 'fs';
 import * as process from 'process';
-import { ArrayBufferPool, Packer, defaultSparseSelectors } from './index.mjs';
+import { ResourcePool, Packer, defaultSparseSelectors } from './index.mjs';
 
 let VERSION = 'unknown';
 try {
@@ -116,7 +116,7 @@ async function parseArgs(args) {
     const inputs = [];
     let currentInput = {};
     const options = {
-        arrayBufferPool: new ArrayBufferPool(),
+        resourcePool: new ResourcePool(),
     };
     let command;
     let optimize;

index.d.ts

@@ -1,9 +1,14 @@
-export class ArrayBufferPool {
+export class ResourcePool {
     constructor();
+    /** @deprecated Should not be used externally! */
     allocate(parent: object, size: number): ArrayBuffer;
+    /** @deprecated Should not be used externally! */
     release(buf: ArrayBuffer): void;
 }
 
+/** @deprecated Use {@link ResourcePool} instead */
+export const ArrayBufferPool = ResourcePool;
+
 export type ScaledFreq = number;
 
 export type Bit = 0 | 1;
@@ -42,7 +47,9 @@ export interface DirectContextModelOptions {
     precision: number;
     modelMaxCount: number;
     modelRecipBaseCount: number;
-    arrayBufferPool?: ArrayBufferPool;
+    resourcePool?: ResourcePool;
+    /** @deprecated Use {@link DirectContextModelOptions.resourcePool} instead */
+    arrayBufferPool?: ResourcePool;
 }
 
 export class DirectContextModel implements Model {
@@ -90,7 +97,7 @@ export class DefaultModel implements LogisticMixModel {
     flushByte(currentByte: number, inBits: number): void;
     release(): void;
 
-    readonly quitesSeen: Set<number>;
+    readonly quotesSeen: Set<number>;
 }
 
 export interface CompressOptions extends AnsOptions {
@@ -164,7 +171,9 @@ export interface PackerOptions {
     precision?: number;
     modelMaxCount?: number;
     modelRecipBaseCount?: number;
-    arrayBufferPool?: ArrayBufferPool;
+    resourcePool?: ResourcePool;
+    /** @deprecated Use {@link PackerOptions.resourcePool} instead */
+    arrayBufferPool?: ResourcePool;
     recipLearningRate?: number;
     numAbbreviations?: number;
     allowFreeVars?: boolean;

index.mjs

@@ -70,14 +70,14 @@ const getPerformanceObject = async () => {
 
 //------------------------------------------------------------------------------
 
-export class ArrayBufferPool {
+export class ResourcePool {
     constructor() {
-        // pool.get(size) is an array of ArrayBuffer of given size
-        this.pool = new Map();
+        // arrayBuffers.get(size) is an array of ArrayBuffer of given size
+        this.arrayBuffers = new Map();
     }
 
     allocate(parent, size) {
-        const available = this.pool.get(size);
+        const available = this.arrayBuffers.get(size);
         let buf;
         if (available) buf = available.pop();
         if (!buf) buf = new ArrayBuffer(size);
@@ -86,15 +86,17 @@ export class ArrayBufferPool {
 
     // FinalizationRegistry is also possible, but GC couldn't keep up with the memory usage
     release(buf) {
-        let available = this.pool.get(buf.byteLength);
+        let available = this.arrayBuffers.get(buf.byteLength);
         if (!available) {
             available = [];
-            this.pool.set(buf.byteLength, available);
+            this.arrayBuffers.set(buf.byteLength, available);
         }
         available.push(buf);
     }
 }
 
+export const ArrayBufferPool = ResourcePool;
+
 const newUintArray = (pool, parent, nbits, length) => {
     if (nbits <= 8) return new Uint8Array(pool ? pool.allocate(parent, length) : length);
     if (nbits <= 16) return new Uint16Array(pool ? pool.allocate(parent, length * 2) : length);
@@ -230,18 +232,18 @@ export class AnsDecoder {
 //------------------------------------------------------------------------------
 
 export class DirectContextModel {
-    constructor({ inBits, contextBits, precision, modelMaxCount, modelRecipBaseCount, arrayBufferPool }) {
+    constructor({ inBits, contextBits, precision, modelMaxCount, modelRecipBaseCount, arrayBufferPool, resourcePool }) {
         this.inBits = inBits;
         this.contextBits = contextBits;
         this.precision = precision;
         this.modelMaxCount = modelMaxCount;
         this.modelBaseCount = 1 / modelRecipBaseCount;
 
-        this.arrayBufferPool = arrayBufferPool;
-        this.predictions = newUintArray(arrayBufferPool, this, precision, 1 << contextBits);
-        this.counts = newUintArray(arrayBufferPool, this, ceilLog2(modelMaxCount + 1), 1 << contextBits);
+        this.resourcePool = resourcePool || arrayBufferPool;
+        this.predictions = newUintArray(this.resourcePool, this, precision, 1 << contextBits);
+        this.counts = newUintArray(this.resourcePool, this, ceilLog2(modelMaxCount + 1), 1 << contextBits);
 
-        if (arrayBufferPool) {
+        if (this.resourcePool) {
             // we need to initialize the array since it may have been already used,
             // but UintXXArray.fill is comparatively slow, less than 5 GB/s even in fastest browsers.
             // we instead use more memory to confirm that each bit of context has been initialized.
@@ -251,7 +253,7 @@ export class DirectContextModel {
             // we choose a new mark to mark initialized elements *in this instance*.
             // if the mark reaches 255 we reset the entire array and start over.
             // this scheme effectively reduces the number of fill calls by a factor of 510.
-            this.confirmations = newUintArray(arrayBufferPool, this, 8, (1 << contextBits) + 1);
+            this.confirmations = newUintArray(this.resourcePool, this, 8, (1 << contextBits) + 1);
             this.mark = this.confirmations[1 << contextBits] + 1;
             if (this.mark === 256) {
                 this.mark = 1;
@@ -326,10 +328,10 @@ export class DirectContextModel {
     }
 
     release() {
-        if (this.arrayBufferPool) {
-            if (this.predictions) this.arrayBufferPool.release(this.predictions.buffer);
-            if (this.counts) this.arrayBufferPool.release(this.counts.buffer);
-            if (this.confirmations) this.arrayBufferPool.release(this.confirmations.buffer);
+        if (this.resourcePool) {
+            if (this.predictions) this.resourcePool.release(this.predictions.buffer);
+            if (this.counts) this.resourcePool.release(this.counts.buffer);
+            if (this.confirmations) this.resourcePool.release(this.confirmations.buffer);
             this.predictions = null;
             this.counts = null;
             this.confirmations = null;
@@ -630,7 +632,7 @@ export class Packer {
             modelRecipBaseCount: options.modelRecipBaseCount || 20,
             recipLearningRate: options.recipLearningRate || Math.max(1, 500),
             contextBits: options.contextBits,
-            arrayBufferPool: options.arrayBufferPool,
+            resourcePool: options.resourcePool || options.arrayBufferPool,
             numAbbreviations: typeof options.numAbbreviations === 'number' ? options.numAbbreviations : 64,
             allowFreeVars: options.allowFreeVars,
         };

test.mjs

@@ -1,8 +1,8 @@
 import test from 'ava';
 import * as crypto from 'crypto';
 import {
-    ArrayBufferPool, AnsEncoder, AnsDecoder, DirectContextModel, DefaultModel, Packer,
     compressWithModel, decompressWithModel
+    ResourcePool, AnsEncoder, AnsDecoder, DirectContextModel, DefaultModel, Packer,
 } from './index.mjs';
 
 //------------------------------------------------------------------------------
@@ -263,14 +263,14 @@ test('inputEndsWithByte', t => {
 //------------------------------------------------------------------------------
 
 test('DirectContextModel.confirmations', t => {
-    const arrayBufferPool = new ArrayBufferPool();
+    const resourcePool = new ResourcePool();
     const options = {
         inBits: 8,
         outBits: 8,
         precision: 16,
         contextBits: 5, // 32 elements
         modelMaxCount: 63,
-        arrayBufferPool,
+        resourcePool,
     };
 
     // the size of 1 will set ~8 elements and test for partial fills.