JavaScriptCore-7601.1.46.3.tar.gz

[apple/javascriptcore.git] / runtime / Options.cpp

diff --git a/runtime/Options.cpp b/runtime/Options.cpp
index 40711bfa30fae2a796fd962041d0feba108bd1a6..c9c698f7368cfd67ff8d447ee7c03bc92baae9da 100644 (file)
--- a/runtime/Options.cpp
+++ b/runtime/Options.cpp
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (C) 2011, 2012 Apple Inc. All rights reserved.
+ * Copyright (C) 2011-2012, 2014-2015 Apple Inc. All rights reserved.

  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions


@@ -29,9 +29,11 @@
 #include "HeapStatistics.h"
 #include <algorithm>
 #include <limits>
 #include "HeapStatistics.h"
 #include <algorithm>
 #include <limits>

-#include <stdio.h>
+#include <math.h>
+#include <mutex>

 #include <stdlib.h>
 #include <string.h>
 #include <stdlib.h>
 #include <string.h>

+#include <wtf/DataLog.h>

 #include <wtf/NumberOfCores.h>
 #include <wtf/PageBlock.h>
 #include <wtf/StdLibExtras.h>
 #include <wtf/NumberOfCores.h>
 #include <wtf/PageBlock.h>
 #include <wtf/StdLibExtras.h>


@@ -41,6 +43,10 @@
 #include <sys/sysctl.h>
 #endif
 
 #include <sys/sysctl.h>
 #endif
 

+#if OS(WINDOWS)
+#include "MacroAssemblerX86.h"
+#endif
+

 namespace JSC {
 
 static bool parse(const char* string, bool& value)
 namespace JSC {
 
 static bool parse(const char* string, bool& value)


@@ -76,37 +82,71 @@ static bool parse(const char* string, OptionRange& value)
     return value.init(string);
 }
 
     return value.init(string);
 }
 

+static bool parse(const char* string, const char*& value)
+{
+    value = string;
+    return true;
+}
+
+static bool parse(const char* string, GCLogging::Level& value)
+{
+    if (!strcasecmp(string, "none") || !strcasecmp(string, "no") || !strcasecmp(string, "false") || !strcmp(string, "0")) {
+        value = GCLogging::None;
+        return true;
+    }
+
+    if (!strcasecmp(string, "basic") || !strcasecmp(string, "yes") || !strcasecmp(string, "true") || !strcmp(string, "1")) {
+        value = GCLogging::Basic;
+        return true;
+    }
+
+    if (!strcasecmp(string, "verbose") || !strcmp(string, "2")) {
+        value = GCLogging::Verbose;
+        return true;
+    }
+
+    return false;
+}
+

 template<typename T>
 template<typename T>

-void overrideOptionWithHeuristic(T& variable, const char* name)
+bool overrideOptionWithHeuristic(T& variable, const char* name)

 {
 {

-#if !OS(WINCE)

     const char* stringValue = getenv(name);
     if (!stringValue)
     const char* stringValue = getenv(name);
     if (!stringValue)

-        return;
+        return false;

     
     if (parse(stringValue, variable))
     
     if (parse(stringValue, variable))

-        return;
+        return true;

     
     fprintf(stderr, "WARNING: failed to parse %s=%s\n", name, stringValue);
     
     fprintf(stderr, "WARNING: failed to parse %s=%s\n", name, stringValue);

-#endif
+    return false;

 }
 
 }
 

