From eda7ad2285aa86bb8b182bd745c847c473b2ee29 Mon Sep 17 00:00:00 2001 From: "Carsten \"Tomcat\" Book" Date: Tue, 3 Feb 2015 17:06:27 +0100 Subject: [PATCH] Backed out changeset 8b393c8dae2b (bug 1127908) for rootanalysis build test failures on a CLOSED TREE --- js/src/jit/IonOptimizationLevels.cpp | 6 +-- js/src/jit/IonOptimizationLevels.h | 13 +++--- js/src/jit/JitOptions.cpp | 59 +++++++++------------------- js/src/jit/JitOptions.h | 18 ++------- js/src/jsapi.cpp | 4 +- js/src/shell/js.cpp | 13 +++++- 6 files changed, 42 insertions(+), 71 deletions(-) diff --git a/js/src/jit/IonOptimizationLevels.cpp b/js/src/jit/IonOptimizationLevels.cpp index 0f2c2038eb82..6d520988c985 100644 --- a/js/src/jit/IonOptimizationLevels.cpp +++ b/js/src/jit/IonOptimizationLevels.cpp @@ -41,7 +41,7 @@ OptimizationInfo::initNormalOptimizationInfo() maxInlineDepth_ = 3; scalarReplacement_ = true; smallFunctionMaxInlineDepth_ = 10; - compilerWarmUpThreshold_ = CompilerWarmupThreshold; + compilerWarmUpThreshold_ = 1000; inliningWarmUpThresholdFactor_ = 0.125; inliningRecompileThresholdFactor_ = 4; } @@ -73,8 +73,8 @@ OptimizationInfo::compilerWarmUpThreshold(JSScript *script, jsbytecode *pc) cons pc = nullptr; uint32_t warmUpThreshold = compilerWarmUpThreshold_; - if (js_JitOptions.forcedDefaultIonWarmUpThreshold.isSome()) - warmUpThreshold = js_JitOptions.forcedDefaultIonWarmUpThreshold.ref(); + if (js_JitOptions.forceDefaultIonWarmUpThreshold) + warmUpThreshold = js_JitOptions.forcedDefaultIonWarmUpThreshold; // If the script is too large to compile on the main thread, we can still // compile it off thread. In these cases, increase the warm-up counter diff --git a/js/src/jit/IonOptimizationLevels.h b/js/src/jit/IonOptimizationLevels.h index 3ebeccd365a9..46a4d38d607d 100644 --- a/js/src/jit/IonOptimizationLevels.h +++ b/js/src/jit/IonOptimizationLevels.h @@ -107,9 +107,6 @@ class OptimizationInfo // are compiled. uint32_t compilerWarmUpThreshold_; - // Default compiler warmup threshold, unless it is overridden. - static const uint32_t CompilerWarmupThreshold = 1000; - // How many invocations or loop iterations are needed before calls // are inlined, as a fraction of compilerWarmUpThreshold. double inliningWarmUpThresholdFactor_; @@ -176,9 +173,9 @@ class OptimizationInfo } IonRegisterAllocator registerAllocator() const { - if (js_JitOptions.forcedRegisterAllocator.isSome()) - return js_JitOptions.forcedRegisterAllocator.ref(); - return registerAllocator_; + if (!js_JitOptions.forceRegisterAllocator) + return registerAllocator_; + return js_JitOptions.forcedRegisterAllocator; } bool scalarReplacementEnabled() const { @@ -205,8 +202,8 @@ class OptimizationInfo uint32_t inliningWarmUpThreshold() const { uint32_t compilerWarmUpThreshold = compilerWarmUpThreshold_; - if (js_JitOptions.forcedDefaultIonWarmUpThreshold.isSome()) - compilerWarmUpThreshold = js_JitOptions.forcedDefaultIonWarmUpThreshold.ref(); + if (js_JitOptions.forceDefaultIonWarmUpThreshold) + compilerWarmUpThreshold = js_JitOptions.forcedDefaultIonWarmUpThreshold; return compilerWarmUpThreshold * inliningWarmUpThresholdFactor_; } diff --git a/js/src/jit/JitOptions.cpp b/js/src/jit/JitOptions.cpp index 8d28f628ded4..c3edb075ea8b 100644 --- a/js/src/jit/JitOptions.cpp +++ b/js/src/jit/JitOptions.cpp @@ -12,31 +12,14 @@ using namespace js; using namespace js::jit; -using mozilla::Maybe; - namespace js { namespace jit { JitOptions js_JitOptions; -static void Warn(const char *env, const char *value) -{ - fprintf(stderr, "Warning: I didn't understand %s=\"%s\"\n", env, value); -} - template struct IsBool : mozilla::FalseType {}; template<> struct IsBool : mozilla::TrueType {}; -static Maybe -ParseInt(const char *str) -{ - char *endp; - int retval = strtol(str, &endp, 0); - if (*endp == '\0') - return mozilla::Some(retval); - return mozilla::Nothing(); -} - template T overrideDefault(const char *param, T dflt) { char *str = getenv(param); @@ -51,12 +34,14 @@ T overrideDefault(const char *param, T dflt) { strcmp(str, "no")) { return false; } - Warn(param, str); + fprintf(stderr, "Warning: I didn't understand %s=\"%s\"", param, str); } else { - Maybe value = ParseInt(str); - if (value.isSome()) - return value.ref(); - Warn(param, str); + char *endp; + int retval = strtol(str, &endp, 0); + if (*endp == '\0') + return retval; + + fprintf(stderr, "Warning: I didn't understand %s=\"%s\"", param, str); } return dflt; } @@ -111,23 +96,13 @@ JitOptions::JitOptions() // Force how many invocation or loop iterations are needed before compiling // a function with the highest ionmonkey optimization level. // (i.e. OptimizationLevel_Normal) - const char *forcedDefaultIonWarmUpThresholdEnv = "JIT_OPTION_forcedDefaultIonWarmUpThreshold"; - if (const char *env = getenv(forcedDefaultIonWarmUpThresholdEnv)) { - Maybe value = ParseInt(env); - if (value.isSome()) - forcedDefaultIonWarmUpThreshold.emplace(value.ref()); - else - Warn(forcedDefaultIonWarmUpThresholdEnv, env); - } + SET_DEFAULT(forceDefaultIonWarmUpThreshold, false); + SET_DEFAULT(forcedDefaultIonWarmUpThreshold, 1000); - // Force the used register allocator instead of letting the optimization - // pass decide. - const char *forcedRegisterAllocatorEnv = "JIT_OPTION_forcedRegisterAllocator"; - if (const char *env = getenv(forcedRegisterAllocatorEnv)) { - forcedRegisterAllocator = LookupRegisterAllocator(env); - if (!forcedRegisterAllocator.isSome()) - Warn(forcedRegisterAllocatorEnv, env); - } + // Force the used register allocator instead of letting the + // optimization pass decide. + forceRegisterAllocator = false; + forcedRegisterAllocator = RegisterAllocator_LSRA; // Toggles whether large scripts are rejected. SET_DEFAULT(limitScriptSize, true); @@ -173,13 +148,15 @@ JitOptions::setEagerCompilation() { eagerCompilation = true; baselineWarmUpThreshold = 0; - forcedDefaultIonWarmUpThreshold.emplace(0); + forceDefaultIonWarmUpThreshold = true; + forcedDefaultIonWarmUpThreshold = 0; } void JitOptions::setCompilerWarmUpThreshold(uint32_t warmUpThreshold) { - forcedDefaultIonWarmUpThreshold.emplace(warmUpThreshold); + forceDefaultIonWarmUpThreshold = true; + forcedDefaultIonWarmUpThreshold = warmUpThreshold; // Undo eager compilation if (eagerCompilation && warmUpThreshold != 0) { @@ -192,7 +169,7 @@ JitOptions::setCompilerWarmUpThreshold(uint32_t warmUpThreshold) void JitOptions::resetCompilerWarmUpThreshold() { - forcedDefaultIonWarmUpThreshold.reset(); + forceDefaultIonWarmUpThreshold = false; // Undo eager compilation if (eagerCompilation) { diff --git a/js/src/jit/JitOptions.h b/js/src/jit/JitOptions.h index 7654de0466c1..031fb68a00db 100644 --- a/js/src/jit/JitOptions.h +++ b/js/src/jit/JitOptions.h @@ -25,18 +25,6 @@ enum IonRegisterAllocator { RegisterAllocator_Stupid }; -static inline mozilla::Maybe -LookupRegisterAllocator(const char *name) -{ - if (!strcmp(name, "lsra")) - return mozilla::Some(RegisterAllocator_LSRA); - if (!strcmp(name, "backtracking")) - return mozilla::Some(RegisterAllocator_Backtracking); - if (!strcmp(name, "stupid")) - return mozilla::Some(RegisterAllocator_Stupid); - return mozilla::Nothing(); -} - struct JitOptions { bool checkGraphConsistency; @@ -54,8 +42,10 @@ struct JitOptions bool disableLoopUnrolling; bool disableEaa; bool eagerCompilation; - mozilla::Maybe forcedDefaultIonWarmUpThreshold; - mozilla::Maybe forcedRegisterAllocator; + bool forceDefaultIonWarmUpThreshold; + uint32_t forcedDefaultIonWarmUpThreshold; + bool forceRegisterAllocator; + IonRegisterAllocator forcedRegisterAllocator; bool limitScriptSize; bool osr; uint32_t baselineWarmUpThreshold; diff --git a/js/src/jsapi.cpp b/js/src/jsapi.cpp index 892022faaaa0..7d17b6fe6529 100644 --- a/js/src/jsapi.cpp +++ b/js/src/jsapi.cpp @@ -5738,9 +5738,7 @@ JS_GetGlobalJitCompilerOption(JSRuntime *rt, JSJitCompilerOption opt) case JSJITCOMPILER_BASELINE_WARMUP_TRIGGER: return jit::js_JitOptions.baselineWarmUpThreshold; case JSJITCOMPILER_ION_WARMUP_TRIGGER: - return jit::js_JitOptions.forcedDefaultIonWarmUpThreshold.isSome() - ? jit::js_JitOptions.forcedDefaultIonWarmUpThreshold.ref() - : jit::OptimizationInfo::CompilerWarmupThreshold; + return jit::js_JitOptions.forcedDefaultIonWarmUpThreshold; case JSJITCOMPILER_ION_ENABLE: return JS::RuntimeOptionsRef(rt).ion(); case JSJITCOMPILER_BASELINE_ENABLE: diff --git a/js/src/shell/js.cpp b/js/src/shell/js.cpp index 2a97c86c6aa5..b2c639976cd8 100644 --- a/js/src/shell/js.cpp +++ b/js/src/shell/js.cpp @@ -5650,9 +5650,18 @@ SetRuntimeOptions(JSRuntime *rt, const OptionParser &op) jit::js_JitOptions.baselineWarmUpThreshold = 0; if (const char *str = op.getStringOption("ion-regalloc")) { - jit::js_JitOptions.forcedRegisterAllocator = jit::LookupRegisterAllocator(str); - if (!jit::js_JitOptions.forcedRegisterAllocator.isSome()) + if (strcmp(str, "lsra") == 0) { + jit::js_JitOptions.forceRegisterAllocator = true; + jit::js_JitOptions.forcedRegisterAllocator = jit::RegisterAllocator_LSRA; + } else if (strcmp(str, "backtracking") == 0) { + jit::js_JitOptions.forceRegisterAllocator = true; + jit::js_JitOptions.forcedRegisterAllocator = jit::RegisterAllocator_Backtracking; + } else if (strcmp(str, "stupid") == 0) { + jit::js_JitOptions.forceRegisterAllocator = true; + jit::js_JitOptions.forcedRegisterAllocator = jit::RegisterAllocator_Stupid; + } else { return OptionFailure("ion-regalloc", str); + } } if (op.getBoolOption("ion-eager"))