git.saurik.com Git - apple/javascriptcore.git/blob

1 /*

3 *

4 * Redistribution and use in source and binary forms, with or without

5 * modification, are permitted provided that the following conditions

6 * are met:

7 * 1. Redistributions of source code must retain the above copyright

8 * notice, this list of conditions and the following disclaimer.

9 * 2. Redistributions in binary form must reproduce the above copyright

10 * notice, this list of conditions and the following disclaimer in the

11 * documentation and/or other materials provided with the distribution.

12 *

13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

14 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR

17 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

18 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

19 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

20 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

21 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

24 */

26 #include "config.h"

27 #include "Options.h"

29 #include "HeapStatistics.h"

30 #include <algorithm>

31 #include <limits>

32 #include <math.h>

33 #include <mutex>

34 #include <stdlib.h>

35 #include <string.h>

36 #include <wtf/DataLog.h>

37 #include <wtf/NumberOfCores.h>

38 #include <wtf/PageBlock.h>

39 #include <wtf/StdLibExtras.h>

40 #include <wtf/StringExtras.h>

42 #if OS(DARWIN) && ENABLE(PARALLEL_GC)

43 #include <sys/sysctl.h>

44 #endif

46 #if OS(WINDOWS)

47 #include "MacroAssemblerX86.h"

48 #endif

50 namespace JSC {

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

53 {

     if (!strcasecmp(string, "true") || !strcasecmp(string, "yes") || !strcmp(string, "1")) {

55 value = true;

56 return true;

57 }

     if (!strcasecmp(string, "false") || !strcasecmp(string, "no") || !strcmp(string, "0")) {

59 value = false;

60 return true;

61 }

62 return false;

63 }

 static bool parse(const char* string, int32_t& value)

66 {

     return sscanf(string, "%d", &value) == 1;

68 }

 static bool parse(const char* string, unsigned& value)

71 {

     return sscanf(string, "%u", &value) == 1;

73 }

 static bool parse(const char* string, double& value)

76 {

     return sscanf(string, "%lf", &value) == 1;

78 }

 static bool parse(const char* string, OptionRange& value)

81 {

     return value.init(string);

83 }

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

86 {

87 value = string;

88 return true;

89 }

 static bool parse(const char* string, GCLogging::Level& value)

92 {

     if (!strcasecmp(string, "none") || !strcasecmp(string, "no") || !strcasecmp(string, "false") || !strcmp(string, "0")) {

94 value = GCLogging::None;

95 return true;

96 }

     if (!strcasecmp(string, "basic") || !strcasecmp(string, "yes") || !strcasecmp(string, "true") || !strcmp(string, "1")) {

99 value = GCLogging::Basic;

100 return true;

101 }

102

     if (!strcasecmp(string, "verbose") || !strcmp(string, "2")) {

104 value = GCLogging::Verbose;

105 return true;

106 }

107

108 return false;

109 }

110

111 template<typename T>

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

113 {

     const char* stringValue = getenv(name);

115 if (!stringValue)

116 return false;

117

     if (parse(stringValue, variable))

119 return true;

120

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

122 return false;

123 }

124

 static unsigned computeNumberOfWorkerThreads(int maxNumberOfWorkerThreads, int minimum = 1)

126 {

     int cpusToUse = std::min(WTF::numberOfProcessorCores(), maxNumberOfWorkerThreads);

128

129 // Be paranoid, it is the OS we're dealing with, after all.

     ASSERT(cpusToUse >= 1);

     return std::max(cpusToUse, minimum);

132 }

133

 static int32_t computePriorityDeltaOfWorkerThreads(int32_t twoCorePriorityDelta, int32_t multiCorePriorityDelta)

135 {

     if (WTF::numberOfProcessorCores() <= 2)

137 return twoCorePriorityDelta;

138

139 return multiCorePriorityDelta;

140 }

141

 static unsigned computeNumberOfGCMarkers(unsigned maxNumberOfGCMarkers)

143 {

144 #if ENABLE(PARALLEL_GC)

145 return computeNumberOfWorkerThreads(maxNumberOfGCMarkers);

146 #else

147 UNUSED_PARAM(maxNumberOfGCMarkers);

148 return 1;

149 #endif

150 }

151

 bool OptionRange::init(const char* rangeString)

153 {

154 // rangeString should be in the form of [!]<low>[:<high>]

155 // where low and high are unsigned

156

157 bool invert = false;

158

159 if (m_state > Uninitialized)

160 return true;

161

162 if (!rangeString) {

163 m_state = InitError;

164 return false;

165 }

166

167 m_rangeString = rangeString;

168

     if (*rangeString == '!') {

170 invert = true;

171 rangeString++;

172 }

173

     int scanResult = sscanf(rangeString, " %u:%u", &m_lowLimit, &m_highLimit);

175

     if (!scanResult || scanResult == EOF) {

177 m_state = InitError;

178 return false;

179 }

180

     if (scanResult == 1)

182 m_highLimit = m_lowLimit;

183

184 if (m_lowLimit > m_highLimit) {

185 m_state = InitError;

186 return false;

187 }

188

189 m_state = invert ? Inverted : Normal;

190

191 return true;

192 }

193

 bool OptionRange::isInRange(unsigned count)

195 {

196 if (m_state < Normal)

197 return true;

198

     if ((m_lowLimit <= count) && (count <= m_highLimit))

         return m_state == Normal ? true : false;

201

     return m_state == Normal ? false : true;

203 }

204

 void OptionRange::dump(PrintStream& out) const

206 {

207 out.print(m_rangeString);

208 }

209

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

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

212

213 // Realize the names for each of the options:

 const Options::EntryInfo Options::s_optionsInfo[Options::numberOfOptions] = {

215 #define FOR_EACH_OPTION(type_, name_, defaultValue_, description_) \

216 { #name_, description_, Options::Type::type_##Type },

217 JSC_OPTIONS(FOR_EACH_OPTION)

218 #undef FOR_EACH_OPTION

219 };

220

221 static void scaleJITPolicy()

222 {

     auto& scaleFactor = Options::jitPolicyScale();

     if (scaleFactor > 1.0)

225 scaleFactor = 1.0;

     else if (scaleFactor < 0.0)

227 scaleFactor = 0.0;

228

229 struct OptionToScale {

230 Options::OptionID id;

231 int32_t minVal;

232 };

233

234 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 }

242 };

243

     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);