-static unsigned computeNumberOfGCMarkers(int maxNumberOfGCMarkers)
+static unsigned computeNumberOfWorkerThreads(int maxNumberOfWorkerThreads, int minimum = 1)

 {
 {

-    int cpusToUse = 1;
-
-#if ENABLE(PARALLEL_GC)
-    cpusToUse = std::min(WTF::numberOfProcessorCores(), maxNumberOfGCMarkers);
+    int cpusToUse = std::min(WTF::numberOfProcessorCores(), maxNumberOfWorkerThreads);

 
     // Be paranoid, it is the OS we're dealing with, after all.
     ASSERT(cpusToUse >= 1);
 
     // Be paranoid, it is the OS we're dealing with, after all.
     ASSERT(cpusToUse >= 1);

-    if (cpusToUse < 1)
-        cpusToUse = 1;
+    return std::max(cpusToUse, minimum);
+}
+
+static int32_t computePriorityDeltaOfWorkerThreads(int32_t twoCorePriorityDelta, int32_t multiCorePriorityDelta)
+{
+    if (WTF::numberOfProcessorCores() <= 2)
+        return twoCorePriorityDelta;
+
+    return multiCorePriorityDelta;
+}
+
+static unsigned computeNumberOfGCMarkers(unsigned maxNumberOfGCMarkers)
+{
+#if ENABLE(PARALLEL_GC)
+    return computeNumberOfWorkerThreads(maxNumberOfGCMarkers);

 #else
     UNUSED_PARAM(maxNumberOfGCMarkers);
 #else
     UNUSED_PARAM(maxNumberOfGCMarkers);

+    return 1;

 #endif
 #endif

-
-    return cpusToUse;

 }
 
 bool OptionRange::init(const char* rangeString)
 }
 
 bool OptionRange::init(const char* rangeString)


@@ -162,69 +202,188 @@ bool OptionRange::isInRange(unsigned count)
     return m_state == Normal ? false : true;
 }
 
     return m_state == Normal ? false : true;
 }
 

+void OptionRange::dump(PrintStream& out) const
+{
+    out.print(m_rangeString);
+}
+

 Options::Entry Options::s_options[Options::numberOfOptions];
 Options::Entry Options::s_options[Options::numberOfOptions];

