js/src/jit/IonOptimizationLevels.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: set ts=8 sts=2 et sw=2 tw=80:
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "jit/IonOptimizationLevels.h"
   8
   9 #include "jit/Ion.h"
  10 #include "vm/JSScript.h"
  11
  12 #include "vm/JSScript-inl.h"
  13
  14 using namespace js;
  15 using namespace js::jit;
  16
  17 namespace js {
  18 namespace jit {
  19
  20 const OptimizationLevelInfo IonOptimizations;
  21
  22 void OptimizationInfo::initNormalOptimizationInfo() {
  23   level_ = OptimizationLevel::Normal;
  24
  25   autoTruncate_ = true;
  26   eaa_ = true;
  27   edgeCaseAnalysis_ = true;
  28   eliminateRedundantChecks_ = true;
  29   eliminateRedundantShapeGuards_ = true;
  30   eliminateRedundantGCBarriers_ = true;
  31   inlineInterpreted_ = true;
  32   inlineNative_ = true;
  33   licm_ = true;
  34   gvn_ = true;
  35   rangeAnalysis_ = true;
  36   reordering_ = true;
  37   scalarReplacement_ = true;
  38   sink_ = true;
  39
  40   registerAllocator_ = RegisterAllocator_Backtracking;
  41 }
  42
  43 void OptimizationInfo::initWasmOptimizationInfo() {
  44   // The Wasm optimization level
  45   // Disables some passes that don't work well with wasm.
  46
  47   // Take normal option values for not specified values.
  48   initNormalOptimizationInfo();
  49
  50   level_ = OptimizationLevel::Wasm;
  51
  52   ama_ = true;
  53   autoTruncate_ = false;
  54   edgeCaseAnalysis_ = false;
  55   eliminateRedundantChecks_ = false;
  56   eliminateRedundantShapeGuards_ = false;
  57   eliminateRedundantGCBarriers_ = false;
  58   scalarReplacement_ = false;  // wasm has no objects.
  59   sink_ = false;
  60 }
  61
  62 uint32_t OptimizationInfo::compilerWarmUpThreshold(JSScript* script,
  63                                                    jsbytecode* pc) const {
  64   MOZ_ASSERT(pc == nullptr || pc == script->code() ||
  65              JSOp(*pc) == JSOp::LoopHead);
  66
  67   // The script must not start with a LoopHead op or the code below would be
  68   // wrong. See bug 1602681.
  69   MOZ_ASSERT_IF(pc && JSOp(*pc) == JSOp::LoopHead, pc > script->code());
  70
  71   if (pc == script->code()) {
  72     pc = nullptr;
  73   }
  74
  75   uint32_t warmUpThreshold = baseCompilerWarmUpThreshold();
  76
  77   // If the script is too large to compile on the main thread, we can still
  78   // compile it off thread. In these cases, increase the warm-up counter
  79   // threshold to improve the compilation's type information and hopefully
  80   // avoid later recompilation.
  81
  82   if (script->length() > JitOptions.ionMaxScriptSizeMainThread) {
  83     warmUpThreshold *=
  84         (script->length() / double(JitOptions.ionMaxScriptSizeMainThread));
  85   }
  86
  87   uint32_t numLocalsAndArgs = NumLocalsAndArgs(script);
  88   if (numLocalsAndArgs > JitOptions.ionMaxLocalsAndArgsMainThread) {
  89     warmUpThreshold *=
  90         (numLocalsAndArgs / double(JitOptions.ionMaxLocalsAndArgsMainThread));
  91   }
  92
  93   if (!pc || JitOptions.eagerIonCompilation()) {
  94     return warmUpThreshold;
  95   }
  96
  97   // It's more efficient to enter outer loops, rather than inner loops, via OSR.
  98   // To accomplish this, we use a slightly higher threshold for inner loops.
  99   // Note that the loop depth is always > 0 so we will prefer non-OSR over OSR.
 100   uint32_t loopDepth = LoopHeadDepthHint(pc);
 101   MOZ_ASSERT(loopDepth > 0);
 102   return warmUpThreshold + loopDepth * (baseCompilerWarmUpThreshold() / 10);
 103 }
 104
 105 uint32_t OptimizationInfo::recompileWarmUpThreshold(JSScript* script,
 106                                                     jsbytecode* pc) const {
 107   MOZ_ASSERT(pc == script->code() || JSOp(*pc) == JSOp::LoopHead);
 108
 109   uint32_t threshold = compilerWarmUpThreshold(script, pc);
 110   if (JSOp(*pc) != JSOp::LoopHead || JitOptions.eagerIonCompilation()) {
 111     return threshold;
 112   }
 113
 114   // If we're stuck in a long-running loop at a low optimization level, we have
 115   // to invalidate to be able to tier up. This is worse than recompiling at
 116   // function entry (because in that case we can use the lazy link mechanism and
 117   // avoid invalidation completely). Use a very high recompilation threshold for
 118   // loop edges so that this only affects very long-running loops.
 119
 120   uint32_t loopDepth = LoopHeadDepthHint(pc);
 121   MOZ_ASSERT(loopDepth > 0);
 122   return threshold + loopDepth * (baseCompilerWarmUpThreshold() / 10);
 123 }
 124
 125 OptimizationLevelInfo::OptimizationLevelInfo() {
 126   infos_[OptimizationLevel::Normal].initNormalOptimizationInfo();
 127   infos_[OptimizationLevel::Wasm].initWasmOptimizationInfo();
 128 }
 129
 130 OptimizationLevel OptimizationLevelInfo::levelForScript(JSScript* script,
 131                                                         jsbytecode* pc) const {
 132   const OptimizationInfo* info = get(OptimizationLevel::Normal);
 133   if (script->getWarmUpCount() < info->compilerWarmUpThreshold(script, pc)) {
 134     return OptimizationLevel::DontCompile;
 135   }
 136
 137   return OptimizationLevel::Normal;
 138 }
 139
 140 }  // namespace jit
 141 }  // namespace js