clean up table benchmarks

Author: Brian Hulette

js/package.json

@@ -12,6 +12,7 @@
  "clean": "gulp clean",
  "debug": "gulp debug",
  "perf": "node ./perf/index.js",
+ "create:perfdata": "python ./test/data/tables/generate.py ./test/data/tables/tracks.arrow",
  "release": "./npm-release.sh",
  "clean:all": "run-p clean clean:testdata",
  "clean:testdata": "gulp clean:testdata",

js/perf/index.js

@@ -16,54 +16,42 @@
 // under the License.
 
 // Use the ES5 UMD target as perf baseline
-// const { lit, col, DataFrame, Table, readVectors } = require('../targets/es5/umd');
-// const { lit, col, DataFrame, Table, readVectors } = require('../targets/es5/cjs');
-// const { lit, col, DataFrame, Table, readVectors } = require('../targets/es2015/umd');
-const { lit, col, DataFrame, Table, readVectors } = require('../targets/es2015/cjs');
+const { col, DataFrame, Table, readVectors } = require('../targets/es5/umd');
+// const { col, DataFrame, Table, readVectors } = require('../targets/es5/cjs');
+// const { col, DataFrame, Table, readVectors } = require('../targets/es2015/umd');
+// const { col, DataFrame, Table, readVectors } = require('../targets/es2015/cjs');
 
 const config = require('./config');
 const Benchmark = require('benchmark');
 
 const suites = [];
 
-//for (let { name, buffers} of config) {
-// const parseSuite = new Benchmark.Suite(`Parse "${name}"`, { async: true });
-// const sliceSuite = new Benchmark.Suite(`Slice "${name}" vectors`, { async: true });
-// const iterateSuite = new Benchmark.Suite(`Iterate "${name}" vectors`, { async: true });
-// const getByIndexSuite = new Benchmark.Suite(`Get "${name}" values by index`, { async: true });
-// parseSuite.add(createFromTableTest(name, buffers));
-// parseSuite.add(createReadVectorsTest(name, buffers));
-// for (const vector of Table.from(buffers).columns) {
-// sliceSuite.add(createSliceTest(vector));
-// iterateSuite.add(createIterateTest(vector));
-// getByIndexSuite.add(createGetByIndexTest(vector));
-// }
-// suites.push(getByIndexSuite, iterateSuite, sliceSuite, parseSuite);
-//}
+for (let { name, buffers} of config) {
+ const parseSuite = new Benchmark.Suite(`Parse "${name}"`, { async: true });
+ const sliceSuite = new Benchmark.Suite(`Slice "${name}" vectors`, { async: true });
+ const iterateSuite = new Benchmark.Suite(`Iterate "${name}" vectors`, { async: true });
+ const getByIndexSuite = new Benchmark.Suite(`Get "${name}" values by index`, { async: true });
+ parseSuite.add(createFromTableTest(name, buffers));
+ parseSuite.add(createReadVectorsTest(name, buffers));
+ for (const vector of Table.from(buffers).columns) {
+ sliceSuite.add(createSliceTest(vector));
+ iterateSuite.add(createIterateTest(vector));
+ getByIndexSuite.add(createGetByIndexTest(vector));
+ }
+ suites.push(getByIndexSuite, iterateSuite, sliceSuite, parseSuite);
+}
 
 for (let {name, buffers, tests} of require('./table_config')) {
- const tableIteratorSuite = new Benchmark.Suite(`Table Iterator "${name}"`, { async: true });
- const tableCountSuite = new Benchmark.Suite(`Table Count "${name}"`, { async: true });
- const dfIteratorSuite = new Benchmark.Suite(`DataFrame Iterator "${name}"`, { async: true });
- const dfIteratorCountSuite = new Benchmark.Suite(`DataFrame Iterator Count "${name}"`, { async: true });
+ const dfFilterCountSuite = new Benchmark.Suite(`DataFrame Filter-Scan Count "${name}"`, { async: true });
  const dfDirectCountSuite = new Benchmark.Suite(`DataFrame Direct Count "${name}"`, { async: true });
- const dfScanCountSuite = new Benchmark.Suite(`DataFrame Scan Count "${name}"`, { async: true });
- const dfFilterCountSuite = new Benchmark.Suite(`DataFrame Filter Scan Count "${name}"`, { async: true });
- const vectorCountSuite = new Benchmark.Suite(`Vector Count "${name}"`, { async: true });
  const table = Table.from(buffers);
 
- tableIteratorSuite.add(createTableIteratorTest(table));
- dfIteratorSuite.add(createDataFrameIteratorTest(table));
  for (test of tests) {
- tableCountSuite.add(createTableCountTest(table, test.col, test.test, test.value))
- dfIteratorCountSuite.add(createDataFrameIteratorCountTest(table, test.col, test.test, test.value))
- dfDirectCountSuite.add(createDataFrameDirectCountTest(table, test.col, test.test, test.value))
- dfScanCountSuite.add(createDataFrameScanCountTest(table, test.col, test.test, test.value))
  dfFilterCountSuite.add(createDataFrameFilterCountTest(table, test.col, test.test, test.value))
- vectorCountSuite.add(createVectorCountTest(table.columns[test.col], test.test, test.value))
+ dfDirectCountSuite.add(createDataFrameDirectCountTest(table, test.col, test.test, test.value))
  }
 
- suites.push(tableIteratorSuite, tableCountSuite, dfIteratorSuite, dfIteratorCountSuite, dfDirectCountSuite, dfScanCountSuite, dfFilterCountSuite, vectorCountSuite)
+ suites.push(dfFilterCountSuite, dfDirectCountSuite)
 }
 
 console.log('Running apache-arrow performance tests...\n');