+Options::Entry Options::s_defaultOptions[Options::numberOfOptions];

 
 // Realize the names for each of the options:
 const Options::EntryInfo Options::s_optionsInfo[Options::numberOfOptions] = {
 
 // Realize the names for each of the options:
 const Options::EntryInfo Options::s_optionsInfo[Options::numberOfOptions] = {

-#define FOR_EACH_OPTION(type_, name_, defaultValue_) \
-    { #name_, Options::type_##Type },
+#define FOR_EACH_OPTION(type_, name_, defaultValue_, description_) \
+    { #name_, description_, Options::Type::type_##Type },

     JSC_OPTIONS(FOR_EACH_OPTION)
 #undef FOR_EACH_OPTION
 };
 
     JSC_OPTIONS(FOR_EACH_OPTION)
 #undef FOR_EACH_OPTION
 };
 

-void Options::initialize()
+static void scaleJITPolicy()

 {
 {

-    // Initialize each of the options with their default values:
-#define FOR_EACH_OPTION(type_, name_, defaultValue_) \
-    name_() = defaultValue_;
-    JSC_OPTIONS(FOR_EACH_OPTION)
-#undef FOR_EACH_OPTION
-        
-#if USE(CF) || OS(UNIX)
-    objectsAreImmortal() = !!getenv("JSImmortalZombieEnabled");
-    useZombieMode() = !!getenv("JSImmortalZombieEnabled") || !!getenv("JSZombieEnabled");
-
-    gcMaxHeapSize() = getenv("GCMaxHeapSize") ? HeapStatistics::parseMemoryAmount(getenv("GCMaxHeapSize")) : 0;
-    recordGCPauseTimes() = !!getenv("JSRecordGCPauseTimes");
-    logHeapStatisticsAtExit() = gcMaxHeapSize() || recordGCPauseTimes();
-#endif
-
-    // Allow environment vars to override options if applicable.
-    // The evn var should be the name of the option prefixed with
-    // "JSC_".
-#define FOR_EACH_OPTION(type_, name_, defaultValue_) \
-    overrideOptionWithHeuristic(name_(), "JSC_" #name_);
-    JSC_OPTIONS(FOR_EACH_OPTION)
-#undef FOR_EACH_OPTION
+    auto& scaleFactor = Options::jitPolicyScale();
+    if (scaleFactor > 1.0)
+        scaleFactor = 1.0;
+    else if (scaleFactor < 0.0)
+        scaleFactor = 0.0;
+
+    struct OptionToScale {
+        Options::OptionID id;
+        int32_t minVal;
+    };
+
+    static const OptionToScale optionsToScale[] = {
+        { Options::thresholdForJITAfterWarmUpID, 0 },
+        { Options::thresholdForJITSoonID, 0 },
+        { Options::thresholdForOptimizeAfterWarmUpID, 1 },
+        { Options::thresholdForOptimizeAfterLongWarmUpID, 1 },
+        { Options::thresholdForOptimizeSoonID, 1 },
+        { Options::thresholdForFTLOptimizeSoonID, 2 },
+        { Options::thresholdForFTLOptimizeAfterWarmUpID, 2 }
+    };
+
+    const int numberOfOptionsToScale = sizeof(optionsToScale) / sizeof(OptionToScale);
+    for (int i = 0; i < numberOfOptionsToScale; i++) {
+        Option option(optionsToScale[i].id);
+        ASSERT(option.type() == Options::Type::int32Type);
+        option.int32Val() *= scaleFactor;
+        option.int32Val() = std::max(option.int32Val(), optionsToScale[i].minVal);
+    }
+}

 
 

-#if 0
-    ; // Deconfuse editors that do auto indentation
-#endif
-    
+static void recomputeDependentOptions()
+{

 #if !ENABLE(JIT)
 #if !ENABLE(JIT)

-    useJIT() = false;
-    useDFGJIT() = false;
+    Options::useLLInt() = true;
+    Options::useJIT() = false;
+    Options::useDFGJIT() = false;
+    Options::useFTLJIT() = false;

 #endif
 #if !ENABLE(YARR_JIT)
 #endif
 #if !ENABLE(YARR_JIT)

-    useRegExpJIT() = false;
+    Options::useRegExpJIT() = false;
+#endif
+#if !ENABLE(CONCURRENT_JIT)
+    Options::enableConcurrentJIT() = false;
+#endif
+#if !ENABLE(DFG_JIT)
+    Options::useDFGJIT() = false;
+    Options::useFTLJIT() = false;

 #endif
 #endif

+#if !ENABLE(FTL_JIT)
+    Options::useFTLJIT() = false;
+#endif
+#if OS(WINDOWS) && CPU(X86) 
+    // Disable JIT on Windows if SSE2 is not present 
+    if (!MacroAssemblerX86::supportsFloatingPoint())
+        Options::useJIT() = false;
+#endif
+    if (Options::showDisassembly()
+        || Options::showDFGDisassembly()
+        || Options::showFTLDisassembly()
+        || Options::dumpBytecodeAtDFGTime()
+        || Options::dumpGraphAtEachPhase()
+        || Options::verboseCompilation()
+        || Options::verboseFTLCompilation()
+        || Options::logCompilationChanges()
+        || Options::validateGraph()
+        || Options::validateGraphAtEachPhase()
+        || Options::verboseOSR()
+        || Options::verboseCompilationQueue()
+        || Options::reportCompileTimes()
+        || Options::reportFTLCompileTimes()
+        || Options::verboseCFA()
+        || Options::verboseFTLFailure())
+        Options::alwaysComputeHash() = true;
+
+    if (Option(Options::jitPolicyScaleID).isOverridden())
+        scaleJITPolicy();

     
     

-    // Do range checks where needed and make corrections to the options:
-    ASSERT(thresholdForOptimizeAfterLongWarmUp() >= thresholdForOptimizeAfterWarmUp());
-    ASSERT(thresholdForOptimizeAfterWarmUp() >= thresholdForOptimizeSoon());
-    ASSERT(thresholdForOptimizeAfterWarmUp() >= 0);
+    if (Options::forceEagerCompilation()) {
+        Options::thresholdForJITAfterWarmUp() = 10;
+        Options::thresholdForJITSoon() = 10;
+        Options::thresholdForOptimizeAfterWarmUp() = 20;
+        Options::thresholdForOptimizeAfterLongWarmUp() = 20;
+        Options::thresholdForOptimizeSoon() = 20;
+        Options::thresholdForFTLOptimizeAfterWarmUp() = 20;
+        Options::thresholdForFTLOptimizeSoon() = 20;
+        Options::maximumEvalCacheableSourceLength() = 150000;
+        Options::enableConcurrentJIT() = false;
+    }

 
     // Compute the maximum value of the reoptimization retry counter. This is simply
     // the largest value at which we don't overflow the execute counter, when using it
     // to left-shift the execution counter by this amount. Currently the value ends
     // up being 18, so this loop is not so terrible; it probably takes up ~100 cycles
     // total on a 32-bit processor.
 
     // Compute the maximum value of the reoptimization retry counter. This is simply
     // the largest value at which we don't overflow the execute counter, when using it
     // to left-shift the execution counter by this amount. Currently the value ends
     // up being 18, so this loop is not so terrible; it probably takes up ~100 cycles
     // total on a 32-bit processor.

-    reoptimizationRetryCounterMax() = 0;
-    while ((static_cast<int64_t>(thresholdForOptimizeAfterLongWarmUp()) << (reoptimizationRetryCounterMax() + 1)) <= static_cast<int64_t>(std::numeric_limits<int32>::max()))
-        reoptimizationRetryCounterMax()++;
+    Options::reoptimizationRetryCounterMax() = 0;
+    while ((static_cast<int64_t>(Options::thresholdForOptimizeAfterLongWarmUp()) << (Options::reoptimizationRetryCounterMax() + 1)) <= static_cast<int64_t>(std::numeric_limits<int32_t>::max()))
+        Options::reoptimizationRetryCounterMax()++;

 
 

-    ASSERT((static_cast<int64_t>(thresholdForOptimizeAfterLongWarmUp()) << reoptimizationRetryCounterMax()) > 0);
-    ASSERT((static_cast<int64_t>(thresholdForOptimizeAfterLongWarmUp()) << reoptimizationRetryCounterMax()) <= static_cast<int64_t>(std::numeric_limits<int32>::max()));
+    ASSERT((static_cast<int64_t>(Options::thresholdForOptimizeAfterLongWarmUp()) << Options::reoptimizationRetryCounterMax()) > 0);
+    ASSERT((static_cast<int64_t>(Options::thresholdForOptimizeAfterLongWarmUp()) << Options::reoptimizationRetryCounterMax()) <= static_cast<int64_t>(std::numeric_limits<int32_t>::max()));
+}
+
+void Options::initialize()
+{
+    static std::once_flag initializeOptionsOnceFlag;
+    
+    std::call_once(
+        initializeOptionsOnceFlag,
+        [] {
+            // Initialize each of the options with their default values:
+#define FOR_EACH_OPTION(type_, name_, defaultValue_, description_)      \
+            name_() = defaultValue_;                                    \
+            name_##Default() = defaultValue_;
+            JSC_OPTIONS(FOR_EACH_OPTION)
+#undef FOR_EACH_OPTION
+    
+                // It *probably* makes sense for other platforms to enable this.
+#if PLATFORM(IOS) && CPU(ARM64)
+                enableLLVMFastISel() = true;
+#endif
+        
+            // Allow environment vars to override options if applicable.
+            // The evn var should be the name of the option prefixed with
+            // "JSC_".
+#define FOR_EACH_OPTION(type_, name_, defaultValue_, description_)      \
+            overrideOptionWithHeuristic(name_(), "JSC_" #name_);
+            JSC_OPTIONS(FOR_EACH_OPTION)
+#undef FOR_EACH_OPTION
+
+#if 0
+                ; // Deconfuse editors that do auto indentation
+#endif
+    
+            recomputeDependentOptions();
+
+            // Do range checks where needed and make corrections to the options:
+            ASSERT(Options::thresholdForOptimizeAfterLongWarmUp() >= Options::thresholdForOptimizeAfterWarmUp());
+            ASSERT(Options::thresholdForOptimizeAfterWarmUp() >= Options::thresholdForOptimizeSoon());
+            ASSERT(Options::thresholdForOptimizeAfterWarmUp() >= 0);
+
+            if (Options::showOptions()) {
+                DumpLevel level = static_cast<DumpLevel>(Options::showOptions());
+                if (level > DumpLevel::Verbose)
+                    level = DumpLevel::Verbose;
+
+                const char* title = nullptr;
+                switch (level) {
+                case DumpLevel::None:
+                    break;
+                case DumpLevel::Overridden:
+                    title = "Overridden JSC options:";
+                    break;
+                case DumpLevel::All:
+                    title = "All JSC options:";
+                    break;
+                case DumpLevel::Verbose:
+                    title = "All JSC options with descriptions:";
+                    break;
+                }
+                dumpAllOptions(level, title);
+            }
+
+            ensureOptionsAreCoherent();
+        });

 }
 
 // Parses a single command line option in the format "<optionName>=<value>"
 }
 
 // Parses a single command line option in the format "<optionName>=<value>"


@@ -241,13 +400,14 @@ bool Options::setOption(const char* arg)
 
     // For each option, check if the specify arg is a match. If so, set the arg
     // if the value makes sense. Otherwise, move on to checking the next option.
 
     // For each option, check if the specify arg is a match. If so, set the arg
     // if the value makes sense. Otherwise, move on to checking the next option.

-#define FOR_EACH_OPTION(type_, name_, defaultValue_)    \
+#define FOR_EACH_OPTION(type_, name_, defaultValue_, description_) \

     if (!strncmp(arg, #name_, equalStr - arg)) {        \
         type_ value;                                    \
     if (!strncmp(arg, #name_, equalStr - arg)) {        \
         type_ value;                                    \

-        value = 0;                                      \
+        value = (defaultValue_);                        \

         bool success = parse(valueStr, value);          \
         if (success) {                                  \
             name_() = value;                            \
         bool success = parse(valueStr, value);          \
         if (success) {                                  \
             name_() = value;                            \

+            recomputeDependentOptions();                \

             return true;                                \
         }                                               \
         return false;                                   \
             return true;                                \
         }                                               \
         return false;                                   \


@@ -256,40 +416,107 @@ bool Options::setOption(const char* arg)
     JSC_OPTIONS(FOR_EACH_OPTION)
 #undef FOR_EACH_OPTION
 
     JSC_OPTIONS(FOR_EACH_OPTION)
 #undef FOR_EACH_OPTION
 

-        return false; // No option matched.
+    return false; // No option matched.

 }
 
 }
 

-void Options::dumpAllOptions(FILE* stream)
+void Options::dumpAllOptions(DumpLevel level, const char* title, FILE* stream)

 {
 {

-    fprintf(stream, "JSC runtime options:\n");
+    if (title)
+        fprintf(stream, "%s\n", title);

     for (int id = 0; id < numberOfOptions; id++)
     for (int id = 0; id < numberOfOptions; id++)

-        dumpOption(static_cast<OptionID>(id), stream, "   ", "\n");
+        dumpOption(level, static_cast<OptionID>(id), stream, "   ", "\n");

 }
 
 }
 

-void Options::dumpOption(OptionID id, FILE* stream, const char* header, const char* footer)
+void Options::dumpOption(DumpLevel level, OptionID id, FILE* stream, const char* header, const char* footer)

 {
     if (id >= numberOfOptions)
         return; // Illegal option.
 
 {
     if (id >= numberOfOptions)
         return; // Illegal option.
 

-    fprintf(stream, "%s%s: ", header, s_optionsInfo[id].name);
-    switch (s_optionsInfo[id].type) {
-    case boolType:
-        fprintf(stream, "%s", s_options[id].u.boolVal?"true":"false");
+    Option option(id);
+    bool wasOverridden = option.isOverridden();
+    bool needsDescription = (level == DumpLevel::Verbose && option.description());
+
+    if (level == DumpLevel::Overridden && !wasOverridden)
+        return;
+
+    fprintf(stream, "%s%s: ", header, option.name());
+    option.dump(stream);
+
+    if (wasOverridden) {
+        fprintf(stream, " (default: ");
+        option.defaultOption().dump(stream);
+        fprintf(stream, ")");
+    }
+
+    if (needsDescription)
+        fprintf(stream, "   ... %s", option.description());
+
+    fprintf(stream, "%s", footer);
+}
+
+void Options::ensureOptionsAreCoherent()
+{
+    bool coherent = true;
+    if (!(useLLInt() || useJIT())) {
+        coherent = false;
+        dataLog("INCOHERENT OPTIONS: at least one of useLLInt or useJIT must be true\n");
+    }
+    if (!coherent)
+        CRASH();
+}
+
+void Option::dump(FILE* stream) const
+{
+    switch (type()) {
+    case Options::Type::boolType:
+        fprintf(stream, "%s", m_entry.boolVal ? "true" : "false");
+        break;
+    case Options::Type::unsignedType:
+        fprintf(stream, "%u", m_entry.unsignedVal);

         break;
         break;

-    case unsignedType:
-        fprintf(stream, "%u", s_options[id].u.unsignedVal);
+    case Options::Type::doubleType:
+        fprintf(stream, "%lf", m_entry.doubleVal);

         break;
         break;

-    case doubleType:
-        fprintf(stream, "%lf", s_options[id].u.doubleVal);
+    case Options::Type::int32Type:
+        fprintf(stream, "%d", m_entry.int32Val);

         break;
         break;

-    case int32Type:
-        fprintf(stream, "%d", s_options[id].u.int32Val);
+    case Options::Type::optionRangeType:
+        fprintf(stream, "%s", m_entry.optionRangeVal.rangeString());

         break;
         break;

-    case optionRangeType:
-        fprintf(stream, "%s", s_options[id].u.optionRangeVal.rangeString());
+    case Options::Type::optionStringType: {
+        const char* option = m_entry.optionStringVal;
+        if (!option)
+            option = "";
+        fprintf(stream, "%s", option);

         break;
     }
         break;
     }

-    fprintf(stream, "%s", footer);
+    case Options::Type::gcLogLevelType: {
+        fprintf(stream, "%s", GCLogging::levelAsString(m_entry.gcLogLevelVal));
+        break;
+    }
+    }
+}
+
+bool Option::operator==(const Option& other) const
+{
+    switch (type()) {
+    case Options::Type::boolType:
+        return m_entry.boolVal == other.m_entry.boolVal;
+    case Options::Type::unsignedType:
+        return m_entry.unsignedVal == other.m_entry.unsignedVal;
+    case Options::Type::doubleType:
+        return (m_entry.doubleVal == other.m_entry.doubleVal) || (isnan(m_entry.doubleVal) && isnan(other.m_entry.doubleVal));
+    case Options::Type::int32Type:
+        return m_entry.int32Val == other.m_entry.int32Val;
+    case Options::Type::optionRangeType:
+        return m_entry.optionRangeVal.rangeString() == other.m_entry.optionRangeVal.rangeString();
+    case Options::Type::optionStringType:
+        return (m_entry.optionStringVal == other.m_entry.optionStringVal)
+            || (m_entry.optionStringVal && other.m_entry.optionStringVal && !strcmp(m_entry.optionStringVal, other.m_entry.optionStringVal));
+    case Options::Type::gcLogLevelType:
+        return m_entry.gcLogLevelVal == other.m_entry.gcLogLevelVal;
+    }
+    return false;

 }
 
 } // namespace JSC
 }
 
 } // namespace JSC