@woosh/meep-engine 2.165.7 → 2.167.0

package/src/core/cache/FrequencySketch.d.ts

@@ -84,30 +84,9 @@ export class FrequencySketch<T> {
      * @param {number} input_hash the element to add
      */
     increment(input_hash: number): void;
-    /**
-     * Increments the specified counter by 1 if it is not already at the maximum value (15).
-     *
-     * @param {number} i the table index (8 counters)
-     * @param {number} j the counter to increment
-     * @returns {boolean} if incremented
-     */
-    incrementAt(i: number, j: number): boolean;
     /**
      * Reduces every counter by half of its original value.
      */
     reset(): void;
-    /**
-     * Returns the table index for the counter at the specified depth.
-     * @param {number} item the element's hash
-     * @param {number} i the counter depth
-     * @returns {number} the table index
-     */
-    indexOf(item: number, i: number): number;
-    /**
-     * Applies a supplemental hash function to a given hash code, which defends against poor quality
-     * @param {number} v
-     * @returns {number}
-     */
-    spread(v: number): number;
 }
 //# sourceMappingURL=FrequencySketch.d.ts.map

package/src/core/cache/FrequencySketch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FrequencySketch.d.ts","sourceRoot":"","sources":["../../../../src/core/cache/FrequencySketch.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH;IACI;;;OAGG;IACH,YAFU,MAAM,CAED;IACf;;;OAGG;IACH,WAFU,MAAM,CAEF;IACd;;;OAGG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IACb;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;;;;OAMG;IACH,4BAFW,MAAM,QAsBhB;IAED;;;;;OAKG;IACH,oBAFa,OAAO,CAInB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,MAAM,CAclB;IAED;;;;;;;OAOG;IACH,sBAFW,MAAM,QAwBhB;IAED;;;;;;OAMG;IACH,eAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAgBnB;IAED;;OAEG;IACH,cAaC;IAED;;;;;OAKG;IACH,cAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAOlB;IAED;;;;OAIG;IACH,UAHW,MAAM,GACJ,MAAM,CASlB;CACJ"}
+{"version":3,"file":"FrequencySketch.d.ts","sourceRoot":"","sources":["../../../../src/core/cache/FrequencySketch.js"],"names":[],"mappings":"AAsEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH;IACI;;;OAGG;IACH,YAFU,MAAM,CAED;IACf;;;OAGG;IACH,WAFU,MAAM,CAEF;IACd;;;OAGG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IACb;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;;;;OAMG;IACH,4BAFW,MAAM,QAsBhB;IAED;;;;;OAKG;IACH,oBAFa,OAAO,CAInB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,MAAM,CAgBlB;IAED;;;;;;;OAOG;IACH,sBAFW,MAAM,QAwBhB;IAED;;OAEG;IACH,cAaC;CACJ"}

package/src/core/cache/FrequencySketch.js

@@ -19,6 +19,55 @@ const ONE_MASK = 0x11111111;
  */
 const MAX_INT_32 = 2147483647;
 
