perf: generator performance optimization work

chompfile.toml

@@ -84,10 +84,10 @@ run = 'node -C source --enable-source-maps $DEP'
 name = 'test:integration'
 dep = 'integration:'
 
-
 [[task]]
 name = 'integration:#'
 deps = ['test/##.test.js', 'lib']
+# env = { JSPM_GENERATOR_LOG = '1' }
 run = 'node -C source --enable-source-maps $DEP'
 
 [[task]]

package.json

@@ -64,7 +64,7 @@
     "open": "^8.4.1",
     "prettier": "^2.8.4",
     "rollup": "^2.79.1",
-    "typescript": "^4.9.5"
+    "typescript": "^5.5.4"
   },
   "files": [
     "dist",

src/common/fetch-common.ts

@@ -1,4 +1,4 @@
-export interface Response {
+export interface WrappedResponse {
   status: number;
   statusText?: string;
   text?(): Promise<string>;
@@ -7,29 +7,105 @@ export interface Response {
 }
 
 export type FetchFn = (
-  url: URL,
+  url: URL | string,
   ...args: any[]
-) => Promise<Response | globalThis.Response>;
+) => Promise<WrappedResponse | globalThis.Response>
 
-let retryCount = 3;
+export type WrappedFetch = ((
+  url: URL | string,
+  ...args: any[]
+) => Promise<WrappedResponse | globalThis.Response>)  & {
+  arrayBuffer: (url: URL | string, ...args: any[]) => Promise<ArrayBuffer | null>,
+  text: (url: URL | string, ...args: any[]) => Promise<string | null>
+};
+
+let retryCount = 5, poolSize = 100;
 
 export function setRetryCount(count: number) {
   retryCount = count;
 }
 
+export function setFetchPoolSize(size: number) {
+  poolSize = size;
+}
+
 /**
- * Wraps a fetch request with retry logic on exceptions, which is useful for
- * spotty connections that may fail intermittently.
+ * Wraps a fetch request with pooling, and retry logic on exceptions (emfile / network errors).
  */
-export function wrapWithRetry(fetch: FetchFn): FetchFn {
-  return async function (url: URL, ...args: any[]) {
+export function wrappedFetch(fetch: FetchFn): WrappedFetch {
+  const wrappedFetch = async function (url: URL | string, ...args: any[]) {
+    url = url.toString();
     let retries = 0;
-    while (true) {
-      try {
-        return await fetch(url, ...args);
-      } catch (e) {
-        if (retries++ >= retryCount) throw e;
+    try {
+      await pushFetchPool();
+      while (true) {
+        try {
+          return await fetch(url, ...args);
+        } catch (e) {
+          if (retries++ >= retryCount) throw e;
+        }
       }
+    } finally {
+      popFetchPool();
     }
   };
+  wrappedFetch.arrayBuffer = async function (url, ...args) {
+    url = url.toString();
+    let retries = 0;
+    try {
+      await pushFetchPool();
+      while (true) {
+        try {
+          var res = await fetch(url, ...args);
+        } catch (e) {
+          if (retries++ >= retryCount)
+            throw e;
+          continue;
+        }
+        switch (res.status) {
+          case 200:
+          case 304:
+            break;
+          // not found = null
+          case 404:
+            return null;
+          default:
+            throw new Error(`Invalid status code ${res.status}`);
+        }
+        try {
+          return await res.arrayBuffer();
+        } catch (e) {
+          if (retries++ >= retryCount &&
+              e.code === "ERR_SOCKET_TIMEOUT" ||
+              e.code === "ETIMEOUT" ||
+              e.code === "ECONNRESET" ||
+              e.code === 'FETCH_ERROR') {
+
+          }
+        }
+      }
+    } finally {
+      popFetchPool();
+    }
+  };
+  wrappedFetch.text = async function (url, ...args) {
+    const arrayBuffer = await this.arrayBuffer(url, ...args);
+    if (!arrayBuffer)
+        return null;
+    return new TextDecoder().decode(arrayBuffer);
+  };
+  return wrappedFetch;
+}
+
+// restrict in-flight fetches to a pool of 100
+let p = [];
+let c = 0;
+function pushFetchPool () {
+  if (++c > poolSize)
+    return new Promise(r => p.push(r));
+}
+function popFetchPool () {
+  c--;
+  if (p.length)
+    p.shift()();
 }

src/common/fetch-deno.ts

@@ -1,9 +1,9 @@
 import { fileURLToPath } from "url";
-import { wrapWithRetry, FetchFn } from "./fetch-common.js";
+import { wrappedFetch, WrappedFetch } from "./fetch-common.js";
 
 export function clearCache() {}
 
-export const fetch: FetchFn = wrapWithRetry(async function (
+export const fetch: WrappedFetch = wrappedFetch(async function (
   url: URL,
   ...args: any[]
 ) {

src/common/fetch-native.ts

@@ -1,42 +1,5 @@
-import { FetchFn, wrapWithRetry } from "./fetch-common.js";
+import { WrappedFetch, wrappedFetch } from "./fetch-common.js";
 
-// Browser native fetch doesn't deal well with high contention
-// restrict in-flight fetches to a pool of 100
-let p = [];
-let c = 0;
-function pushFetchPool() {
-  if (++c > 100) return new Promise((r) => p.push(r));
-}
-function popFetchPool() {
-  c--;
-  if (p.length) p.shift()();
-}
-
-export const fetch: FetchFn = wrapWithRetry(async function fetch(url, opts) {
-  const poolQueue = pushFetchPool();
-  if (poolQueue) await poolQueue;
-  try {
-    return await globalThis.fetch(url as any, opts);
-  } catch (e) {
-    // CORS errors throw a fetch type error
-    // Instead, treat this as an actual unauthorized response
-    if (e instanceof TypeError) {
-      return {
-        status: 401,
-        async text() {
-          return "";
-        },
-        async json() {
-          throw new Error("Not JSON");
-        },
-        arrayBuffer() {
-          return new ArrayBuffer(0);
-        },
-      };
-    }
-  } finally {
-    popFetchPool();
-  }
-});
+export const fetch: WrappedFetch = wrappedFetch(globalThis.fetch);
 
 export const clearCache = () => {};

src/common/fetch-node.ts

@@ -1,6 +1,6 @@
 // @ts-ignore
 import version from "../version.js";
-import { wrapWithRetry, FetchFn } from "./fetch-common.js";
+import { wrappedFetch, WrappedFetch } from "./fetch-common.js";
 import path from "path";
 import { homedir } from "os";
 import process from "process";
@@ -65,11 +65,10 @@ const dirResponse = {
   },
 };
 
-export const fetch: FetchFn = wrapWithRetry(async function (
+export const fetch: WrappedFetch = wrappedFetch(async function (
   url: URL,
   opts?: Record<string, any>
 ) {
-  if (!opts) throw new Error("Always expect fetch options to be passed");
   const urlString = url.toString();
   const protocol = urlString.slice(0, urlString.indexOf(":") + 1);
   let source: string | Buffer;

src/common/fetch-vscode.ts

@@ -1,4 +1,4 @@
-import { FetchFn, wrapWithRetry } from "./fetch-common.js";
+import { WrappedFetch, wrappedFetch } from "./fetch-common.js";
 import { fetch as _fetch } from "./fetch-native.js";
 export { clearCache } from "./fetch-native.js";
 
@@ -33,11 +33,10 @@ const dirResponse = {
 // @ts-ignore
 const vscode = require("vscode");
 
-export const fetch: FetchFn = wrapWithRetry(async function (
+export const fetch: WrappedFetch = wrappedFetch(async function (
   url: URL,
   opts?: Record<string, any>
 ) {
-  if (!opts) throw new Error("Always expect fetch options to be passed");
   const urlString = url.toString();
   const protocol = urlString.slice(0, urlString.indexOf(":") + 1);
   switch (protocol) {