ARROW-12832: [JS] Write benchmarks in TypeScript

domoritz · TheNeuralBit · commit 488fcd7abfbe · 2021-05-22T11:03:02.000-07:00
Closes apache#10361 from domoritz/ts-perf Authored-by: Dominik Moritz <domoritz@gmail.com> Signed-off-by: Brian Hulette <hulettbh@gmail.com>
diff --git a/js/DEVELOP.md b/js/DEVELOP.md
@@ -72,7 +72,9 @@ Uses [lerna](https://github.com/lerna/lerna) to publish each build target to npm
 
 # Running the Performance Benchmarks
 
-First, compile the bundles with `yarn build` and generate perf data with `yarn create:perfdata`. Then you can run the benchmarks with `yarn perf`. You can change the target you want to test by changing the imports in `perf/index.js`. To print the results to stderr as JSON, add the `--json` flag (e.g. `yarn perf --json 2> perf.json`).
+First, generate perf data with `yarn create:perfdata`. Then you can run the benchmarks with `yarn perf`. To print the results to stderr as JSON, add the `--json` flag (e.g. `yarn perf --json 2> perf.json`).
+
+You can change the target you want to test by changing the imports in `perf/index.ts`. Note that you need to compile the bundles with `yarn build` before you can import them.
 
 # Updating the Arrow format flatbuffers generated code
 
diff --git a/js/package.json b/js/package.json
@@ -11,7 +11,7 @@
     "build": "cross-env NODE_NO_WARNINGS=1 gulp build",
     "clean": "cross-env NODE_NO_WARNINGS=1 gulp clean",
     "debug": "cross-env NODE_NO_WARNINGS=1 gulp debug",
-    "perf": "node ./perf/index.js",
+    "perf": "ts-node-transpile-only ./perf/index.ts",
     "test:integration": "node ./bin/integration.js --mode validate",
     "create:perfdata": "python ./test/data/tables/generate.py ./test/data/tables/tracks.arrow",
     "release": "./npm-release.sh",
diff --git a/js/perf/config.ts b/js/perf/config.ts
@@ -15,34 +15,23 @@
 // specific language governing permissions and limitations
 // under the License.
 
-const fs = require('fs');
-const path = require('path');
-const glob = require('glob');
+import {readFileSync} from 'fs';
+import {resolve, parse} from 'path';
+import {sync} from 'glob';
 
-const config = [];
-const filenames = glob.sync(path.resolve(__dirname, `../test/data/tables/`, `*.arrow`));
+const filenames = sync(resolve(__dirname, `../test/data/tables/`, `*.arrow`));
 
-const countBys = {
-    tracks: ['origin', 'destination']
-}
-const counts = {
-    tracks: [
-        {column: 'lat',    test: 'gt', value: 0        },
-        {column: 'lng',    test: 'gt', value: 0        },
-        {column: 'origin', test: 'eq', value: 'Seattle'},
-    ]
-}
+export default filenames.map(filename => {
+    const { name } = parse(filename);
+    return {
+        name,
+        buffers: [readFileSync(filename)],
+        countBys: ['origin', 'destination'],
+        counts: [
+            {column: 'lat',    test: 'gt' as 'gt' | 'eq', value: 0        },
+            {column: 'lng',    test: 'gt' as 'gt' | 'eq', value: 0        },
+            {column: 'origin', test: 'eq' as 'gt' | 'eq', value: 'Seattle'},
+        ],
+    };
+});
 
-for (const filename of filenames) {
-    const { name } = path.parse(filename);
-    if (name in counts) {
-        config.push({
-            name,
-            buffers: [fs.readFileSync(filename)],
-            countBys: countBys[name],
-            counts: counts[name],
-        });
-    }
-}
-
-module.exports = config;
diff --git a/js/perf/index.ts b/js/perf/index.ts
@@ -15,27 +15,35 @@
 // specific language governing permissions and limitations
 // under the License.
 
-// Use the ES5 UMD target as perf baseline
-// const { predicate, Table, RecordBatchReader } = require('../targets/es5/umd');
-// const { predicate, Table, RecordBatchReader } = require('../targets/es5/cjs');
-// const { predicate, Table, RecordBatchReader } = require('../targets/es2015/umd');
-const { predicate, Table, DataFrame, RecordBatchReader } = require('../targets/es2015/cjs');
-const kleur = require('kleur');
-const b = require('benny');
+// Alternatively, use bundles for performance tests
+// import * as Arrow from '../targets/es5/umd';
+// import * as Arrow from '../targets/es5/cjs';
+// import * as Arrow from '../targets/es2015/umd';
+// import * as Arrow from '../targets/es2015/cjs';
+
+import * as Arrow from '../src/Arrow';
+
+import config from './config';
+import b from 'benny';
+import { CaseResult, Summary } from 'benny/lib/internal/common-types';
+import kleur from 'kleur';
+
+const { predicate, Table, DataFrame, RecordBatchReader } = Arrow;
 const { col } = predicate;
 
+
 const args = process.argv.slice(2);
 const json = args[0] === '--json';
 
 const formatter = new Intl.NumberFormat();
-function formatNumber(number, precision) {
+function formatNumber(number: number, precision = 0) {
     const rounded = number > precision * 10 ? Math.round(number) : parseFloat((number).toPrecision(precision));
-    return formatter.format(rounded)
+    return formatter.format(rounded);
 }
 
-const results = []
+const results: CaseResult[] = [];
 
-function cycle(result, _summary) {
+function cycle(result: CaseResult, _summary: Summary) {
     const duration = result.details.median * 1000;
     if (json) {
         results.push(result);
@@ -45,7 +53,7 @@ function cycle(result, _summary) {
     );
 }
 
-for (const { name, buffers } of require('./config')) {
+for (const { name, buffers } of config) {
     b.suite(
         `Parse "${name}"`,
 
@@ -54,42 +62,42 @@ for (const { name, buffers } of require('./config')) {
         }),
 
         b.add(`readBatches`, () => {
-            for (recordBatch of RecordBatchReader.from(buffers)) {}
+            for (const _recordBatch of RecordBatchReader.from(buffers)) {}
         }),
 
         b.cycle(cycle)
     );
 
-    const table = Table.from(buffers)
+    const table = Table.from(buffers);
     const schema = table.schema;
 
     const suites = [{
             name: `Get "${name}" values by index`,
-            fn(vector) {
+            fn(vector: Arrow.Column<any>) {
                 for (let i = -1, n = vector.length; ++i < n;) {
-                    value = vector.get(i);
+                    vector.get(i);
                 }
             }
         }, {
             name: `Iterate "${name}" vectors`,
-            fn(vector) { for (value of vector) {} }
+            fn(vector: Arrow.Column<any>) { for (const _value of vector) {} }
         }, {
             name: `Slice toArray "${name}" vectors`,
-            fn(vector) { xs = vector.slice().toArray(); }
+            fn(vector: Arrow.Column<any>) { vector.slice().toArray(); }
         }, {
             name: `Slice "${name}" vectors`,
-            fn(vector) { xs = vector.slice(); }
+            fn(vector: Arrow.Column<any>) { vector.slice(); }
         }];
 
     for (const {name, fn} of suites) {
         b.suite(
             name,
 
             ...schema.fields.map((f, i) => {
-                const vector = table.getColumnAt(i);
+                const vector = table.getColumnAt(i)!;
                 return b.add(`name: '${f.name}', length: ${formatNumber(vector.length)}, type: ${vector.type}`, () => {
-                    fn(vector)
-                })
+                    fn(vector);
+                });
             }),
 
             b.cycle(cycle)
@@ -98,14 +106,14 @@ for (const { name, buffers } of require('./config')) {
 }
 
 
-for (const { name, buffers, countBys, counts } of require('./config')) {
+for (const { name, buffers, countBys, counts } of config) {
     const df = DataFrame.from(buffers);
 
     b.suite(
         `DataFrame Iterate "${name}"`,
 
         b.add(`length: ${formatNumber(df.length)}`, () => {
-            for (value of df) {}
+            for (const _value of df) {}
         }),
 
         b.cycle(cycle)
@@ -114,8 +122,8 @@ for (const { name, buffers, countBys, counts } of require('./config')) {
     b.suite(
         `DataFrame Count By "${name}"`,
 
-        ...countBys.map((column) => b.add(
-            `name: '${column}', length: ${formatNumber(df.length)}, type: ${df.schema.fields.find((c)=> c.name === column).type}`,
+        ...countBys.map((column: string) => b.add(
+            `name: '${column}', length: ${formatNumber(df.length)}, type: ${df.schema.fields.find((c)=> c.name === column)!.type}`,
             () => df.countBy(column)
         )),
 
@@ -125,10 +133,10 @@ for (const { name, buffers, countBys, counts } of require('./config')) {
     b.suite(
         `DataFrame Filter-Scan Count "${name}"`,
 
-        ...counts.map(({ column, test, value }) => b.add(
-            `name: '${column}', length: ${formatNumber(df.length)}, type: ${df.schema.fields.find((c)=> c.name === column).type}, test: ${test}, value: ${value}`,
+        ...counts.map(({ column, test, value }: {column: string; test: 'gt' | 'eq'; value: number | string}) => b.add(
+            `name: '${column}', length: ${formatNumber(df.length)}, type: ${df.schema.fields.find((c)=> c.name === column)!.type}, test: ${test}, value: ${value}`,
             () => {
-                let filteredDf;
+                let filteredDf: Arrow.FilteredDataFrame;
                 if (test == 'gt') {
                     filteredDf = df.filter(col(column).gt(value));
                 } else if (test == 'eq') {
@@ -147,10 +155,10 @@ for (const { name, buffers, countBys, counts } of require('./config')) {
     b.suite(
         `DataFrame Filter-Iterate "${name}"`,
 
-        ...counts.map(({ column, test, value }) => b.add(
-            `name: '${column}', length: ${formatNumber(df.length)}, type: ${df.schema.fields.find((c)=> c.name === column).type}, test: ${test}, value: ${value}`,
+        ...counts.map(({ column, test, value }: {column: string; test: 'gt' | 'eq'; value: number | string}) => b.add(
+            `name: '${column}', length: ${formatNumber(df.length)}, type: ${df.schema.fields.find((c)=> c.name === column)!.type}, test: ${test}, value: ${value}`,
             () => {
-                let filteredDf;
+                let filteredDf: Arrow.FilteredDataFrame;
                 if (test == 'gt') {
                     filteredDf = df.filter(col(column).gt(value));
                 } else if (test == 'eq') {
@@ -160,8 +168,8 @@ for (const { name, buffers, countBys, counts } of require('./config')) {
                 }
 
                 return () => {
-                    for (value of filteredDf) {}
-                }
+                    for (const _value of filteredDf) {}
+                };
             }
         )),
 
@@ -171,43 +179,43 @@ for (const { name, buffers, countBys, counts } of require('./config')) {
     b.suite(
         `DataFrame Direct Count "${name}"`,
 
-        ...counts.map(({ column, test, value }) => b.add(
-            `name: '${column}', length: ${formatNumber(df.length)}, type: ${df.schema.fields.find((c)=> c.name === column).type}, test: ${test}, value: ${value}`,
+        ...counts.map(({ column, test, value }: {column: string; test: 'gt' | 'eq'; value: number | string}) => b.add(
+            `name: '${column}', length: ${formatNumber(df.length)}, type: ${df.schema.fields.find((c)=> c.name === column)!.type}, test: ${test}, value: ${value}`,
             () => {
-                let colidx = df.schema.fields.findIndex((c)=> c.name === column);
+                const colidx = df.schema.fields.findIndex((c)=> c.name === column);
 
                 if (test == 'gt') {
                     return () => {
-                        sum = 0;
-                        let batches = df.chunks;
-                        let numBatches = batches.length;
+                        let sum = 0;
+                        const batches = df.chunks;
+                        const numBatches = batches.length;
                         for (let batchIndex = -1; ++batchIndex < numBatches;) {
                             // load batches
                             const batch = batches[batchIndex];
-                            const vector = batch.getChildAt(colidx);
+                            const vector = batch.getChildAt(colidx)!;
                             // yield all indices
                             for (let index = -1, length = batch.length; ++index < length;) {
-                                sum += (vector.get(index) >= value);
+                                sum += (vector.get(index) >= value) ? 1 : 0;
                             }
                         }
                         return sum;
-                    }
+                    };
                 } else if (test == 'eq') {
                     return () => {
-                        sum = 0;
-                        let batches = df.chunks;
-                        let numBatches = batches.length;
+                        let sum = 0;
+                        const batches = df.chunks;
+                        const numBatches = batches.length;
                         for (let batchIndex = -1; ++batchIndex < numBatches;) {
                             // load batches
                             const batch = batches[batchIndex];
-                            const vector = batch.getChildAt(colidx);
+                            const vector = batch.getChildAt(colidx)!;
                             // yield all indices
                             for (let index = -1, length = batch.length; ++index < length;) {
-                                sum += (vector.get(index) === value);
+                                sum += (vector.get(index) === value) ?  1 : 0;
                             }
                         }
                         return sum;
-                    }
+                    };
                 } else {
                     throw new Error(`Unrecognized test "${test}"`);
                 }
@@ -218,7 +226,7 @@ for (const { name, buffers, countBys, counts } of require('./config')) {
 
         b.complete(() => {
             // last benchmark finished
-            json && process.stderr.write(JSON.stringify(results, null, 2))
+            json && process.stderr.write(JSON.stringify(results, null, 2));
         })
     );
 }
diff --git a/js/test/generate-test-data.ts b/js/test/generate-test-data.ts
@@ -580,9 +580,7 @@ type TypedArrayConstructor =
 
 const rand = Math.random.bind(Math);
 const randomBytes = (length: number) => fillRandom(Uint8Array, length);
-const randomString = ((opts) =>
-    (length: number) => randomatic('?', length, opts)
-)({ chars: `abcdefghijklmnopqrstuvwxyz0123456789_` });
+const randomString = (length: number) => randomatic('?', length, { chars: `abcdefghijklmnopqrstuvwxyz0123456789_` });
 
 const memoize = (fn: () => any) => ((x?: any) => () => x || (x = fn()))();
 
diff --git a/js/tsconfig.json b/js/tsconfig.json
@@ -7,7 +7,8 @@
   "compilerOptions": {
     "target": "ESNEXT",
     "module": "commonjs",
-    "noEmit": true
+    "noEmit": true,
+    "esModuleInterop": true
   },
-  "include": ["src/**/*.ts", "test/**/*.ts"]
+  "include": ["src/**/*.ts", "test/**/*.ts", "perf/**/*.ts"]
 }
