JetStream should have a more rational story for jitter-oriented latency tests
[WebKit-https.git] / Source / JavaScriptCore / runtime / Options.h
1 /*
2  * Copyright (C) 2011-2015 Apple Inc. All rights reserved.
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  */
25
26 #ifndef Options_h
27 #define Options_h
28
29 #include "GCLogging.h"
30 #include "JSExportMacros.h"
31 #include <stdint.h>
32 #include <stdio.h>
33 #include <wtf/StdLibExtras.h>
34
35 namespace JSC {
36
37 // How do JSC VM options work?
38 // ===========================
39 // The JSC_OPTIONS() macro below defines a list of all JSC options in use,
40 // along with their types and default values. The options values are actually
41 // realized as an array of Options::Entry elements.
42 //
43 //     Options::initialize() will initialize the array of options values with
44 // the defaults specified in JSC_OPTIONS() below. After that, the values can
45 // be programmatically read and written to using an accessor method with the
46 // same name as the option. For example, the option "useJIT" can be read and
47 // set like so:
48 //
49 //     bool jitIsOn = Options::useJIT();  // Get the option value.
50 //     Options::useJIT() = false;         // Sets the option value.
51 //
52 //     If you want to tweak any of these values programmatically for testing
53 // purposes, you can do so in Options::initialize() after the default values
54 // are set.
55 //
56 //     Alternatively, you can override the default values by specifying
57 // environment variables of the form: JSC_<name of JSC option>.
58 //
59 // Note: Options::initialize() tries to ensure some sanity on the option values
60 // which are set by doing some range checks, and value corrections. These
61 // checks are done after the option values are set. If you alter the option
62 // values after the sanity checks (for your own testing), then you're liable to
63 // ensure that the new values set are sane and reasonable for your own run.
64
65 class OptionRange {
66 private:
67     enum RangeState { Uninitialized, InitError, Normal, Inverted };
68 public:
69     OptionRange& operator= (const int& rhs)
70     { // Only needed for initialization
71         if (!rhs) {
72             m_state = Uninitialized;
73             m_rangeString = 0;
74             m_lowLimit = 0;
75             m_highLimit = 0;
76         }
77         return *this;
78     }
79
80     bool init(const char*);
81     bool isInRange(unsigned);
82     const char* rangeString() const { return (m_state > InitError) ? m_rangeString : "<null>"; }
83
84 private:
85     RangeState m_state;
86     const char* m_rangeString;
87     unsigned m_lowLimit;
88     unsigned m_highLimit;
89 };
90
91 typedef OptionRange optionRange;
92 typedef const char* optionString;
93
94 #define JSC_OPTIONS(v) \
95     v(unsigned, showOptions, 0, "shows JSC options (0 = None, 1 = Overridden only, 2 = All, 3 = Verbose)") \
96     \
97     v(bool, useLLInt,  true, "allows the LLINT to be used if true") \
98     v(bool, useJIT,    true, "allows the baseline JIT to be used if true") \
99     v(bool, useDFGJIT, true, "allows the DFG JIT to be used if true") \
100     v(bool, useRegExpJIT, true, "allows the RegExp JIT to be used if true") \
101     \
102     v(bool, reportMustSucceedExecutableAllocations, false, nullptr) \
103     \
104     v(unsigned, maxPerThreadStackUsage, 4 * MB, nullptr) \
105     v(unsigned, reservedZoneSize, 128 * KB, nullptr) \
106     v(unsigned, errorModeReservedZoneSize, 64 * KB, nullptr) \
107     \
108     v(bool, crashIfCantAllocateJITMemory, false, nullptr) \
109     \
110     v(bool, forceDFGCodeBlockLiveness, false, nullptr) \
111     v(bool, forceICFailure, false, nullptr) \
112     \
113     v(bool, dumpGeneratedBytecodes, false, nullptr) \
114     v(bool, dumpBytecodeLivenessResults, false, nullptr) \
115     v(bool, validateBytecode, false, nullptr) \
116     v(bool, forceDebuggerBytecodeGeneration, false, nullptr) \
117     v(bool, forceProfilerBytecodeGeneration, false, nullptr) \
118     \
119     v(bool, enableFunctionDotArguments, true, nullptr) \
120     \
121     /* showDisassembly implies showDFGDisassembly. */ \
122     v(bool, showDisassembly, false, "dumps disassembly of all JIT compiled code upon compilation") \
123     v(bool, asyncDisassembly, false, nullptr) \
124     v(bool, showDFGDisassembly, false, "dumps disassembly of DFG function upon compilation") \
125     v(bool, showFTLDisassembly, false, "dumps disassembly of FTL function upon compilation") \
126     v(bool, showAllDFGNodes, false, nullptr) \
127     v(optionRange, bytecodeRangeToDFGCompile, 0, "bytecode size range to allow DFG compilation on, e.g. 1:100") \
128     v(optionString, dfgWhitelist, nullptr, "file with list of function signatures to allow DFG compilation on") \
129     v(bool, dumpSourceAtDFGTime, false, "dumps source code of JS function being DFG compiled") \
130     v(bool, dumpBytecodeAtDFGTime, false, "dumps bytecode of JS function being DFG compiled") \
131     v(bool, dumpGraphAfterParsing, false, nullptr) \
132     v(bool, dumpGraphAtEachPhase, false, nullptr) \
133     v(bool, verboseDFGByteCodeParsing, false, nullptr) \
134     v(bool, verboseCompilation, false, nullptr) \
135     v(bool, verboseFTLCompilation, false, nullptr) \
136     v(bool, logCompilationChanges, false, nullptr) \
137     v(bool, printEachOSRExit, false, nullptr) \
138     v(bool, validateGraph, false, nullptr) \
139     v(bool, validateGraphAtEachPhase, false, nullptr) \
140     v(bool, verboseValidationFailure, false, nullptr) \
141     v(bool, verboseOSR, false, nullptr) \
142     v(bool, verboseFTLOSRExit, false, nullptr) \
143     v(bool, verboseCallLink, false, nullptr) \
144     v(bool, verboseCompilationQueue, false, nullptr) \
145     v(bool, reportCompileTimes, false, "dumps JS function signature and the time it took to compile") \
146     v(bool, reportFTLCompileTimes, false, "dumps JS function signature and the time it took to FTL compile") \
147     v(bool, verboseCFA, false, nullptr) \
148     v(bool, verboseFTLToJSThunk, false, nullptr) \
149     v(bool, verboseFTLFailure, false, nullptr) \
150     v(bool, alwaysComputeHash, false, nullptr) \
151     v(bool, testTheFTL, false, nullptr) \
152     v(bool, verboseSanitizeStack, false, nullptr) \
153     v(bool, alwaysDoFullCollection, false, nullptr) \
154     v(bool, eagerlyUpdateTopCallFrame, false, nullptr) \
155     \
156     v(bool, enableOSREntryToDFG, true, nullptr) \
157     v(bool, enableOSREntryToFTL, true, nullptr) \
158     \
159     v(bool, useFTLJIT, true, "allows the FTL JIT to be used if true") \
160     v(bool, useFTLTBAA, true, nullptr) \
161     v(bool, enableLLVMFastISel, false, nullptr) \
162     v(bool, useLLVMSmallCodeModel, false, nullptr) \
163     v(bool, dumpLLVMIR, false, nullptr) \
164     v(bool, validateFTLOSRExitLiveness, false, nullptr) \
165     v(bool, llvmAlwaysFailsBeforeCompile, false, nullptr) \
166     v(bool, llvmAlwaysFailsBeforeLink, false, nullptr) \
167     v(bool, llvmSimpleOpt, true, nullptr) \
168     v(unsigned, llvmBackendOptimizationLevel, 2, nullptr) \
169     v(unsigned, llvmOptimizationLevel, 2, nullptr) \
170     v(unsigned, llvmSizeLevel, 0, nullptr) \
171     v(unsigned, llvmMaxStackSize, 128 * KB, nullptr) \
172     v(bool, llvmDisallowAVX, true, nullptr) \
173     v(bool, ftlCrashes, false, nullptr) /* fool-proof way of checking that you ended up in the FTL. ;-) */\
174     v(bool, ftlCrashesIfCantInitializeLLVM, false, nullptr) \
175     v(bool, clobberAllRegsInFTLICSlowPath, !ASSERT_DISABLED, nullptr) \
176     v(bool, assumeAllRegsInFTLICAreLive, false, nullptr) \
177     v(bool, enableAccessInlining, true, nullptr) \
178     v(bool, enablePolyvariantDevirtualization, true, nullptr) \
179     v(bool, enablePolymorphicAccessInlining, true, nullptr) \
180     v(bool, enablePolymorphicCallInlining, true, nullptr) \
181     v(unsigned, maxPolymorphicCallVariantListSize, 15, nullptr) \
182     v(unsigned, maxPolymorphicCallVariantListSizeForTopTier, 5, nullptr) \
183     v(unsigned, maxPolymorphicCallVariantsForInlining, 5, nullptr) \
184     v(unsigned, frequentCallThreshold, 2, nullptr) \
185     v(double, minimumCallToKnownRate, 0.51, nullptr) \
186     v(bool, optimizeNativeCalls, false, nullptr) \
187     v(bool, enableMovHintRemoval, true, nullptr) \
188     v(bool, enableObjectAllocationSinking, true, nullptr) \
189     \
190     v(bool, enableConcurrentJIT, true, "allows the DFG / FTL compilation in threads other than the executing JS thread") \
191     v(unsigned, numberOfDFGCompilerThreads, computeNumberOfWorkerThreads(2, 2) - 1, nullptr) \
192     v(unsigned, numberOfFTLCompilerThreads, computeNumberOfWorkerThreads(8, 2) - 1, nullptr) \
193     v(int32, priorityDeltaOfDFGCompilerThreads, computePriorityDeltaOfWorkerThreads(-1, 0), nullptr) \
194     v(int32, priorityDeltaOfFTLCompilerThreads, computePriorityDeltaOfWorkerThreads(-2, 0), nullptr) \
195     \
196     v(bool, enableProfiler, false, nullptr) \
197     \
198     v(bool, forceUDis86Disassembler, false, nullptr) \
199     v(bool, forceLLVMDisassembler, false, nullptr) \
200     \
201     v(bool, enableArchitectureSpecificOptimizations, true, nullptr) \
202     \
203     v(bool, breakOnThrow, false, nullptr) \
204     \
205     v(unsigned, maximumOptimizationCandidateInstructionCount, 100000, nullptr) \
206     \
207     v(unsigned, maximumFunctionForCallInlineCandidateInstructionCount, 250, nullptr) \
208     v(unsigned, maximumFunctionForClosureCallInlineCandidateInstructionCount, 180, nullptr) \
209     v(unsigned, maximumFunctionForConstructInlineCandidateInstructionCount, 180, nullptr) \
210     \
211     v(unsigned, maximumFTLCandidateInstructionCount, 20000, nullptr) \
212     \
213     v(double, exitSitePowerForInlineCost, 0.5, nullptr) \
214     \
215     /* Depth of inline stack, so 1 = no inlining, 2 = one level, etc. */ \
216     v(unsigned, maximumInliningDepth, 5, "maximum allowed inlining depth.  Depth of 1 means no inlining") \
217     v(unsigned, maximumInliningRecursion, 2, nullptr) \
218     \
219     v(unsigned, maximumLLVMInstructionCountForNativeInlining, 80, nullptr) \
220     \
221     /* Maximum size of a caller for enabling inlining. This is purely to protect us */\
222     /* from super long compiles that take a lot of memory. */\
223     v(unsigned, maximumInliningCallerSize, 10000, nullptr) \
224     \
225     v(unsigned, maximumVarargsForInlining, 100, nullptr) \
226     \
227     v(bool, enablePolyvariantCallInlining, true, nullptr) \
228     v(bool, enablePolyvariantByIdInlining, true, nullptr) \
229     \
230     v(unsigned, maximumBinaryStringSwitchCaseLength, 50, nullptr) \
231     v(unsigned, maximumBinaryStringSwitchTotalLength, 2000, nullptr) \
232     \
233     v(double, jitPolicyScale, 1.0, "scale JIT thresholds to this specified ratio between 0.0 (compile ASAP) and 1.0 (compile like normal).") \
234     v(bool, forceEagerCompilation, false, nullptr) \
235     v(int32, thresholdForJITAfterWarmUp, 500, nullptr) \
236     v(int32, thresholdForJITSoon, 100, nullptr) \
237     \
238     v(int32, thresholdForOptimizeAfterWarmUp, 1000, nullptr) \
239     v(int32, thresholdForOptimizeAfterLongWarmUp, 1000, nullptr) \
240     v(int32, thresholdForOptimizeSoon, 1000, nullptr) \
241     v(int32, executionCounterIncrementForLoop, 1, nullptr) \
242     v(int32, executionCounterIncrementForEntry, 15, nullptr) \
243     \
244     v(int32, thresholdForFTLOptimizeAfterWarmUp, 100000, nullptr) \
245     v(int32, thresholdForFTLOptimizeSoon, 1000, nullptr) \
246     v(int32, ftlTierUpCounterIncrementForLoop, 1, nullptr) \
247     v(int32, ftlTierUpCounterIncrementForReturn, 15, nullptr) \
248     v(unsigned, ftlOSREntryFailureCountForReoptimization, 15, nullptr) \
249     v(unsigned, ftlOSREntryRetryThreshold, 100, nullptr) \
250     \
251     v(int32, evalThresholdMultiplier, 10, nullptr) \
252     v(unsigned, maximumEvalCacheableSourceLength, 256, nullptr) \
253     \
254     v(bool, randomizeExecutionCountsBetweenCheckpoints, false, nullptr) \
255     v(int32, maximumExecutionCountsBetweenCheckpointsForBaseline, 1000, nullptr) \
256     v(int32, maximumExecutionCountsBetweenCheckpointsForUpperTiers, 50000, nullptr) \
257     \
258     v(unsigned, likelyToTakeSlowCaseMinimumCount, 20, nullptr) \
259     v(unsigned, couldTakeSlowCaseMinimumCount, 10, nullptr) \
260     \
261     v(unsigned, osrExitCountForReoptimization, 100, nullptr) \
262     v(unsigned, osrExitCountForReoptimizationFromLoop, 5, nullptr) \
263     \
264     v(unsigned, reoptimizationRetryCounterMax, 0, nullptr)  \
265     \
266     v(unsigned, minimumOptimizationDelay, 1, nullptr) \
267     v(unsigned, maximumOptimizationDelay, 5, nullptr) \
268     v(double, desiredProfileLivenessRate, 0.75, nullptr) \
269     v(double, desiredProfileFullnessRate, 0.35, nullptr) \
270     \
271     v(double, doubleVoteRatioForDoubleFormat, 2, nullptr) \
272     v(double, structureCheckVoteRatioForHoisting, 1, nullptr) \
273     v(double, checkArrayVoteRatioForHoisting, 1, nullptr) \
274     \
275     v(unsigned, minimumNumberOfScansBetweenRebalance, 100, nullptr) \
276     v(unsigned, numberOfGCMarkers, computeNumberOfGCMarkers(7), nullptr) \
277     v(unsigned, opaqueRootMergeThreshold, 1000, nullptr) \
278     v(double, minHeapUtilization, 0.8, nullptr) \
279     v(double, minCopiedBlockUtilization, 0.9, nullptr) \
280     v(double, minMarkedBlockUtilization, 0.9, nullptr) \
281     v(unsigned, slowPathAllocsBetweenGCs, 0, "force a GC on every Nth slow path alloc, where N is specified by this option") \
282     \
283     v(double, percentCPUPerMBForFullTimer, 0.0003125, nullptr) \
284     v(double, percentCPUPerMBForEdenTimer, 0.0025, nullptr) \
285     v(double, collectionTimerMaxPercentCPU, 0.05, nullptr) \
286     \
287     v(bool, forceWeakRandomSeed, false, nullptr) \
288     v(unsigned, forcedWeakRandomSeed, 0, nullptr) \
289     \
290     v(bool, useZombieMode, false, "debugging option to scribble over dead objects with 0xdeadbeef") \
291     v(bool, objectsAreImmortal, false, "debugging option to keep all objects alive forever") \
292     v(bool, showObjectStatistics, false, nullptr) \
293     \
294     v(gcLogLevel, logGC, GCLogging::None, "debugging option to log GC activity (0 = None, 1 = Basic, 2 = Verbose)") \
295     v(bool, disableGC, false, nullptr) \
296     v(unsigned, gcMaxHeapSize, 0, nullptr) \
297     v(unsigned, forceRAMSize, 0, nullptr) \
298     v(bool, recordGCPauseTimes, false, nullptr) \
299     v(bool, logHeapStatisticsAtExit, false, nullptr) \
300     v(bool, enableTypeProfiler, false, nullptr) \
301     v(bool, enableControlFlowProfiler, false, nullptr) \
302     \
303     v(bool, verifyHeap, false, nullptr) \
304     v(unsigned, numberOfGCCyclesToRecordForVerification, 3, nullptr) \
305     \
306     v(bool, enableExceptionFuzz, false, nullptr) \
307     v(unsigned, fireExceptionFuzzAt, 0, nullptr) \
308     \
309     v(bool, enableExecutableAllocationFuzz, false, nullptr) \
310     v(unsigned, fireExecutableAllocationFuzzAt, 0, nullptr) \
311     v(unsigned, fireExecutableAllocationFuzzAtOrAfter, 0, nullptr) \
312     v(bool, verboseExecutableAllocationFuzz, false, nullptr) \
313     \
314     v(bool, enableDollarVM, false, "installs the $vm debugging tool in global objects") \
315     v(optionString, functionOverrides, nullptr, "file with debugging overrides for function bodies") \
316
317 class Options {
318 public:
319     enum class DumpLevel {
320         None = 0,
321         Overridden,
322         All,
323         Verbose
324     };
325     
326     // This typedef is to allow us to eliminate the '_' in the field name in
327     // union inside Entry. This is needed to keep the style checker happy.
328     typedef int32_t int32;
329
330     // Declare the option IDs:
331     enum OptionID {
332 #define FOR_EACH_OPTION(type_, name_, defaultValue_, description_) \
333         name_##ID,
334         JSC_OPTIONS(FOR_EACH_OPTION)
335 #undef FOR_EACH_OPTION
336         numberOfOptions
337     };
338
339     enum class Type {
340         boolType,
341         unsignedType,
342         doubleType,
343         int32Type,
344         optionRangeType,
345         optionStringType,
346         gcLogLevelType,
347     };
348
349     static void initialize();
350
351     // Parses a single command line option in the format "<optionName>=<value>"
352     // (no spaces allowed) and set the specified option if appropriate.
353     JS_EXPORT_PRIVATE static bool setOption(const char* arg);
354     JS_EXPORT_PRIVATE static void dumpAllOptions(DumpLevel, const char* title = nullptr, FILE* stream = stdout);
355     static void dumpOption(DumpLevel, OptionID, FILE* stream = stdout, const char* header = "", const char* footer = "");
356     JS_EXPORT_PRIVATE static void ensureOptionsAreCoherent();
357
358     // Declare accessors for each option:
359 #define FOR_EACH_OPTION(type_, name_, defaultValue_, description_) \
360     ALWAYS_INLINE static type_& name_() { return s_options[name_##ID].type_##Val; } \
361     ALWAYS_INLINE static type_& name_##Default() { return s_defaultOptions[name_##ID].type_##Val; }
362
363     JSC_OPTIONS(FOR_EACH_OPTION)
364 #undef FOR_EACH_OPTION
365
366 private:
367     // For storing for an option value:
368     union Entry {
369         bool boolVal;
370         unsigned unsignedVal;
371         double doubleVal;
372         int32 int32Val;
373         OptionRange optionRangeVal;
374         const char* optionStringVal;
375         GCLogging::Level gcLogLevelVal;
376     };
377
378     // For storing constant meta data about each option:
379     struct EntryInfo {
380         const char* name;
381         const char* description;
382         Type type;
383     };
384
385     Options();
386
387     // Declare the singleton instance of the options store:
388     JS_EXPORTDATA static Entry s_options[numberOfOptions];
389     static Entry s_defaultOptions[numberOfOptions];
390     static const EntryInfo s_optionsInfo[numberOfOptions];
391
392     friend class Option;
393 };
394
395 class Option {
396 public:
397     Option(Options::OptionID id)
398         : m_id(id)
399         , m_entry(Options::s_options[m_id])
400     {
401     }
402     
403     void dump(FILE*) const;
404     bool operator==(const Option& other) const;
405     bool operator!=(const Option& other) const { return !(*this == other); }
406     
407     const char* name() const;
408     const char* description() const;
409     Options::Type type() const;
410     bool isOverridden() const;
411     const Option defaultOption() const;
412     
413     bool& boolVal();
414     unsigned& unsignedVal();
415     double& doubleVal();
416     int32_t& int32Val();
417     OptionRange optionRangeVal();
418     const char* optionStringVal();
419     GCLogging::Level& gcLogLevelVal();
420     
421 private:
422     // Only used for constructing default Options.
423     Option(Options::OptionID id, Options::Entry& entry)
424         : m_id(id)
425         , m_entry(entry)
426     {
427     }
428     
429     Options::OptionID m_id;
430     Options::Entry& m_entry;
431 };
432
433 inline const char* Option::name() const
434 {
435     return Options::s_optionsInfo[m_id].name;
436 }
437
438 inline const char* Option::description() const
439 {
440     return Options::s_optionsInfo[m_id].description;
441 }
442
443 inline Options::Type Option::type() const
444 {
445     return Options::s_optionsInfo[m_id].type;
446 }
447
448 inline bool Option::isOverridden() const
449 {
450     return *this != defaultOption();
451 }
452
453 inline const Option Option::defaultOption() const
454 {
455     return Option(m_id, Options::s_defaultOptions[m_id]);
456 }
457
458 inline bool& Option::boolVal()
459 {
460     return m_entry.boolVal;
461 }
462
463 inline unsigned& Option::unsignedVal()
464 {
465     return m_entry.unsignedVal;
466 }
467
468 inline double& Option::doubleVal()
469 {
470     return m_entry.doubleVal;
471 }
472
473 inline int32_t& Option::int32Val()
474 {
475     return m_entry.int32Val;
476 }
477
478 inline OptionRange Option::optionRangeVal()
479 {
480     return m_entry.optionRangeVal;
481 }
482
483 inline const char* Option::optionStringVal()
484 {
485     return m_entry.optionStringVal;
486 }
487
488 inline GCLogging::Level& Option::gcLogLevelVal()
489 {
490     return m_entry.gcLogLevelVal;
491 }
492
493 } // namespace JSC
494
495 #endif // Options_h