248 option.int32Val() *= scaleFactor;

         option.int32Val() = std::max(option.int32Val(), optionsToScale[i].minVal);

250 }

251 }

252

253 static void recomputeDependentOptions()

254 {

255 #if !ENABLE(JIT)

     Options::useLLInt() = true;

     Options::useJIT() = false;

     Options::useDFGJIT() = false;

     Options::useFTLJIT() = false;

260 #endif

261 #if !ENABLE(YARR_JIT)

     Options::useRegExpJIT() = false;

263 #endif

264 #if !ENABLE(CONCURRENT_JIT)

     Options::enableConcurrentJIT() = false;

266 #endif

267 #if !ENABLE(DFG_JIT)

     Options::useDFGJIT() = false;

     Options::useFTLJIT() = false;

270 #endif

271 #if !ENABLE(FTL_JIT)

     Options::useFTLJIT() = false;

273 #endif

274 #if OS(WINDOWS) && CPU(X86)

275 // Disable JIT on Windows if SSE2 is not present

     if (!MacroAssemblerX86::supportsFloatingPoint())

         Options::useJIT() = false;

278 #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;

296

     if (Option(Options::jitPolicyScaleID).isOverridden())

298 scaleJITPolicy();

299

     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;

310 }

311

312 // Compute the maximum value of the reoptimization retry counter. This is simply

313 // the largest value at which we don't overflow the execute counter, when using it

314 // to left-shift the execution counter by this amount. Currently the value ends

315 // up being 18, so this loop is not so terrible; it probably takes up ~100 cycles

316 // total on a 32-bit processor.

     Options::reoptimizationRetryCounterMax() = 0;

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

319 Options::reoptimizationRetryCounterMax()++;

320

     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()));

323 }

324

 void Options::initialize()

