Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-23 02:05:42 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Backed out changeset 8b393c8dae2b (bug 1127908) for rootanalysis build test failures on a CLOSED TREE

Browse Source
This commit is contained in:
Carsten "Tomcat" Book 2015-02-03 17:06:27 +01:00
parent d4001130db
commit eda7ad2285
6 changed files with 42 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
js/src/jit/IonOptimizationLevels.cpp
View File

@ -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

13
js/src/jit/IonOptimizationLevels.h
View File

@ -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_;
}

59
js/src/jit/JitOptions.cpp
View File

@ -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<typename T> struct IsBool : mozilla::FalseType {};
template<> struct IsBool<bool> : mozilla::TrueType {};
static Maybe<int>
ParseInt(const char *str)
{
char *endp;
int retval = strtol(str, &endp, 0);
if (*endp == '\0')
return mozilla::Some(retval);
return mozilla::Nothing();
}
template<typename T>
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<int> 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<int> 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) {

18
js/src/jit/JitOptions.h
View File

@ -25,18 +25,6 @@ enum IonRegisterAllocator {
RegisterAllocator_Stupid
};
static inline mozilla::Maybe<IonRegisterAllocator>
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<uint32_t> forcedDefaultIonWarmUpThreshold;
mozilla::Maybe<IonRegisterAllocator> forcedRegisterAllocator;
bool forceDefaultIonWarmUpThreshold;
uint32_t forcedDefaultIonWarmUpThreshold;
bool forceRegisterAllocator;
IonRegisterAllocator forcedRegisterAllocator;
bool limitScriptSize;
bool osr;
uint32_t baselineWarmUpThreshold;

4
js/src/jsapi.cpp
View File

@ -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:

13
js/src/shell/js.cpp
View File

@ -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"))