+/**
+ * Applies a supplemental hash function to a given hash code, which defends against poor quality hashes.
+ * @param {number} v
+ * @returns {number}
+ */
+function spread(v) {
+    let x = v;
+
+    x = ((x >>> 16) ^ x) * 0x45d9f3b;
+    x = ((x >>> 16) ^ x) * 0x45d9f3b;
+
+    return (x >>> 16) ^ x;
+}
+
+/**
+ * Returns the table index for the counter at the specified depth.
+ * @param {number} item the element's hash
+ * @param {number} i the counter depth
+ * @param {number} tableMask the table-size mask
+ * @returns {number} the table index
+ */
+function indexOf(item, i, tableMask) {
+    let hash = (item + SEED[i]) * SEED[i];
+    hash += (hash >>> 16);
+
+    return hash & tableMask;
+}
+
+/**
+ * Increments the specified counter by 1 if it is not already at the maximum value (15).
+ * @param {Uint32Array} table the counter table
+ * @param {number} i the table index (8 counters)
+ * @param {number} j the counter to increment
+ * @returns {boolean} if incremented
+ */
+function incrementAt(table, i, j) {
+    const offset = j << 2;
+    const mask = (0xF << offset);
+
+    const existing_table_value = table[i];
+
+    if ((existing_table_value & mask) !== mask) {
+        table[i] = existing_table_value + (1 << offset);
+        return true;
+    }
+
+    return false;
+}
+
 /**
  * A probabilistic multiset for estimating the popularity of an element within a time window. The
  * maximum frequency of an element is limited to 15 (4-bits) and an aging process periodically
@@ -121,13 +170,15 @@ export class FrequencySketch {
      * @returns {number} the estimated number of occurrences of the element; possibly zero but never negative
      */
     frequency(input_hash) {
-        const hash = this.spread(input_hash);
+        const table = this.table;
+        const tableMask = this.tableMask;
+        const hash = spread(input_hash);
         const start = (hash & 3) << 2;
         let frequency = MAX_INT_32;
 
         for (let i = 0; i < 4; i++) {
-            const index = this.indexOf(hash, i);
-            const count = (this.table[index] >>> ((start + i) << 2)) & 0xf;
+            const index = indexOf(hash, i, tableMask);
+            const count = (table[index] >>> ((start + i) << 2)) & 0xf;
             frequency = min2(frequency, count);
         }
 
@@ -143,21 +194,21 @@ export class FrequencySketch {
      * @param {number} input_hash the element to add
      */
     increment(input_hash) {
-        const hash = this.spread(input_hash);
+        const table = this.table;
+        const tableMask = this.tableMask;
+        const hash = spread(input_hash);
         const start = (hash & 3) << 2;
 
         // Loop unrolling improves throughput by 5m ops/s
-        const index0 = this.indexOf(hash, 0);
-        const index1 = this.indexOf(hash, 1);
-        const index2 = this.indexOf(hash, 2);
-        const index3 = this.indexOf(hash, 3);
-
-        // Evaluate all four counters unconditionally; `||` would short-circuit and skip the remaining
-        // increments as soon as the first one returned true, so only one of the four counters would ever advance.
-        const added0 = this.incrementAt(index0, start);
-        const added1 = this.incrementAt(index1, start + 1);
-        const added2 = this.incrementAt(index2, start + 2);
-        const added3 = this.incrementAt(index3, start + 3);
+        const index0 = indexOf(hash, 0, tableMask);
+        const index1 = indexOf(hash, 1, tableMask);
+        const index2 = indexOf(hash, 2, tableMask);
+        const index3 = indexOf(hash, 3, tableMask);
+
+        const added0 = incrementAt(table, index0, start);
+        const added1 = incrementAt(table, index1, start + 1);
+        const added2 = incrementAt(table, index2, start + 2);
+        const added3 = incrementAt(table, index3, start + 3);
 
         const added = added0 || added1 || added2 || added3;
 
@@ -166,29 +217,6 @@ export class FrequencySketch {
         }
     }
 
-    /**
-     * Increments the specified counter by 1 if it is not already at the maximum value (15).
-     *
-     * @param {number} i the table index (8 counters)
-     * @param {number} j the counter to increment
-     * @returns {boolean} if incremented
-     */
-    incrementAt(i, j) {
-        const offset = j << 2;
-        const mask = (0xF << offset);
-
-        const table = this.table;
-
-        const existing_table_value = table[i];
-
-        if ((existing_table_value & mask) !== mask) {
-            table[i] = existing_table_value + (1 << offset);
-            return true;
-        }
-
-        return false;
-    }
-
     /**
      * Reduces every counter by half of its original value.
      */
@@ -206,31 +234,4 @@ export class FrequencySketch {
 
         this.size = (this.size >>> 1) - (count >>> 2);
     }
-
-    /**
-     * Returns the table index for the counter at the specified depth.
-     * @param {number} item the element's hash
-     * @param {number} i the counter depth
-     * @returns {number} the table index
-     */
-    indexOf(item, i) {
-        let hash = (item + SEED[i]) * SEED[i];
-        hash += (hash >>> 16);
-
-        return hash & this.tableMask;
-    }
-
-    /**
-     * Applies a supplemental hash function to a given hash code, which defends against poor quality
-     * @param {number} v
-     * @returns {number}
-     */
-    spread(v) {
-        let x = v;
-
-        x = ((x >>> 16) ^ x) * 0x45d9f3b;
-        x = ((x >>> 16) ^ x) * 0x45d9f3b;
-
-        return (x >>> 16) ^ x;
-    }
 }

package/src/core/cache/wtinylfu/CacheElementWTinylfu.d.ts

@@ -0,0 +1,17 @@
+export class CacheElementWTinylfu extends CacheElement<any, any> {
+    constructor();
+    /**
+     *
+     * @type {CacheRegionType}
+     */
+    region: CacheRegionType;
+    /**
+     * Cached key hash (keyHashFunction(key)), computed once at admission so the frequency-sketch paths
+     * (increment / frequency / admission duel) never recompute it.
+     * @type {number}
+     */
+    keyHash: number;
+}
+import { CacheElement } from "../CacheElement.js";
+import { CacheRegionType } from "./CacheRegionType.js";
+//# sourceMappingURL=CacheElementWTinylfu.d.ts.map

package/src/core/cache/wtinylfu/CacheElementWTinylfu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheElementWTinylfu.d.ts","sourceRoot":"","sources":["../../../../../src/core/cache/wtinylfu/CacheElementWTinylfu.js"],"names":[],"mappings":"AAGA;;IAEI;;;OAGG;IACH,QAFU,eAAe,CAEO;IAEhC;;;;OAIG;IACH,SAFU,MAAM,CAEJ;CACf;6BAjB0B,oBAAoB;gCACjB,sBAAsB"}

package/src/core/cache/wtinylfu/CacheElementWTinylfu.js

@@ -0,0 +1,18 @@
+import {CacheElement} from "../CacheElement.js";
+import {CacheRegionType} from "./CacheRegionType.js";
+
+export class CacheElementWTinylfu extends CacheElement {
+
+    /**
+     *
+     * @type {CacheRegionType}
+     */
+    region = CacheRegionType.Window;
+
+    /**
+     * Cached key hash (keyHashFunction(key)), computed once at admission so the frequency-sketch paths
+     * (increment / frequency / admission duel) never recompute it.
+     * @type {number}
+     */
+    keyHash = 0;
+}

package/src/core/cache/wtinylfu/CacheRegionType.d.ts

@@ -0,0 +1,10 @@
+/**
+ * *
+ */
+export type CacheRegionType = number;
+export namespace CacheRegionType {
+    let Window: number;
+    let Trial: number;
+    let Protected: number;
+}
+//# sourceMappingURL=CacheRegionType.d.ts.map

package/src/core/cache/wtinylfu/CacheRegionType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheRegionType.d.ts","sourceRoot":"","sources":["../../../../../src/core/cache/wtinylfu/CacheRegionType.js"],"names":[],"mappings":";;;8BAEU,MAAM"}

package/src/core/cache/wtinylfu/CacheRegionType.js

@@ -0,0 +1,10 @@
+/**
+ *
+ * @enum {number}
+ * @private
+ */
+export const CacheRegionType = {
+    Window: 0,
+    Trial: 1,
+    Protected: 2
+};

package/src/core/cache/wtinylfu/CacheRegionWTinylfu.d.ts

@@ -0,0 +1,66 @@
+export class CacheRegionWTinylfu {
+    /**
+     *
+     * @param {number} maxWeight
+     */
+    constructor({ maxWeight }?: number);
+    /**
+     * Add new element to this region
+     * @param {CacheElementWTinylfu} element
+     * @param {number} [weight=element.weight]
+     */
+    add(element: CacheElementWTinylfu, weight?: number): void;
+    /**
+     * Update to MRU
+     * @param {CacheElementWTinylfu} element
+     */
+    touch(element: CacheElementWTinylfu): void;
+    /**
+     *
+     * @returns {CacheElementWTinylfu<Key,Value>|null}
+     */
+    findEvictionVictim(): CacheElementWTinylfu<Key, Value> | null;
+    /**
+     *
+     * @param {CacheElementWTinylfu<Key,Value>} element
+     * @param {number} [weight=element.weight]
+     * @private
+     */
+    private __removeElement;
+    /**
+     *
+     * @param {CacheElementWTinylfu<Key,Value>} element
+     * @param {number} [weight=element.weight]
+     */
+    remove(element: any, weight?: number): void;
+    /**
+     * Total weight of all elements in this region.
+     *
+     * @returns {number}
+     */
+    get weight(): number;
+    /**
+     *
+     * @param {number} delta
+     */
+    adjustWeight(delta: number): void;
+    /**
+     *
+     * @returns {number}
+     */
+    get maxWeight(): number;
+    /**
+     * Would the region exceed its capacity if `extraWeight` were added?
+     * Pass 0 (default) to test the current state.
+     * @param {number} [extraWeight=0]
+     * @returns {boolean}
+     */
+    wouldExceedCapacity(extraWeight?: number): boolean;
+    /**
+     * Empty the region. Elements are abandoned (the cache drops them from its lookup map).
+     */
+    clear(): void;
+    #private;
+}
+import { CacheElementWTinylfu } from "./CacheElementWTinylfu.js";
+//# sourceMappingURL=CacheRegionWTinylfu.d.ts.map

package/src/core/cache/wtinylfu/CacheRegionWTinylfu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheRegionWTinylfu.d.ts","sourceRoot":"","sources":["../../../../../src/core/cache/wtinylfu/CacheRegionWTinylfu.js"],"names":[],"mappings":"AAIA;IA8BI;;;OAGG;IACH,4BAFW,MAAM,EAWhB;IAED;;;;OAIG;IACH,aAHW,oBAAoB,WACpB,MAAM,QAmBhB;IAED;;;OAGG;IACH,eAFW,oBAAoB,QAoB9B;IAED;;;OAGG;IACH,sBAFa,gCAA+B,GAAC,IAAI,CAIhD;IAED;;;;;OAKG;IACH,wBAcC;IAED;;;;OAIG;IACH,8BAFW,MAAM,QAMhB;IAED;;;;OAIG;IACH,qBAEC;IAED;;;OAGG;IACH,oBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,wBAEC;IAED;;;;;OAKG;IACH,kCAHW,MAAM,GACJ,OAAO,CAInB;IAED;;OAEG;IACH,cAIC;;CAEJ;qCArLkC,2BAA2B"}

package/src/core/cache/wtinylfu/CacheRegionWTinylfu.js

@@ -0,0 +1,183 @@
+import {assert} from "../../assert.js";
+import {CacheElementWTinylfu} from "./CacheElementWTinylfu.js";
+
+
+export class CacheRegionWTinylfu {
+
+    /**
+     * How much "weight" the region can hold before it starts evicting elements
+     * @type {number}
+     * @private
+     */
+    #allowedMaxWeight = Number.POSITIVE_INFINITY;
+
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    #currentWeight = 0;
+
+    /**
+     * Head (next is LRU direction, previous is MRU direction)
+     * @type {CacheElementWTinylfu|null}
+     * @private
+     */
+    #first = null;
+
+    /**
+     * Tail (next is LRU direction, previous is MRU direction)
+     * @type {CacheElementWTinylfu|null}
+     * @private
+     */
+    #last = null;
+
+    /**
+     *
+     * @param {number} maxWeight
+     */
+    constructor({
+                    maxWeight = Number.POSITIVE_INFINITY
+                } = {}) {
+
+        assert.isNumber(maxWeight, 'maxWeight');
+        assert.notNaN(maxWeight, 'maxWeight');
+        assert.greaterThanOrEqual(maxWeight, 0, 'maxWeight < 0');
+
+        this.#allowedMaxWeight = maxWeight;
+    }
+
+    /**
+     * Add new element to this region
+     * @param {CacheElementWTinylfu} element
+     * @param {number} [weight=element.weight]
+     */
+    add(element, weight = element.weight){
+        assert.ok(element instanceof CacheElementWTinylfu);
+
+        // patch the element in
+        element.next = this.#first;
+
+        if (this.#first !== null) {
+            this.#first.previous = element;
+        }
+        this.#first = element;
+
+        if (this.#last === null) {
+            this.#last = element;
+        }
+
+        //update weight
+        this.#currentWeight += weight;
+    }
+
+    /**
+     * Update to MRU
+     * @param {CacheElementWTinylfu} element
+     */
+    touch(element) {
+        if (element === this.#first) {
+            // already at the front
+            return;
+        }
+
+        // update end-pointers
+        if (element === this.#last) {
+            this.#last = element.previous;
+        }
+
+        element.unlink(); //detach from the list
+
+        if (this.#first !== null) {
+            element.next = this.#first;
+            this.#first.previous = element;
+        }
+        this.#first = element;
+    }
+
+    /**
+     *
+     * @returns {CacheElementWTinylfu<Key,Value>|null}
+     */
+    findEvictionVictim() {
+        return this.#last;
+    }
+
+    /**
+     *
+     * @param {CacheElementWTinylfu<Key,Value>} element
+     * @param {number} [weight=element.weight]
+     * @private
+     */
+    __removeElement(element, weight = element.weight) {
+        // remove from the queue
+        if (element === this.#first) {
+            this.#first = element.next;
+        }
+
+        if (element === this.#last) {
+            this.#last = element.previous;
+        }
+
+        element.unlink();
+
+        //update weight
+        this.#currentWeight -= weight;
+    }
+
+    /**
+     *
+     * @param {CacheElementWTinylfu<Key,Value>} element
+     * @param {number} [weight=element.weight]
+     */
+    remove(element, weight = element.weight) {
+        assert.ok(element != null, "Attempted to remove undefined element");
+
+        this.__removeElement(element, weight);
+    }
+
+    /**
+     * Total weight of all elements in this region.
+     *
+     * @returns {number}
+     */
+    get weight() {
+        return this.#currentWeight;
+    }
+
+    /**
+     *
+     * @param {number} delta
+     */
+    adjustWeight(delta) {
+        this.#currentWeight += delta;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    get maxWeight() {
+        return this.#allowedMaxWeight;
+    }
+
+    /**
+     * Would the region exceed its capacity if `extraWeight` were added?
+     * Pass 0 (default) to test the current state.
+     * @param {number} [extraWeight=0]
+     * @returns {boolean}
+     */
+    wouldExceedCapacity(extraWeight = 0) {
+        return this.#currentWeight + extraWeight > this.#allowedMaxWeight;
+    }
+
+    /**
+     * Empty the region. Elements are abandoned (the cache drops them from its lookup map).
+     */
+    clear() {
+        this.#first = null;
+        this.#last = null;
+        this.#currentWeight = 0;
+    }
+
+}