Expose optimization info via runtime functions

test/mjsunit/assert-opt-and-deopt.js

+// Copyright 2011 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Flags: --allow-natives-syntax
+
+// This class shows how to use %GetOptimizationCount() and 
+// %IsOptimizedFunction() to infer information about opts and deopts.
+// Might be nice to put this into mjsunit.js, but that doesn't depend on
+// the --allow-natives-syntax flag so far.
+function OptTracker() {
+  this.YES = 1;
+  this.NO = 2;
+  this.ALWAYS = 3;
+  this.NEVER = 4;

[Mike West, 2011/05/04 08:18:03]

Nit: These can be pulled out into a static member of `OptTracker`, and would
probably be best as a separate enum.  See
http://codesearch.google.com/codesearch/p?vert=chromium#OAMlx_jo-ck/src/chrom...
for an example.

[Jakob Kummerow, 2011/05/06 15:58:15]

Done.

+  this.opt_counts_ = new Object();

[Mike West, 2011/05/04 08:18:03]

Nit: Object literals (`{}`) are preferred.

[Jakob Kummerow, 2011/05/06 15:58:15]

Done.

+}
+  
+// Always call this at the beginning of your test, once for each function
+// that you later want to track de/optimizations for. It is necessary because
+// tests are sometimes executed several times in a row, and you want to
+// disregard counts from previous runs.
+OptTracker.prototype.CheckpointOptCount = function(func) {
+  this.opt_counts_[func] = %GetOptimizationCount(func);
+}
+
+OptTracker.prototype.AssertOptCount = function(func, optcount) {
+  if (this.DisableAsserts_(func)) {
+    return;

[Mike West, 2011/05/04 08:18:03]

Nit: If asserts are disabled, you should probably return `true` here; otherwise
you're returning `undefined`, which evaluates to `false`.  `if
(tracker.AssertOptCount(x, y))` would fail...

[Jakob Kummerow, 2011/05/06 15:58:15]

This function doesn't have a return value in any case. It's not supposed to be
used inside if() conditionals. The same is true for all OptTracker.Assert*
functions. 

+  }
+  assertEquals(optcount, this.GetOptCount_(func));
+}
+
+OptTracker.prototype.AssertDeoptCount = function(func, deopt_count) {
+  if (this.DisableAsserts_(func)) {
+    return;
+  }
+  assertEquals(deopt_count, this.GetDeoptCount_(func));
+}
+
+OptTracker.prototype.AssertDeoptHappened = function(func, expect_deopt) {
+  if (this.DisableAsserts_(func)) {
+    return;
+  }
+  if (expect_deopt) {
+    assertTrue(this.GetDeoptCount_(func) > 0);
+    return;
+  }
+  assertEquals(0, this.GetDeoptCount_(func));
+}
+
+OptTracker.prototype.AssertIsOptimized = function(func, expect_optimized) {
+  var raw_optimized = %IsOptimizedFunction(func);
+  if (raw_optimized == this.ALWAYS ||

[Mike West, 2011/05/04 08:18:03]

Nit: Use `DisableAsserts_`.

[Jakob Kummerow, 2011/05/06 15:58:15]

Done.

+      raw_optimized == this.NEVER) {
+    return;
+  }
+  if (expect_optimized) {
+    assertEquals(this.YES, raw_optimized);
+  } else {
+    assertEquals(this.NO, raw_optimized);
+  }
+}
+
+// "private" methods. Do not call these from the outside.
+
+OptTracker.prototype.GetOptCount_ = function(func) {
+  var raw_count = %GetOptimizationCount(func);
+  if (func in this.opt_counts_) {
+    var checkpointed_count = this.opt_counts_[func];
+    return raw_count - checkpointed_count;
+  }
+  return raw_count;
+}
+
+OptTracker.prototype.GetDeoptCount_ = function(func) {
+  var count = this.GetOptCount_(func);
+  if (%IsOptimizedFunction(func) == this.YES) {
+    count -= 1;
+  }
+  return count;
+}
+
+OptTracker.prototype.DisableAsserts_ = function(func) {
+  switch(%IsOptimizedFunction(func)) {
+    case this.YES:
+    case this.NO:
+      return false;
+    case this.ALWAYS:
+    case this.NEVER:
+      return true;
+  }
+  return false;
+}
+
+
+// Example function used by the test below.
+function f(a) {
+  return a+1;
+}
+
+var tracker = new OptTracker();
+tracker.CheckpointOptCount(f);
+
+tracker.AssertOptCount(f, 0);
+tracker.AssertIsOptimized(f, false);
+tracker.AssertDeoptHappened(f, false);
+tracker.AssertDeoptCount(f, 0);
+
+for (var i = 0; i < 5; i++) f(1);
+
+tracker.AssertOptCount(f, 0);
+tracker.AssertIsOptimized(f, false);
+tracker.AssertDeoptHappened(f, false);
+tracker.AssertDeoptCount(f, 0);
+
+%OptimizeFunctionOnNextCall(f);
+f(1);
+
+tracker.AssertOptCount(f, 1);
+tracker.AssertIsOptimized(f, true);
+tracker.AssertDeoptHappened(f, false);
+tracker.AssertDeoptCount(f, 0);
+
+%DeoptimizeFunction(f);
+
+tracker.AssertOptCount(f, 1);
+tracker.AssertIsOptimized(f, false);
+tracker.AssertDeoptHappened(f, true);
+tracker.AssertDeoptCount(f, 1);
+
+for (var i = 0; i < 5; i++) f("a");

[Mike West, 2011/05/04 08:18:03]

Nit: You're intentionally switching from numbers to strings here, and it's
almost certainly clear to V8 developers that the optimizations are
type-specific.  It wasn't clear to me, though... A comment would still be nice.
:)

[Jakob Kummerow, 2011/05/06 15:58:15]

Done.

+%OptimizeFunctionOnNextCall(f);
+f("b");
+
+tracker.AssertOptCount(f, 2);
+tracker.AssertIsOptimized(f, true);
+tracker.AssertDeoptHappened(f, true);
+tracker.AssertDeoptCount(f, 1);