@@ -135,81 +123,9 @@ function createGetByIndexTest(vector) {
  };
 }
 
-function createVectorCountTest(vector, test, value) {
- let op;
- if (test == 'gteq') {
- op = function () {
- sum = 0;
- for (cell of vector) {
- sum += (cell >= value)
- }
- }
- } else if (test == 'eq') {
- op = function () {
- sum = 0;
- for (cell of vector) {
- sum += (cell == value)
- }
- }
- } else {
- throw new Error(`Unrecognized test "$test"`);
- }
-
- return {
- async: true,
- name: `name: '${vector.name}', length: ${vector.length}, type: ${vector.type}, test: ${test}, value: ${value}`,
- fn: op
- };
-}
-
-function createTableIteratorTest(table) {
- let row;
- return {
- async: true,
- name: `length: ${table.length}`,
- fn() { for (row of table) {} }
- };
-}
-
-function createTableCountTest(table, column, test, value) {
- let op;
- if (test == 'gteq') {
- op = function () {
- sum = 0;
- for (row of table) {
- sum += (row.get(column) >= value)
- }
- }
- } else if (test == 'eq') {
- op = function() {
- sum = 0;
- for (row of table) {
- sum += (row.get(column) == value)
- }
- }
- } else {
- throw new Error(`Unrecognized test "${test}"`);
- }
-
- return {
- async: true,
- name: `name: '${table.columns[column].name}', length: ${table.length}, type: ${table.columns[column].type}, test: ${test}, value: ${value}`,
- fn: op
- };
-}
-
-function createDataFrameIteratorTest(table) {
- let df = DataFrame.from(table);
- let idx;
- return {
- async: true,
- name: `length: ${table.length}`,
- fn() { for (idx of table) {} }
- };
-}
-
 function createDataFrameDirectCountTest(table, column, test, value) {
  let df = DataFrame.from(table);
+ let colidx = table.columns.findIndex((c)=>c.name === column);
 
  if (test == 'gteq') {
  op = function () {
@@ -218,11 +134,11 @@ function createDataFrameDirectCountTest(table, column, test, value) {
  const length = df.lengths[batch];
 
  // load batches
- const columns = df.getBatch(batch);
+ const columns = df.batches[batch];
 
  // yield all indices
  for (let idx = -1; ++idx < length;) {
- sum += (columns[column].get(idx) >= value);
+ sum += (columns[colidx].get(idx) >= value);
  }
  }
  }
@@ -233,11 +149,11 @@ function createDataFrameDirectCountTest(table, column, test, value) {
  const length = df.lengths[batch];
 
  // load batches
- const columns = df.getBatch(batch);
+ const columns = df.batches[batch]
 
  // yield all indices
  for (let idx = -1; ++idx < length;) {
- sum += (columns[column].get(idx) == value);
+ sum += (columns[colidx].get(idx) == value);
  }
  }
  }
@@ -247,79 +163,28 @@ function createDataFrameDirectCountTest(table, column, test, value) {
 
  return {
  async: true,
- name: `name: '${table.columns[column].name}', length: ${table.length}, type: ${table.columns[column].type}, test: ${test}, value: ${value}`,
- fn: op
- };
-}
-
-function createDataFrameScanCountTest(table, column, test, value) {
- let df = DataFrame.from(table);
-
- if (test == 'gteq') {
- op = function () {
- sum = 0;
- df.scan((idx, cols)=>{sum += cols[column].get(idx) >= value});
- }
- } else if (test == 'eq') {
- op = function() {
- sum = 0;
- df.scan((idx, cols)=>{sum += cols[column].get(idx) == value});
- console.log(sum);
- }
- } else {
- throw new Error(`Unrecognized test "${test}"`);
- }
-
- return {
- async: true,
- name: `name: '${table.columns[column].name}', length: ${table.length}, type: ${table.columns[column].type}, test: ${test}, value: ${value}`,
+ name: `name: '${column}', length: ${table.length}, type: ${table.columns[colidx].type}, test: ${test}, value: ${value}`,
  fn: op
  };
 }
 
 function createDataFrameFilterCountTest(table, column, test, value) {
  let df = DataFrame.from(table);
+ let colidx = table.columns.findIndex((c)=>c.name === column);
+
  if (test == 'gteq') {
- df = df.filter(col(table.columns[column].name).gteq(value));
+ df = df.filter(col(column).gteq(value));
  } else if (test == 'eq') {
- df = df.filter(col(table.columns[column].name).eq(value));
+ df = df.filter(col(column).eq(value));
  } else {
  throw new Error(`Unrecognized test "${test}"`);
  }
 
  return {
  async: true,
- name: `name: '${table.columns[column].name}', length: ${table.length}, type: ${table.columns[column].type}, test: ${test}, value: ${value}`,
+ name: `name: '${column}', length: ${table.length}, type: ${table.columns[colidx].type}, test: ${test}, value: ${value}`,
  fn() {
  df.count();
  }
  };
 }
-
-function createDataFrameIteratorCountTest(table, column, test, value) {
- let df = DataFrame.from(table);
-
- if (test == 'gteq') {
- op = function () {
- sum = 0;
- for (idx of df) {
- sum += (df.columns[column].get(idx) >= value);
- }
- }
- } else if (test == 'eq') {
- op = function() {
- sum = 0;
- for (idx of df) {
- sum += (df.columns[column].get(idx) == value);
- }
- }
- } else {
- throw new Error(`Unrecognized test "${test}"`);
- }
-
- return {
- async: true,
- name: `name: '${table.columns[column].name}', length: ${table.length}, type: ${table.columns[column].type}, test: ${test}, value: ${value}`,
- fn: op
- };
-}

js/perf/table_config.js

@@ -22,15 +22,23 @@ const glob = require('glob');
 const config = [];
 const filenames = glob.sync(path.resolve(__dirname, `../test/data/tables/`, `*.arrow`));
 
-tests = [
- {col: 0, test: 'gteq', value: 0 },
- {col: 1, test: 'gteq', value: 0 },
- {col: 2, test: 'eq', value: 'Seattle'},
-]
+tests = {
+ "tracks": [
+ {col: 'lat', test: 'gteq', value: 0 },
+ {col: 'lng', test: 'gteq', value: 0 },
+ {col: 'origin', test: 'eq', value: 'Seattle'},
+ ]
+}
 
 for (const filename of filenames) {
  const { name } = path.parse(filename);
- config.push({ name, buffers: [fs.readFileSync(filename)], tests });
+ if (name in tests) {
+ config.push({
+ name,
+ buffers: [fs.readFileSync(filename)],
+ tests: tests[name]
+ });
+ }
 }
 
 module.exports = config;

js/src/Arrow.externs.ts

@@ -82,3 +82,19 @@ let DictionaryVector = function() {};
 DictionaryVector.prototype.getKey;
 /** @type {?} */
 DictionaryVector.prototype.getValue;
+
+let DataFrame = function () {};
+/** @type {?} */
+DataFrame.prototype.lengths;
+/** @type {?} */
+DataFrame.prototype.columns;
+/** @type {?} */
+DataFrame.prototype.batches;
+
+let Col = function() {};
+/** @type {?} */
+Col.prototype.gteq;
+/** @type {?} */
+Col.prototype.lteq;
+/** @type {?} */
+Col.prototype.eq;