Add more IDB perf tests, including cursor reads and log-style writes.

chrome/test/data/indexeddb/perf_shared.js

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 window.indexedDB = window.indexedDB || window.webkitIndexedDB ||
     window.mozIndexedDB || window.msIndexedDB;
 
 var automation = {
   results: {}
 };
@@ skipping 41 matching lines @@
 var baseVersion = 2;  // The version with our object stores.
 var curVersion;
 
 // Valid options fields:
 //  indexName: the name of an index to create on each object store
 //  indexKeyPath: the key path for that index
 //  indexIsUnique: the "unique" option for IDBIndexParameters
 //  indexIsMultiEntry: the "multiEntry" option for IDBIndexParameters
 //
 function createDatabase(
-    name, objectStoreNames, handler, errorHandler, options) {
+    name, objectStoreNames, handler, errorHandler, optionSets) {
   var openRequest = indexedDB.open(name, baseVersion);
   openRequest.onblocked = errorHandler;
   function createObjectStores(db) {
     for (var store in objectStoreNames) {
       var name = objectStoreNames[store];
       assert(!db.objectStoreNames.contains(name));
       var os = db.createObjectStore(name);
-      if (options && options.indexName) {
-        assert('indexKeyPath' in options);
-        os.createIndex(options.indexName, options.indexKeyPath,
-            { unique: options.indexIsUnique,
-              multiEntry: options.indexIsMultiEntry });
+      if (optionSets) {
+        for (o in optionSets) {
+          var options = optionSets[o];
+          assert(options.indexName);
+          assert('indexKeyPath' in options);
+          os.createIndex(options.indexName, options.indexKeyPath,
+              { unique: options.indexIsUnique,
+                multiEntry: options.indexIsMultiEntry });
+        }
       }
     }
   }
   openRequest.onupgradeneeded = function(ev) {
-    // TODO: This is the spec-compliant path, which doesn't yet work in Chrome,
-    // and isn't yet tested, as this function won't currently be called.
+    // TODO(ericu): This is the spec-compliant path, which doesn't yet work in
+    // Chrome, and isn't yet tested, as this function won't currently be called.
     assert(openRequest == ev.target);
     createObjectStores(openRequest.result);
     // onsuccess will get called after this exits.
   };
   openRequest.onsuccess = function(ev) {
     assert(openRequest == ev.target);
     var db = openRequest.result;
     db.onerror = function(ev) {
       console.log("db error", arguments, openRequest.webkitErrorMessage);
       errorHandler();
@@ skipping 15 matching lines @@
     }
   }
 }
 
 // You must close all database connections before calling this.
 function alterObjectStores(
     name, objectStoreNames, func, handler, errorHandler) {
   var version = curVersion + 1;
   var openRequest = indexedDB.open(name, version);
   openRequest.onblocked = errorHandler;
-  // TODO: This won't work in Firefox yet; see above in createDatabase.
+  // TODO(ericu): This won't work in Firefox yet; see above in createDatabase.
   openRequest.onsuccess = function(ev) {
     assert(openRequest == ev.target);
     var db = openRequest.result;
     db.onerror = function(ev) {
       console.log("error altering db", arguments,
           openRequest.webkitErrorMessage);
       errorHandler();
     }
     if (db.version != version) {
       var setVersionRequest = db.setVersion(version);
@@ skipping 36 matching lines @@
 function getCompletionFunc(testName, startTime, onTestComplete) {
   function onDeleted() {
     automation.setStatus("Deleted database.");
     onTestComplete();
   }
   return function() {
     var duration = Date.now() - startTime;
     // Ignore the cleanup time for this test.
     automation.addResult(testName, duration);
     automation.setStatus("Deleting database.");
-    // TODO: Turn on actual deletion; for now it's way too slow.
+    // TODO(ericu): Turn on actual deletion; for now it's way too slow.
     // deleteDatabase(testName, onDeleted);
     onTestComplete();
   }
 }
 
 function getDisplayName(args) {
   // The last arg is the completion callback the test runner tacks on.
+  // TODO(ericu): Make test errors delete the database automatically.
   return getDisplayName.caller.name + "_" +
       Array.prototype.slice.call(args, 0, args.length - 1).join("_");
 }
 
+// Pad a string [or object convertible to a string] to a fixed width; use this
+// to have numeric strings sort properly.
+function padToWidth(s, width) {
+  s = "" + s;

[jsbell, 2012/07/27 00:25:46]

Although it should get optimized to the same thing, String(s) (NOTE: no "new"
operator) may be more readable.

[ericu, 2012/07/31 01:00:53]

Done.

+  assert(s.length <= width);
+  while (s.length < width) {

[jsbell, 2012/07/27 00:25:46]

Alternately: (Array(width + 1).join("0") + s).substr(-width)

[ericu, 2012/07/31 01:00:53]

I find that shorter, but a bit harder to read, so I'd prefer to leave this
as-is.

+    s = "0" + s;
+  }
+  return s;
+}
+
 function getSimpleKey(i) {
-  return "key " + i;
+  return "key " + padToWidth(i, 10);
 }
 
 function getSimpleValue(i) {
-  return "value " + i;
+  return "value " + padToWidth(i, 10);
+}
+
+function getForwardIndexKey(i) {
+  return i;
+}
+
+function getBackwardIndexKey(i) {
+  return -i;
+}
+
+// This is useful for indexing by keypath; the two names should be ordered in
+// opposite directions for all i in uint32 range.
+function getObjectValue(i) {
+  return {
+    firstName: getForwardIndexKey(i),
+    lastName: getBackwardIndexKey(i)
+  };
+}
+
+function getNFieldObjectValue(i, n) {
+  assert(Math.floor(n) == n);
+  assert(n > 0);
+  var o = {};
+  for (; n > 0; --n) {
+    // The value varies per field, each object will tend to be unique,
+    // and thanks to the modulus, indexing on different fields will give you
+    // different ordering for large-enough data sets.
+    o["field" + (n - 1)] = Math.pow(i + 0.5, n + 0.5) % 65536;
+  }
+  return o;
 }
 
 function putLinearValues(
     transaction, objectStoreNames, numKeys, getKey, getValue) {
   if (!getKey)
     getKey = getSimpleKey;
   if (!getValue)
     getValue = getSimpleValue;
   for (var i in objectStoreNames) {
     var os = transaction.objectStore(objectStoreNames[i]);
@@ skipping 30 matching lines @@
   for (var i in objectStoreNames) {
     var os = transaction.objectStore(objectStoreNames[i]);
     for (var j = 0; j < numPuts; ++j) {
       var rand = Math.floor(Math.random() * numKeys);
       var request = os.put(getValue(rand), getKey(rand));
       request.onerror = onError;
     }
   }
 }
 
+// getKey should be deterministic, as we assume that a cursor that starts at
+// getKey(X) and runs through getKey(X + K) has exactly K values available.
+// This is annoying to guarantee generally when using an index, so we avoid both
+// ends of the key space just in case and use simple indices.
+// TODO(ericu): Figure out if this can be simplified and we can remove uses of
+// getObjectValue in favor of getNFieldObjectValue.
+function getValuesFromCursor(
+    transaction, inputObjectStoreName, numReads, numKeys, indexName, getKey,
+    readKeysOnly, outputObjectStoreName) {
+  assert(2 * numReads < numKeys);
+  if (!getKey)
+    getKey = getSimpleKey;
+  var rand = Math.floor(Math.random() * (numKeys - 2 * numReads)) + numReads;
+  var values = [];
+  var queryObject = transaction.objectStore(inputObjectStoreName);
+  assert(queryObject);
+  if (indexName)
+    queryObject = queryObject.index(indexName);
+  var keyRange = webkitIDBKeyRange.bound(

[jsbell, 2012/07/27 00:25:46]

Should add at the top of the file:
window.IDBKeyRange = window.IDBKeyRange || window.webkitIDBKeyRange;
(Note that ONLY webkit prefixes this; other browsers didn't bother.)

[ericu, 2012/07/31 01:00:53]

Done.

+      getKey(rand), getKey(rand + numReads), false, true);
+  var request;
+  if (readKeysOnly) {
+    request = queryObject.openKeyCursor(keyRange);
+  } else {
+    request = queryObject.openCursor(keyRange);
+  }
+  var oos;
+  if (outputObjectStoreName)
+    oos = transaction.objectStore(outputObjectStoreName);
+  var numReadsLeft = numReads;
+  request.onsuccess = function(event) {
+    var cursor = event.target.result;
+    if (cursor) {
+      assert(numReadsLeft);
+      --numReadsLeft;
+      if (oos) // Put in random order for maximum difficulty.
+        oos.put(cursor.value, Math.random());
+      values.push({key: cursor.key, value: cursor.value});

[jsbell, 2012/07/27 00:25:46]

Although the input/output stores here differ, having a cursor perf test that
does write to the same store that is being read from is a good idea. In the
current impl, writing to a store invalidates a per-cursor "prefetch" cache.

Huh, looking at the code, it looks like we reset ALL cursors, regardless of
store. And in many cases where we don't need to. So... um... yeah, this is a
good test. :)

[ericu, 2012/07/31 01:00:53]

Added a TODO to add a test that writes back to the same store.

+      cursor.continue();
+    } else {
+      assert(!numReadsLeft);
+    }
+  }
+  request.onerror = onError;
+}
+
+
 function stringOfLength(n) {
   assert(n > 0);
   assert(n == Math.floor(n));
   return new Array(n + 1).join('0');
 }