@daneren2005/shared-memory-objects 1.1.0 → 1.3.0

package/dist/memory-buffer.js

@@ -1,327 +1,270 @@
-import { lock as E, unlock as a } from "./lock/simple-lock.js";
-import { typedArray as z } from "./utils/typedarray.js";
-const A = 0, T = 1, B = 2, x = 3, N = 4, u = 5, g = 6, m = 1, _ = 2, w = 32, p = 0, b = 1, n = 8;
-class C {
-  buf;
-  start;
-  u8;
-  u32;
-  state;
-  lock;
-  constructor(t = {}) {
-    if (this.buf = t.buf ? t.buf : new ArrayBuffer(t.size || 4096), this.start = t.start != null ? k(Math.max(t.start, 0), 4) : 0, this.u8 = new Uint8Array(this.buf), this.u32 = new Uint32Array(this.buf), this.state = new Uint32Array(this.buf, this.start, w / 4), this.lock = new Int32Array(this.buf, this.start + this.state.byteLength - 4, 1), !t.skipInitialization) {
-      const e = t.align || 8;
-      if (e < 8)
-        throw new Error(`invalid alignment: ${e}, must be a pow2 and >= 8`);
-      const s = this.initialTop(e), i = t.end != null ? Math.min(t.end, this.buf.byteLength) : this.buf.byteLength;
-      if (s >= i)
-        throw new Error(
-          `insufficient address range (0x${this.start.toString(
-            16
-          )} - 0x${i.toString(16)})`
-        );
-      this.align = e, this.doCompact = t.compact !== !1, this.doSplit = t.split !== !1, this.minSplit = t.minSplit || 16, this.end = i, this.top = s, this._free = 0, this._used = 0;
-    }
-  }
-  stats() {
-    const t = (s) => {
-      let i = 0, o = 0;
-      for (; s; )
-        if (i++, o += this.blockSize(s), s = this.blockNext(s), s > this.end) {
-          console.error(`Trying to get stats for block past end of buffer: ${s} > ${this.end}`);
-          break;
-        }
-      return { count: i, size: o };
-    }, e = t(this._free);
-    return {
-      free: e,
-      used: t(this._used),
-      top: this.top,
-      available: this.end - this.top + e.size,
-      total: this.buf.byteLength
-    };
-  }
-  callocAs(t, e, s = 0) {
-    const i = this.mallocAs(t, e);
-    return i && i.fill(s), i;
-  }
-  mallocAs(t, e) {
-    const s = this.malloc(e * M[t]);
-    return s ? z(t, this.buf, s, e) : void 0;
-  }
-  calloc(t, e = 0) {
-    const s = this.malloc(t);
-    return s && this.u8.fill(e, s, s + t), s;
-  }
-  malloc(t) {
-    if (t <= 0)
-      return 0;
-    E(this.lock);
-    const e = k(t + n, this.align), s = this.end;
-    let i = this.top, o = this._free, l = 0;
-    for (; o; ) {
-      const h = this.blockSize(o), c = o + h >= i;
-      if (c || h >= e) {
-        let S = this.mallocTop(
-          o,
-          l,
-          h,
-          e,
-          c
-        );
-        return a(this.lock), S;
-      }
-      l = o, o = this.blockNext(o);
-    }
-    if (o = i, i = o + e, i <= s) {
-      this.initBlock(o, e, this._used), this._used = o, this.top = i;
-      let h = f(o);
-      return a(this.lock), h;
-    }
-    return a(this.lock), 0;
-  }
-  mallocTop(t, e, s, i, o) {
-    if (o && t + i > this.end) return 0;
-    if (e ? this.unlinkBlock(e, t) : this._free = this.blockNext(t), this.setBlockNext(t, this._used), this._used = t, o)
-      this.top = t + this.setBlockSize(t, i);
-    else if (this.doSplit) {
-      const l = s - i;
-      l >= this.minSplit && this.splitBlock(t, i, l);
-    }
-    return f(t);
-  }
-  realloc(t, e) {
-    if (e <= 0)
-      return 0;
-    const s = d(t);
-    let i = 0, o = this._used, l = 0;
-    for (; o; ) {
-      if (o === s) {
-        [i, l] = this.reallocBlock(o, e);
-        break;
-      }
-      o = this.blockNext(o);
-    }
-    return i && i !== s && this.u8.copyWithin(
-      f(i),
-      f(s),
-      l
-    ), f(i);
-  }
-  reallocBlock(t, e) {
-    const s = this.blockSize(t), i = t + s, o = i >= this.top, l = k(e + n, this.align);
-    if (l <= s) {
-      if (this.doSplit) {
-        const h = s - l;
-        h >= this.minSplit ? this.splitBlock(t, l, h) : o && (this.top = t + l);
-      } else o && (this.top = t + l);
-      return [t, i];
-    }
-    return o && t + l < this.end ? (this.top = t + this.setBlockSize(t, l), [t, i]) : (this.free(t), [d(this.malloc(e)), i]);
-  }
-  reallocArray(t, e) {
-    if (t.buffer !== this.buf)
-      return;
-    const s = this.realloc(
-      t.byteOffset,
-      e * t.BYTES_PER_ELEMENT
-    );
-    return s ? new t.constructor(this.buf, s, e) : void 0;
-  }
-  bytesFor(t) {
-    let e;
-    if (typeof t != "number") {
-      if (t.buffer !== this.buf)
-        return;
-      e = t.byteOffset;
-    } else
-      e = t;
-    e = d(e);
-    let s = this._used;
-    for (; s; ) {
-      if (s === e)
-        return this.blockSize(e) - n;
-      s = this.blockNext(s);
-    }
-  }
-  lengthOf(t) {
-    let e = this.bytesFor(t);
-    if (e)
-      return e / this.u32.BYTES_PER_ELEMENT;
-  }
-  free(t) {
-    let e;
-    if (typeof t != "number") {
-      if (t.buffer !== this.buf)
-        return !1;
-      e = t.byteOffset;
-    } else
-      e = t;
-    E(this.lock), e = d(e);
-    let s = this._used, i = 0;
-    for (; s; ) {
-      if (s === e)
-        return i ? this.unlinkBlock(i, s) : this._used = this.blockNext(s), this.insert(s), this.doCompact && this.compact(), a(this.lock), !0;
-      i = s, s = this.blockNext(s);
-    }
-    return a(this.lock), !1;
-  }
-  freeAll() {
-    this._free = 0, this._used = 0, this.top = this.initialTop();
-  }
-  release() {
-    return delete this.u8, delete this.u32, delete this.state, delete this.buf, !0;
-  }
-  get align() {
-    return this.state[N];
-  }
-  set align(t) {
-    this.state[N] = t;
-  }
-  get end() {
-    return this.state[x];
-  }
-  set end(t) {
-    this.state[x] = t;
-  }
-  get top() {
-    return Atomics.load(this.state, B);
-  }
-  set top(t) {
-    Atomics.store(this.state, B, t);
-  }
-  get _free() {
-    return Atomics.load(this.state, A);
-  }
-  set _free(t) {
-    Atomics.store(this.state, A, t);
-  }
-  get _used() {
-    return Atomics.load(this.state, T);
-  }
-  set _used(t) {
-    Atomics.store(this.state, T, t);
-  }
-  get doCompact() {
-    return !!(this.state[u] & m);
-  }
-  set doCompact(t) {
-    t ? this.state[u] |= 1 << m - 1 : this.state[u] &= ~m;
-  }
-  get doSplit() {
-    return !!(this.state[u] & _);
-  }
-  set doSplit(t) {
-    t ? this.state[u] |= 1 << _ - 1 : this.state[u] &= ~_;
-  }
-  get minSplit() {
-    return this.state[g];
-  }
-  set minSplit(t) {
-    if (t <= n)
-      throw new Error(`illegal min split threshold: ${t}, require at least ${n + 1}`);
-    this.state[g] = t;
-  }
-  blockSize(t) {
-    return Atomics.load(this.u32, (t >> 2) + p);
-  }
-  /**
-   * Sets & returns given block size.
-   *
-   * @param block -
-   * @param size -
-   */
-  setBlockSize(t, e) {
-    return Atomics.store(this.u32, (t >> 2) + p, e), e;
-  }
-  blockNext(t) {
-    return Atomics.load(this.u32, (t >> 2) + b);
-  }
-  /**
-   * Sets block next pointer to `next`. Use zero to indicate list end.
-   *
-   * @param block -
-   */
-  setBlockNext(t, e) {
-    Atomics.store(this.u32, (t >> 2) + b, e);
-  }
-  /**
-   * Initializes block header with given `size` and `next` pointer. Returns `block`.
-   *
-   * @param block -
-   * @param size -
-   * @param next -
-   */
-  initBlock(t, e, s) {
-    const i = t >>> 2;
-    return Atomics.store(this.u32, i + p, e), Atomics.store(this.u32, i + b, s), t;
-  }
-  unlinkBlock(t, e) {
-    this.setBlockNext(t, this.blockNext(e));
-  }
-  splitBlock(t, e, s) {
-    this.insert(
-      this.initBlock(
-        t + this.setBlockSize(t, e),
-        s,
-        0
-      )
-    ), this.doCompact && this.compact();
-  }
-  initialTop(t = this.align) {
-    return k(this.start + w + n, t) - n;
-  }
-  /**
-   * Traverses free list and attempts to recursively merge blocks
-   * occupying consecutive memory regions. Returns true if any blocks
-   * have been merged. Only called if `compact` option is enabled.
-   */
-  compact() {
-    let t = this._free, e = 0, s = 0, i, o = !1;
-    for (; t; ) {
-      for (i = t, s = this.blockNext(t); s && i + this.blockSize(i) === s; )
-        i = s, s = this.blockNext(s);
-      if (i !== t) {
-        const l = i - t + this.blockSize(i);
-        this.setBlockSize(t, l);
-        const h = this.blockNext(i);
-        let c = this.blockNext(t);
-        for (; c && c !== h; ) {
-          const S = this.blockNext(c);
-          this.setBlockNext(c, 0), c = S;
-        }
-        this.setBlockNext(t, h), o = !0;
-      }
-      t + this.blockSize(t) >= this.top && (this.top = t, e ? this.unlinkBlock(e, t) : this._free = this.blockNext(t)), e = t, t = this.blockNext(t);
-    }
-    return o;
-  }
-  /**
-   * Inserts given block into list of free blocks, sorted by address.
-   *
-   * @param block -
-   */
-  insert(t) {
-    let e = this._free, s = 0;
-    for (; e && !(t <= e); )
-      s = e, e = this.blockNext(e);
-    s ? this.setBlockNext(s, t) : this._free = t, this.setBlockNext(t, e);
-  }
-}
-const f = (r) => r > 0 ? r + n : 0, d = (r) => r > 0 ? r - n : 0, k = (r, t) => (t--, r + t & ~t), M = {
-  u8: 1,
-  u8c: 1,
-  i8: 1,
-  u16: 2,
-  i16: 2,
-  u32: 4,
-  i32: 4,
-  i64: 8,
-  u64: 8,
-  f32: 4,
-  f64: 8
-};
-export {
-  C as default
+import { lock as e, unlock as t } from "./lock/simple-lock.js";
+import { typedArray as n } from "./utils/typedarray.js";
+//#region src/memory-buffer.ts
+var r = 0, i = 1, a = 2, o = 3, s = 4, c = 5, l = 6, u = 1, d = 2, f = {
+	u8: 1,
+	u8c: 1,
+	i8: 1,
+	u16: 2,
+	i16: 2,
+	u32: 4,
+	i32: 4,
+	i64: 8,
+	u64: 8,
+	f32: 4,
+	f64: 8
+}, p = 32, m = 0, h = 1, g = 8, _ = class {
+	buf;
+	start;
+	u8;
+	u32;
+	state;
+	lock;
+	constructor(e = {}) {
+		if (this.buf = e.buf ? e.buf : new ArrayBuffer(e.size || 4096), this.start = e.start == null ? 0 : b(Math.max(e.start, 0), 4), this.u8 = new Uint8Array(this.buf), this.u32 = new Uint32Array(this.buf), this.state = new Uint32Array(this.buf, this.start, 8), this.lock = new Int32Array(this.buf, this.start + this.state.byteLength - 4, 1), !e.skipInitialization) {
+			let t = e.align || 8;
+			if (t < 8) throw Error(`invalid alignment: ${t}, must be a pow2 and >= 8`);
+			let n = this.initialTop(t), r = e.end == null ? this.buf.byteLength : Math.min(e.end, this.buf.byteLength);
+			if (n >= r) throw Error(`insufficient address range (0x${this.start.toString(16)} - 0x${r.toString(16)})`);
+			this.align = t, this.doCompact = e.compact !== !1, this.doSplit = e.split !== !1, this.minSplit = e.minSplit || 16, this.end = r, this.top = n, this._free = 0, this._used = 0;
+		}
+	}
+	stats() {
+		let e = (e) => {
+			let t = 0, n = 0;
+			for (; e;) if (t++, n += this.blockSize(e), e = this.blockNext(e), e > this.end) {
+				console.error(`Trying to get stats for block past end of buffer: ${e} > ${this.end}`);
+				break;
+			}
+			return {
+				count: t,
+				size: n
+			};
+		}, t = e(this._free);
+		return {
+			free: t,
+			used: e(this._used),
+			top: this.top,
+			available: this.end - this.top + t.size,
+			total: this.buf.byteLength
+		};
+	}
+	callocAs(e, t, n = 0) {
+		let r = this.mallocAs(e, t);
+		return r && r.fill(n), r;
+	}
+	mallocAs(e, t) {
+		let r = this.malloc(t * f[e]);
+		return r ? n(e, this.buf, r, t) : void 0;
+	}
+	calloc(e, t = 0) {
+		let n = this.malloc(e);
+		return n && this.u8.fill(t, n, n + e), n;
+	}
+	malloc(n) {
+		if (n <= 0) return 0;
+		e(this.lock);
+		let r = b(n + 8, this.align), i = this.end, a = this.top, o = this._free, s = 0;
+		for (; o;) {
+			let e = this.blockSize(o), n = o + e >= a;
+			if (n || e >= r) {
+				let i = this.mallocTop(o, s, e, r, n);
+				return t(this.lock), i;
+			}
+			s = o, o = this.blockNext(o);
+		}
+		if (o = a, a = o + r, a <= i) {
+			this.initBlock(o, r, this._used), this._used = o, this.top = a;
+			let e = v(o);
+			return t(this.lock), e;
+		}
+		return t(this.lock), 0;
+	}
+	mallocTop(e, t, n, r, i) {
+		if (i && e + r > this.end) return 0;
+		if (t ? this.unlinkBlock(t, e) : this._free = this.blockNext(e), this.setBlockNext(e, this._used), this._used = e, i) this.top = e + this.setBlockSize(e, r);
+		else if (this.doSplit) {
+			let t = n - r;
+			t >= this.minSplit && this.splitBlock(e, r, t);
+		}
+		return v(e);
+	}
+	realloc(e, t) {
+		if (t <= 0) return 0;
+		let n = y(e), r = 0, i = this._used, a = 0;
+		for (; i;) {
+			if (i === n) {
+				[r, a] = this.reallocBlock(i, t);
+				break;
+			}
+			i = this.blockNext(i);
+		}
+		return r && r !== n && this.u8.copyWithin(v(r), v(n), a), v(r);
+	}
+	reallocBlock(e, t) {
+		let n = this.blockSize(e), r = e + n, i = r >= this.top, a = b(t + 8, this.align);
+		if (a <= n) {
+			if (this.doSplit) {
+				let t = n - a;
+				t >= this.minSplit ? this.splitBlock(e, a, t) : i && (this.top = e + a);
+			} else i && (this.top = e + a);
+			return [e, r];
+		}
+		return i && e + a < this.end ? (this.top = e + this.setBlockSize(e, a), [e, r]) : (this.free(e), [y(this.malloc(t)), r]);
+	}
+	reallocArray(e, t) {
+		if (e.buffer !== this.buf) return;
+		let n = this.realloc(e.byteOffset, t * e.BYTES_PER_ELEMENT);
+		return n ? new e.constructor(this.buf, n, t) : void 0;
+	}
+	bytesFor(e) {
+		let t;
+		if (typeof e != "number") {
+			if (e.buffer !== this.buf) return;
+			t = e.byteOffset;
+		} else t = e;
+		t = y(t);
+		let n = this._used;
+		for (; n;) {
+			if (n === t) return this.blockSize(t) - 8;
+			n = this.blockNext(n);
+		}
+	}
+	lengthOf(e) {
+		let t = this.bytesFor(e);
+		if (t) return t / this.u32.BYTES_PER_ELEMENT;
+	}
+	free(n) {
+		let r;
+		if (typeof n != "number") {
+			if (n.buffer !== this.buf) return !1;
+			r = n.byteOffset;
+		} else r = n;
+		e(this.lock), r = y(r);
+		let i = this._used, a = 0;
+		for (; i;) {
+			if (i === r) return a ? this.unlinkBlock(a, i) : this._used = this.blockNext(i), this.insert(i), this.doCompact && this.compact(), t(this.lock), !0;
+			a = i, i = this.blockNext(i);
+		}
+		return t(this.lock), !1;
+	}
+	freeAll() {
+		this._free = 0, this._used = 0, this.top = this.initialTop();
+	}
+	release() {
+		return delete this.u8, delete this.u32, delete this.state, delete this.buf, !0;
+	}
+	get align() {
+		return this.state[s];
+	}
+	set align(e) {
+		this.state[s] = e;
+	}
+	get end() {
+		return this.state[o];
+	}
+	set end(e) {
+		this.state[o] = e;
+	}
+	get top() {
+		return Atomics.load(this.state, a);
+	}
+	set top(e) {
+		Atomics.store(this.state, a, e);
+	}
+	get isEmpty() {
+		return this._used === 0;
+	}
+	get _free() {
+		return Atomics.load(this.state, r);
+	}
+	set _free(e) {
+		Atomics.store(this.state, r, e);
+	}
+	get _used() {
+		return Atomics.load(this.state, i);
+	}
+	set _used(e) {
+		Atomics.store(this.state, i, e);
+	}
+	get doCompact() {
+		return !!(this.state[c] & u);
+	}
+	set doCompact(e) {
+		e ? this.state[c] |= 1 : this.state[c] &= -2;
+	}
+	get doSplit() {
+		return !!(this.state[c] & d);
+	}
+	set doSplit(e) {
+		e ? this.state[c] |= 2 : this.state[c] &= -3;
+	}
+	get minSplit() {
+		return this.state[l];
+	}
+	set minSplit(e) {
+		if (e <= 8) throw Error(`illegal min split threshold: ${e}, require at least 9`);
+		this.state[l] = e;
+	}
+	blockSize(e) {
+		return Atomics.load(this.u32, (e >> 2) + m);
+	}
+	setBlockSize(e, t) {
+		return Atomics.store(this.u32, (e >> 2) + m, t), t;
+	}
+	blockNext(e) {
+		return Atomics.load(this.u32, (e >> 2) + h);
+	}
+	setBlockNext(e, t) {
+		Atomics.store(this.u32, (e >> 2) + h, t);
+	}
+	initBlock(e, t, n) {
+		let r = e >>> 2;
+		return Atomics.store(this.u32, r + m, t), Atomics.store(this.u32, r + h, n), e;
+	}
+	unlinkBlock(e, t) {
+		this.setBlockNext(e, this.blockNext(t));
+	}
+	splitBlock(e, t, n) {
+		this.insert(this.initBlock(e + this.setBlockSize(e, t), n, 0)), this.doCompact && this.compact();
+	}
+	initialTop(e = this.align) {
+		return b(this.start + 32 + 8, e) - 8;
+	}
+	compact() {
+		let e = this._free, t = 0, n = 0, r, i = !1;
+		for (; e;) {
+			for (r = e, n = this.blockNext(e); n && r + this.blockSize(r) === n;) r = n, n = this.blockNext(n);
+			if (r !== e) {
+				let t = r - e + this.blockSize(r);
+				this.setBlockSize(e, t);
+				let n = this.blockNext(r), a = this.blockNext(e);
+				for (; a && a !== n;) {
+					let e = this.blockNext(a);
+					this.setBlockNext(a, 0), a = e;
+				}
+				this.setBlockNext(e, n), i = !0;
+			}
+			e + this.blockSize(e) >= this.top && (this.top = e, t ? this.unlinkBlock(t, e) : this._free = this.blockNext(e)), t = e, e = this.blockNext(e);
+		}
+		return i;
+	}
+	insert(e) {
+		let t = this._free, n = 0;
+		for (; t && !(e <= t);) n = t, t = this.blockNext(t);
+		n ? this.setBlockNext(n, e) : this._free = e, this.setBlockNext(e, t);
+	}
 };
-//# sourceMappingURL=memory-buffer.js.map
+function v(e) {
+	return e > 0 ? e + 8 : 0;
+}
+function y(e) {
+	return e > 0 ? e - 8 : 0;
+}
+function b(e, t) {
+	return t--, e + t & ~t;
+}
+//#endregion
+export { g as SIZEOF_MEM_BLOCK, p as SIZEOF_STATE, _ as default };
+
+//# sourceMappingURL=memory-buffer.js.map