#include "config.h"
#include "Options.h"
#include "HeapStatistics.h"
#include <algorithm>
#include <limits>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wtf/NumberOfCores.h>
#include <wtf/PageBlock.h>
#include <wtf/StdLibExtras.h>
#include <wtf/StringExtras.h>
#if OS(DARWIN) && ENABLE(PARALLEL_GC)
#include <sys/sysctl.h>
#endif
namespace JSC {
static bool parse(const char* string, bool& value)
{
if (!strcasecmp(string, "true") || !strcasecmp(string, "yes") || !strcmp(string, "1")) {
value = true;
return true;
}
if (!strcasecmp(string, "false") || !strcasecmp(string, "no") || !strcmp(string, "0")) {
value = false;
return true;
}
return false;
}
static bool parse(const char* string, int32_t& value)
{
return sscanf(string, "%d", &value) == 1;
}
static bool parse(const char* string, unsigned& value)
{
return sscanf(string, "%u", &value) == 1;
}
static bool parse(const char* string, double& value)
{
return sscanf(string, "%lf", &value) == 1;
}
static bool parse(const char* string, OptionRange& value)
{
return value.init(string);
}
template<typename T>
void overrideOptionWithHeuristic(T& variable, const char* name)
{
#if !OS(WINCE)
const char* stringValue = getenv(name);
if (!stringValue)
return;
if (parse(stringValue, variable))
return;
fprintf(stderr, "WARNING: failed to parse %s=%s\n", name, stringValue);
#endif
}
static unsigned computeNumberOfGCMarkers(int maxNumberOfGCMarkers)
{
int cpusToUse = 1;
#if ENABLE(PARALLEL_GC)
cpusToUse = std::min(WTF::numberOfProcessorCores(), maxNumberOfGCMarkers);
ASSERT(cpusToUse >= 1);
if (cpusToUse < 1)
cpusToUse = 1;
#else
UNUSED_PARAM(maxNumberOfGCMarkers);
#endif
return cpusToUse;
}
bool OptionRange::init(const char* rangeString)
{
bool invert = false;
if (m_state > Uninitialized)
return true;
if (!rangeString) {
m_state = InitError;
return false;
}
m_rangeString = rangeString;
if (*rangeString == '!') {
invert = true;
rangeString++;
}
int scanResult = sscanf(rangeString, " %u:%u", &m_lowLimit, &m_highLimit);
if (!scanResult || scanResult == EOF) {
m_state = InitError;
return false;
}
if (scanResult == 1)
m_highLimit = m_lowLimit;
if (m_lowLimit > m_highLimit) {
m_state = InitError;
return false;
}
m_state = invert ? Inverted : Normal;
return true;
}
bool OptionRange::isInRange(unsigned count)
{
if (m_state < Normal)
return true;
if ((m_lowLimit <= count) && (count <= m_highLimit))
return m_state == Normal ? true : false;
return m_state == Normal ? false : true;
}
Options::Entry Options::s_options[Options::numberOfOptions];
const Options::EntryInfo Options::s_optionsInfo[Options::numberOfOptions] = {
#define FOR_EACH_OPTION(type_, name_, defaultValue_) \
{ #name_, Options::type_##Type },
JSC_OPTIONS(FOR_EACH_OPTION)
#undef FOR_EACH_OPTION
};
void Options::initialize()
{
#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
#define FOR_EACH_OPTION(type_, name_, defaultValue_) \
overrideOptionWithHeuristic(name_(), "JSC_" #name_);
JSC_OPTIONS(FOR_EACH_OPTION)
#undef FOR_EACH_OPTION
#if 0
; #endif
#if !ENABLE(JIT)
useJIT() = false;
useDFGJIT() = false;
#endif
#if !ENABLE(YARR_JIT)
useRegExpJIT() = false;
#endif
ASSERT(thresholdForOptimizeAfterLongWarmUp() >= thresholdForOptimizeAfterWarmUp());
ASSERT(thresholdForOptimizeAfterWarmUp() >= thresholdForOptimizeSoon());
ASSERT(thresholdForOptimizeAfterWarmUp() >= 0);
reoptimizationRetryCounterMax() = 0;
while ((static_cast<int64_t>(thresholdForOptimizeAfterLongWarmUp()) << (reoptimizationRetryCounterMax() + 1)) <= static_cast<int64_t>(std::numeric_limits<int32>::max()))
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()));
}
bool Options::setOption(const char* arg)
{
const char* equalStr = strchr(arg, '=');
if (!equalStr)
return false;
const char* valueStr = equalStr + 1;
#define FOR_EACH_OPTION(type_, name_, defaultValue_) \
if (!strncmp(arg, #name_, equalStr - arg)) { \
type_ value; \
value = 0; \
bool success = parse(valueStr, value); \
if (success) { \
name_() = value; \
return true; \
} \
return false; \
}
JSC_OPTIONS(FOR_EACH_OPTION)
#undef FOR_EACH_OPTION
return false; }
void Options::dumpAllOptions(FILE* stream)
{
fprintf(stream, "JSC runtime options:\n");
for (int id = 0; id < numberOfOptions; id++)
dumpOption(static_cast<OptionID>(id), stream, " ", "\n");
}
void Options::dumpOption(OptionID id, FILE* stream, const char* header, const char* footer)
{
if (id >= numberOfOptions)
return;
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");
break;
case unsignedType:
fprintf(stream, "%u", s_options[id].u.unsignedVal);
break;
case doubleType:
fprintf(stream, "%lf", s_options[id].u.doubleVal);
break;
case int32Type:
fprintf(stream, "%d", s_options[id].u.int32Val);
break;
case optionRangeType:
fprintf(stream, "%s", s_options[id].u.optionRangeVal.rangeString());
break;
}
fprintf(stream, "%s", footer);
}
}