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

   1 // Copyright 2011 the V8 project authors. All rights reserved.
   2 // Redistribution and use in source and binary forms, with or without
   3 // modification, are permitted provided that the following conditions are
   4 // met:
   5 //
   6 //     * Redistributions of source code must retain the above copyright
   7 //       notice, this list of conditions and the following disclaimer.
   8 //     * Redistributions in binary form must reproduce the above
   9 //       copyright notice, this list of conditions and the following
  10 //       disclaimer in the documentation and/or other materials provided
  11 //       with the distribution.
  12 //     * Neither the name of Google Inc. nor the names of its
  13 //       contributors may be used to endorse or promote products derived
  14 //       from this software without specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28 // Flags: --allow-natives-syntax
  29 // Flags: --noconcurrent-recompilation --noconcurrent-osr
  30
  31 if (%IsConcurrentRecompilationSupported()) {
  32   print("Concurrent recompilation is turned on after all. Skipping this test.");
  33   quit();
  34 }
  35
  36 /**
  37  * This class shows how to use %GetOptimizationCount() and
  38  * %GetOptimizationStatus() to infer information about opts and deopts.
  39  * Might be nice to put this into mjsunit.js, but that doesn't depend on
  40  * the --allow-natives-syntax flag so far.
  41  */
  42 function OptTracker() {
  43   this.opt_counts_ = {};
  44 }
  45
  46 /**
  47  * The possible optimization states of a function. Must be in sync with the
  48  * return values of Runtime_GetOptimizationStatus() in runtime.cc!
  49  * @enum {int}
  50  */
  51 OptTracker.OptimizationState = {
  52     YES: 1,
  53     NO: 2,
  54     ALWAYS: 3,
  55     NEVER: 4
  56 };
  57
  58 /**
  59  * Always call this at the beginning of your test, once for each function
  60  * that you later want to track de/optimizations for. It is necessary because
  61  * tests are sometimes executed several times in a row, and you want to
  62  * disregard counts from previous runs.
  63  */
  64 OptTracker.prototype.CheckpointOptCount = function(func) {
  65   this.opt_counts_[func] = %GetOptimizationCount(func);
  66 };
  67
  68 OptTracker.prototype.AssertOptCount = function(func, optcount) {
  69   if (this.DisableAsserts_(func)) {
  70     return;
  71   }
  72   assertEquals(optcount, this.GetOptCount_(func));
  73 };
  74
  75 OptTracker.prototype.AssertDeoptCount = function(func, deopt_count) {
  76   if (this.DisableAsserts_(func)) {
  77     return;
  78   }
  79   assertEquals(deopt_count, this.GetDeoptCount_(func));
  80 };
  81
  82 OptTracker.prototype.AssertDeoptHappened = function(func, expect_deopt) {
  83   if (this.DisableAsserts_(func)) {
  84     return;
  85   }
  86   if (expect_deopt) {
  87     assertTrue(this.GetDeoptCount_(func) > 0);
  88   } else {
  89     assertEquals(0, this.GetDeoptCount_(func));
  90   }
  91 }
  92
  93 OptTracker.prototype.AssertIsOptimized = function(func, expect_optimized) {
  94   if (this.DisableAsserts_(func)) {
  95     return;
  96   }
  97   var raw_optimized = %GetOptimizationStatus(func);
  98   if (expect_optimized) {
  99     assertEquals(OptTracker.OptimizationState.YES, raw_optimized);
 100   } else {
 101     assertEquals(OptTracker.OptimizationState.NO, raw_optimized);
 102   }
 103 }
 104
 105 /**
 106  * @private
 107  */
 108 OptTracker.prototype.GetOptCount_ = function(func) {
 109   var raw_count = %GetOptimizationCount(func);
 110   if (func in this.opt_counts_) {
 111     var checkpointed_count = this.opt_counts_[func];
 112     return raw_count - checkpointed_count;
 113   }
 114   return raw_count;
 115 }
 116
 117 /**
 118  * @private
 119  */
 120 OptTracker.prototype.GetDeoptCount_ = function(func) {
 121   var count = this.GetOptCount_(func);
 122   if (%GetOptimizationStatus(func) == OptTracker.OptimizationState.YES) {
 123     count -= 1;
 124   }
 125   return count;
 126 }
 127
 128 /**
 129  * @private
 130  */
 131 OptTracker.prototype.DisableAsserts_ = function(func) {
 132   switch(%GetOptimizationStatus(func)) {
 133     case OptTracker.OptimizationState.YES:
 134     case OptTracker.OptimizationState.NO:
 135       return false;
 136     case OptTracker.OptimizationState.ALWAYS:
 137     case OptTracker.OptimizationState.NEVER:
 138       return true;
 139   }
 140   return true;
 141 }
 142 // (End of class OptTracker.)
 143
 144 // Example function used by the test below.
 145 function f(a) {
 146   return a+1;
 147 }
 148
 149 var tracker = new OptTracker();
 150 tracker.CheckpointOptCount(f);
 151
 152 tracker.AssertOptCount(f, 0);
 153 tracker.AssertIsOptimized(f, false);
 154 tracker.AssertDeoptHappened(f, false);
 155 tracker.AssertDeoptCount(f, 0);
 156
 157 f(1);
 158
 159 %OptimizeFunctionOnNextCall(f);
 160 f(1);
 161
 162 tracker.AssertOptCount(f, 1);
 163 tracker.AssertIsOptimized(f, true);
 164 tracker.AssertDeoptHappened(f, false);
 165 tracker.AssertDeoptCount(f, 0);
 166
 167 %DeoptimizeFunction(f);
 168
 169 tracker.AssertOptCount(f, 1);
 170 tracker.AssertIsOptimized(f, false);
 171 tracker.AssertDeoptHappened(f, true);
 172 tracker.AssertDeoptCount(f, 1);
 173
 174 // Let's trigger optimization for another type.
 175 for (var i = 0; i < 5; i++) f("a");
 176
 177 %OptimizeFunctionOnNextCall(f);
 178 f("b");
 179
 180 tracker.AssertOptCount(f, 2);
 181 tracker.AssertIsOptimized(f, true);
 182 tracker.AssertDeoptHappened(f, true);
 183 tracker.AssertDeoptCount(f, 1);