initial commit

2026-06-25 21:30:32 +00:00
commit 328faf6251
220 changed files with 162103 additions and 0 deletions
@@ -0,0 +1,123 @@
+/**
+ * @license
+ * Copyright The Closure Library Authors.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.module('goog.async.WorkQueue');
+goog.module.declareLegacyNamespace();
+
+const FreeList = goog.require('goog.async.FreeList');
+const {assert} = goog.require('goog.asserts');
+
+// TODO(johnlenz): generalize the WorkQueue if this is used by more
+// than goog.async.run.
+
+
+/**
+ * A low GC workqueue. The key elements of this design:
+ *   - avoids the need for goog.bind or equivalent by carrying scope
+ *   - avoids the need for array reallocation by using a linked list
+ *   - minimizes work entry objects allocation by recycling objects
+ * @final
+ * @struct
+ */
+class WorkQueue {
+  constructor() {
+    this.workHead_ = null;
+    this.workTail_ = null;
+  }
+
+  /**
+   * @param {function()} fn
+   * @param {Object|null|undefined} scope
+   */
+  add(fn, scope) {
+    const item = this.getUnusedItem_();
+    item.set(fn, scope);
+
+    if (this.workTail_) {
+      this.workTail_.next = item;
+      this.workTail_ = item;
+    } else {
+      assert(!this.workHead_);
+      this.workHead_ = item;
+      this.workTail_ = item;
+    }
+  }
+
+  /**
+   * @return {?WorkItem}
+   */
+  remove() {
+    let item = null;
+
+    if (this.workHead_) {
+      item = this.workHead_;
+      this.workHead_ = this.workHead_.next;
+      if (!this.workHead_) {
+        this.workTail_ = null;
+      }
+      item.next = null;
+    }
+    return item;
+  }
+
+  /**
+   * @param {!WorkItem} item
+   */
+  returnUnused(item) {
+    WorkQueue.freelist_.put(item);
+  }
+
+  /**
+   * @return {!WorkItem}
+   * @private
+   */
+  getUnusedItem_() {
+    return WorkQueue.freelist_.get();
+  }
+}
+
+/** @define {number} The maximum number of entries to keep for recycling. */
+WorkQueue.DEFAULT_MAX_UNUSED =
+    goog.define('goog.async.WorkQueue.DEFAULT_MAX_UNUSED', 100);
+
+/** @const @private {!FreeList<!WorkItem>} */
+WorkQueue.freelist_ = new FreeList(
+    () => new WorkItem(), item => item.reset(), WorkQueue.DEFAULT_MAX_UNUSED);
+
+/**
+ * @final
+ * @struct
+ */
+class WorkItem {
+  constructor() {
+    /** @type {?function()} */
+    this.fn = null;
+    /** @type {?Object|null|undefined} */
+    this.scope = null;
+    /** @type {?WorkItem} */
+    this.next = null;
+  }
+
+  /**
+   * @param {function()} fn
+   * @param {Object|null|undefined} scope
+   */
+  set(fn, scope) {
+    'use strict';
+    this.fn = fn;
+    this.scope = scope;
+    this.next = null;
+  }
+
+  /** Reset the work item so they don't prevent GC before reuse */
+  reset() {
+    this.fn = null;
+    this.scope = null;
+    this.next = null;
+  }
+}
+
+exports = WorkQueue;