@genome-spy/core 0.43.2 → 0.43.3

package/dist/src/data/sources/lazy/bigBedSource.js

@@ -92,11 +92,22 @@ export default class BigBedSource extends SingleAxisWindowedSource {
 }
 
 /**
- * A specific optimization for Hautaniemi Lab's Methylation project, where
- * we have hundreds of columns having small integers (0-100).
- * This parser avoids generating piles of garbage to be collected by the GC.
- * We don't split the line into an array of strings, but instead parse the
- * integer fields directly from the original string.
+ * An optimized parser for Hautaniemi Lab's Methylation project, where
+ * we have hundreds of columns having small integers (0-100). This is over 5x
+ * faster than @gmod/bed's parser.
+ *
+ * Techniques used:
+ *
+ * 1. Avoid generating garbage by parsing integers directly from the string,
+ *    i.e., without splitting the line into an array of strings.
+ * 2. Use a template object to avoid hidden class changes after each property
+ *    assignment. Avoids garbage generation.
+ * 3. Generate and compile code that uses constants to access object properties,
+ *    avoiding Map lookups during assignment.
+ * 4. Input chrom, startPos, and endPos as parameters so that @gmod/bbi's
+ *    output doesn't first need to be converted to a string just to be parsed
+ *    again.
+ *
  * This parser doesn't support arrays, etc. at the moment. This could, however,
  * be extended into a fully-featured parser.
  *
@@ -152,28 +163,11 @@ function makeFastParser(bed) {
         return value * sign;
     }
 
-    const fieldParsers = fields.map((field) => {
-        const { name, type } = field;
-
-        if (["ubyte", "int", "uint"].includes(type)) {
-            return () => {
-                currentObject[name] = parseInt();
-            };
-        } else if (field.isNumeric) {
-            return () => {
-                currentObject[name] = Number(parseString());
-            };
-        } else if (["char", "string", "lstring"].includes(type)) {
-            return () => {
-                currentObject[name] = parseString();
-            };
-        } else {
-            throw new Error("Unsupported type: " + type);
-        }
-    });
-
     const templateFields = fields.map(
-        (field) => `"${field.name}": ${field.isNumeric ? "0" : "emptyString"}`
+        (field) =>
+            `${JSON.stringify(field.name)}: ${
+                field.isNumeric ? "0" : "emptyString"
+            }`
     );
 
     /**
@@ -196,6 +190,42 @@ function makeFastParser(bed) {
             }
         };`)();
 
+    /*
+     * Generate setter code that uses constant field names to access the
+     * object's properties. This avoids Map lookups and allows for efficient
+     * machine code to be generated by the VM.
+     */
+    const fieldParsers = fields.map((field) => {
+        const type = field.type;
+        const name = JSON.stringify(field.name);
+
+        if (["ubyte", "int", "uint"].includes(type)) {
+            return `d[${name}] = parseInt();`;
+        } else if (field.isNumeric) {
+            return `d[${name}] = Number(parseString());`;
+        } else if (["char", "string", "lstring"].includes(type)) {
+            return `d[${name}] = parseString();`;
+        } else {
+            throw new Error("Unsupported type: " + type);
+            // TODO: Implement them
+        }
+    });
+
+    /*
+     * Split the field parsers into chunks to avoid creating so large
+     * functions that the JavaScript VM would decline to optimize it.
+     * Not sure if this is really necessary, but the added cost is minimal.
+     */
+    const chunckedFieldParsers = chunk(fieldParsers, 50).map((chunk, i) =>
+        Function(
+            "parseInt",
+            "parseString",
+            `return function parseFieldChunk${i}(d) {
+            ${chunk.join("\n")}
+        }`
+        )(parseInt, parseString)
+    );
+
     /**
      * @param {string} line
      */
@@ -216,8 +246,8 @@ function makeFastParser(bed) {
 
         currentObject = makeTemplate(chrom, chromStart, chromEnd);
 
-        for (let j = 0, n = fieldParsers.length; j < n; j++) {
-            fieldParsers[j]();
+        for (const parser of chunckedFieldParsers) {
+            parser(currentObject);
         }
 
         return currentObject;
@@ -225,3 +255,15 @@ function makeFastParser(bed) {
 
     return parseLine;
 }
+
+/**
+ * @param {T[]} arr
+ * @param {number} size
+ * @template T
+ */
+function chunk(arr, size) {
+    // https://www.30secondsofcode.org/js/s/split-array-into-chunks/
+    return Array.from({ length: Math.ceil(arr.length / size) }, (_v, i) =>
+        arr.slice(i * size, i * size + size)
+    );
+}

package/package.json

@@ -7,7 +7,7 @@
   },
   "contributors": [],
   "license": "MIT",
-  "version": "0.43.2",
+  "version": "0.43.3",
   "jsdelivr": "dist/bundle/index.js",
   "unpkg": "dist/bundle/index.js",
   "browser": "dist/bundle/index.js",
@@ -65,5 +65,5 @@
     "vega-scale": "^7.1.1",
     "vega-util": "^1.16.0"
   },
-  "gitHead": "12ff70326672ed7ca34ef081c01fc25f19cf1ede"
+  "gitHead": "0c6e0418a7461b40da98896bfaf5e05732384e85"
 }