326 {

327 static std::once_flag initializeOptionsOnceFlag;

328

329 std::call_once(

330 initializeOptionsOnceFlag,

331 [] {

332 // Initialize each of the options with their default values:

333 #define FOR_EACH_OPTION(type_, name_, defaultValue_, description_) \

334 name_() = defaultValue_; \

335 name_##Default() = defaultValue_;

336 JSC_OPTIONS(FOR_EACH_OPTION)

337 #undef FOR_EACH_OPTION

338

339 // It *probably* makes sense for other platforms to enable this.

340 #if PLATFORM(IOS) && CPU(ARM64)

341 enableLLVMFastISel() = true;

342 #endif

343

344 // Allow environment vars to override options if applicable.

345 // The evn var should be the name of the option prefixed with

346 // "JSC_".

347 #define FOR_EACH_OPTION(type_, name_, defaultValue_, description_) \

348 overrideOptionWithHeuristic(name_(), "JSC_" #name_);

349 JSC_OPTIONS(FOR_EACH_OPTION)

350 #undef FOR_EACH_OPTION

351

352 #if 0

353 ; // Deconfuse editors that do auto indentation

354 #endif

355

356 recomputeDependentOptions();

357

358 // 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);

362

             if (Options::showOptions()) {

                 DumpLevel level = static_cast<DumpLevel>(Options::showOptions());

                 if (level > DumpLevel::Verbose)

366 level = DumpLevel::Verbose;

367

                 const char* title = nullptr;

369 switch (level) {

370 case DumpLevel::None:

371 break;

372 case DumpLevel::Overridden:

373 title = "Overridden JSC options:";

374 break;

375 case DumpLevel::All:

376 title = "All JSC options:";

377 break;

378 case DumpLevel::Verbose:

379 title = "All JSC options with descriptions:";

380 break;

381 }

382 dumpAllOptions(level, title);

383 }

384

385 ensureOptionsAreCoherent();

386 });

387 }

388

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

390 // (no spaces allowed) and set the specified option if appropriate.

 bool Options::setOption(const char* arg)

392 {

393 // arg should look like this:

394 // <jscOptionName>=<appropriate value>

     const char* equalStr = strchr(arg, '=');

396 if (!equalStr)

397 return false;

398

     const char* valueStr = equalStr + 1;

400

401 // For each option, check if the specify arg is a match. If so, set the arg

402 // if the value makes sense. Otherwise, move on to checking the next option.

403 #define FOR_EACH_OPTION(type_, name_, defaultValue_, description_) \

404 if (!strncmp(arg, #name_, equalStr - arg)) { \

405 type_ value; \

406 value = (defaultValue_); \

407 bool success = parse(valueStr, value); \

408 if (success) { \

409 name_() = value; \

410 recomputeDependentOptions(); \

411 return true; \

412 } \

413 return false; \

414 }

415

416 JSC_OPTIONS(FOR_EACH_OPTION)

417 #undef FOR_EACH_OPTION

418

419 return false; // No option matched.

420 }

421

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

423 {

424 if (title)

         fprintf(stream, "%s\n", title);

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

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

428 }

429

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

431 {

432 if (id >= numberOfOptions)

433 return; // Illegal option.

434

435 Option option(id);

     bool wasOverridden = option.isOverridden();

     bool needsDescription = (level == DumpLevel::Verbose && option.description());

438

     if (level == DumpLevel::Overridden && !wasOverridden)

440 return;

441

     fprintf(stream, "%s%s: ", header, option.name());

443 option.dump(stream);

444

445 if (wasOverridden) {

         fprintf(stream, " (default: ");

         option.defaultOption().dump(stream);

         fprintf(stream, ")");

449 }

450

451 if (needsDescription)

         fprintf(stream, "   ... %s", option.description());

453

     fprintf(stream, "%s", footer);

455 }

456

 void Options::ensureOptionsAreCoherent()

458 {

459 bool coherent = true;

     if (!(useLLInt() || useJIT())) {

461 coherent = false;

         dataLog("INCOHERENT OPTIONS: at least one of useLLInt or useJIT must be true\n");

463 }

464 if (!coherent)

465 CRASH();

466 }

467

 void Option::dump(FILE* stream) const

469 {

470 switch (type()) {

     case Options::Type::boolType:

         fprintf(stream, "%s", m_entry.boolVal ? "true" : "false");

473 break;

     case Options::Type::unsignedType:

         fprintf(stream, "%u", m_entry.unsignedVal);

476 break;

     case Options::Type::doubleType:

         fprintf(stream, "%lf", m_entry.doubleVal);

479 break;

     case Options::Type::int32Type:

         fprintf(stream, "%d", m_entry.int32Val);

482 break;

     case Options::Type::optionRangeType:

         fprintf(stream, "%s", m_entry.optionRangeVal.rangeString());

485 break;

     case Options::Type::optionStringType: {

         const char* option = m_entry.optionStringVal;

488 if (!option)

489 option = "";

         fprintf(stream, "%s", option);

491 break;

492 }

     case Options::Type::gcLogLevelType: {

         fprintf(stream, "%s", GCLogging::levelAsString(m_entry.gcLogLevelVal));

495 break;

496 }

497 }

498 }

499

 bool Option::operator==(const Option& other) const

501 {

502 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;

518 }

519 return false;

520 }

521

522 } // namespace JSC

523