9e7eb5230de6ce83a9471d1e862fde206efe609e
[WebKit-https.git] / Source / JavaScriptCore / runtime / Options.h
1 /*
2  * Copyright (C) 2011, 2012, 2013, 2014 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() { 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(bool, useLLInt,  true) \
96     v(bool, useJIT,    true) \
97     v(bool, useDFGJIT, true) \
98     v(bool, useRegExpJIT, true) \
99     \
100     v(unsigned, maxPerThreadStackUsage, 4 * MB) \
101     v(unsigned, reservedZoneSize, 128 * KB) \
102     v(unsigned, errorModeReservedZoneSize, 64 * KB) \
103     \
104     v(bool, crashIfCantAllocateJITMemory, false) \
105     \
106     v(bool, forceDFGCodeBlockLiveness, false) \
107     v(bool, forceICFailure, false) \
108     \
109     v(bool, dumpGeneratedBytecodes, false) \
110     v(bool, dumpBytecodeLivenessResults, false) \
111     v(bool, validateBytecode, false) \
112     v(bool, forceDebuggerBytecodeGeneration, false) \
113     v(bool, forceProfilerBytecodeGeneration, false) \
114     \
115     v(bool, enableFunctionDotArguments, false) \
116     \
117     /* showDisassembly implies showDFGDisassembly. */ \
118     v(bool, showDisassembly, false) \
119     v(bool, showDFGDisassembly, false) \
120     v(bool, showFTLDisassembly, false) \
121     v(bool, showAllDFGNodes, false) \
122     v(optionRange, bytecodeRangeToDFGCompile, 0) \
123     v(optionString, dfgFunctionWhitelistFile, nullptr) \
124     v(bool, dumpBytecodeAtDFGTime, false) \
125     v(bool, dumpGraphAtEachPhase, false) \
126     v(bool, verboseDFGByteCodeParsing, false) \
127     v(bool, verboseCompilation, false) \
128     v(bool, verboseFTLCompilation, false) \
129     v(bool, logCompilationChanges, false) \
130     v(bool, printEachOSRExit, false) \
131     v(bool, validateGraph, false) \
132     v(bool, validateGraphAtEachPhase, false) \
133     v(bool, verboseValidationFailure, false) \
134     v(bool, verboseOSR, false) \
135     v(bool, verboseFTLOSRExit, false) \
136     v(bool, verboseCallLink, false) \
137     v(bool, verboseCompilationQueue, false) \
138     v(bool, reportCompileTimes, false) \
139     v(bool, reportFTLCompileTimes, false) \
140     v(bool, verboseCFA, false) \
141     v(bool, verboseFTLToJSThunk, false) \
142     v(bool, verboseFTLFailure, false) \
143     v(bool, alwaysComputeHash, false) \
144     v(bool, testTheFTL, false) \
145     v(bool, verboseSanitizeStack, false) \
146     v(bool, alwaysDoFullCollection, false) \
147     v(bool, eagerlyUpdateTopCallFrame, false) \
148     \
149     v(bool, enableOSREntryToDFG, true) \
150     v(bool, enableOSREntryToFTL, true) \
151     \
152     v(bool, useFTLJIT, true) \
153     v(bool, enableExperimentalFTLCoverage, false) \
154     v(bool, useFTLTBAA, true) \
155     v(bool, enableLLVMFastISel, false) \
156     v(bool, useLLVMSmallCodeModel, false) \
157     v(bool, dumpLLVMIR, false) \
158     v(bool, validateFTLOSRExitLiveness, false) \
159     v(bool, llvmAlwaysFailsBeforeCompile, false) \
160     v(bool, llvmAlwaysFailsBeforeLink, false) \
161     v(bool, llvmSimpleOpt, true) \
162     v(unsigned, llvmBackendOptimizationLevel, 2) \
163     v(unsigned, llvmOptimizationLevel, 2) \
164     v(unsigned, llvmSizeLevel, 0) \
165     v(unsigned, llvmMaxStackSize, 128 * KB) \
166     v(bool, llvmDisallowAVX, true) \
167     v(bool, ftlCrashes, false) /* fool-proof way of checking that you ended up in the FTL. ;-) */\
168     v(bool, clobberAllRegsInFTLICSlowPath, !ASSERT_DISABLED) \
169     v(bool, assumeAllRegsInFTLICAreLive, false) \
170     v(bool, enableAccessInlining, true) \
171     v(bool, enablePolyvariantDevirtualization, true) \
172     v(bool, enablePolymorphicAccessInlining, true) \
173     v(bool, enablePolymorphicCallInlining, true) \
174     v(bool, callStatusShouldUseCallEdgeProfile, true) \
175     v(bool, callEdgeProfileReallyProcessesLog, true) \
176     v(bool, baselineDoesCallEdgeProfiling, false) \
177     v(bool, dfgDoesCallEdgeProfiling, true) \
178     v(bool, enableCallEdgeProfiling, true) \
179     v(unsigned, frequentCallThreshold, 2) \
180     v(bool, optimizeNativeCalls, false) \
181     \
182     v(bool, enableConcurrentJIT, true) \
183     v(unsigned, numberOfDFGCompilerThreads, computeNumberOfWorkerThreads(2, 2) - 1) \
184     v(unsigned, numberOfFTLCompilerThreads, computeNumberOfWorkerThreads(8, 2) - 1) \
185     v(int32, priorityDeltaOfDFGCompilerThreads, computePriorityDeltaOfWorkerThreads(-1, 0)) \
186     v(int32, priorityDeltaOfFTLCompilerThreads, computePriorityDeltaOfWorkerThreads(-2, 0)) \
187     \
188     v(bool, enableProfiler, false) \
189     \
190     v(bool, forceUDis86Disassembler, false) \
191     v(bool, forceLLVMDisassembler, false) \
192     \
193     v(bool, enableArchitectureSpecificOptimizations, true) \
194     \
195     v(bool, breakOnThrow, false) \
196     \
197     v(unsigned, maximumOptimizationCandidateInstructionCount, 100000) \
198     \
199     v(unsigned, maximumFunctionForCallInlineCandidateInstructionCount, 180) \
200     v(unsigned, maximumFunctionForClosureCallInlineCandidateInstructionCount, 100) \
201     v(unsigned, maximumFunctionForConstructInlineCandidateInstructionCount, 100) \
202     \
203     v(unsigned, maximumFTLCandidateInstructionCount, 20000) \
204     \
205     /* Depth of inline stack, so 1 = no inlining, 2 = one level, etc. */ \
206     v(unsigned, maximumInliningDepth, 5) \
207     v(unsigned, maximumInliningRecursion, 2) \
208     v(unsigned, maximumInliningDepthForMustInline, 7) \
209     v(unsigned, maximumInliningRecursionForMustInline, 3) \
210     \
211     v(unsigned, maximumLLVMInstructionCountForNativeInlining, 80) \
212     \
213     /* Maximum size of a caller for enabling inlining. This is purely to protect us */\
214     /* from super long compiles that take a lot of memory. */\
215     v(unsigned, maximumInliningCallerSize, 10000) \
216     \
217     v(bool, enablePolyvariantCallInlining, true) \
218     v(bool, enablePolyvariantByIdInlining, true) \
219     \
220     v(unsigned, maximumBinaryStringSwitchCaseLength, 50) \
221     v(unsigned, maximumBinaryStringSwitchTotalLength, 2000) \
222     \
223     v(int32, thresholdForJITAfterWarmUp, 500) \
224     v(int32, thresholdForJITSoon, 100) \
225     \
226     v(int32, thresholdForOptimizeAfterWarmUp, 1000) \
227     v(int32, thresholdForOptimizeAfterLongWarmUp, 1000) \
228     v(int32, thresholdForOptimizeSoon, 1000) \
229     v(int32, executionCounterIncrementForLoop, 1) \
230     v(int32, executionCounterIncrementForEntry, 15) \
231     \
232     v(int32, thresholdForFTLOptimizeAfterWarmUp, 100000) \
233     v(int32, thresholdForFTLOptimizeSoon, 1000) \
234     v(int32, ftlTierUpCounterIncrementForLoop, 1) \
235     v(int32, ftlTierUpCounterIncrementForReturn, 15) \
236     v(unsigned, ftlOSREntryFailureCountForReoptimization, 15) \
237     v(unsigned, ftlOSREntryRetryThreshold, 100) \
238     \
239     v(int32, evalThresholdMultiplier, 10) \
240     \
241     v(bool, randomizeExecutionCountsBetweenCheckpoints, false) \
242     v(int32, maximumExecutionCountsBetweenCheckpointsForBaseline, 1000) \
243     v(int32, maximumExecutionCountsBetweenCheckpointsForUpperTiers, 50000) \
244     \
245     v(unsigned, likelyToTakeSlowCaseMinimumCount, 100) \
246     v(unsigned, couldTakeSlowCaseMinimumCount, 10) \
247     \
248     v(unsigned, osrExitCountForReoptimization, 100) \
249     v(unsigned, osrExitCountForReoptimizationFromLoop, 5) \
250     \
251     v(unsigned, reoptimizationRetryCounterMax, 0)  \
252     v(unsigned, reoptimizationRetryCounterStep, 1) \
253     \
254     v(unsigned, minimumOptimizationDelay, 1) \
255     v(unsigned, maximumOptimizationDelay, 5) \
256     v(double, desiredProfileLivenessRate, 0.75) \
257     v(double, desiredProfileFullnessRate, 0.35) \
258     \
259     v(double, doubleVoteRatioForDoubleFormat, 2) \
260     v(double, structureCheckVoteRatioForHoisting, 1) \
261     v(double, checkArrayVoteRatioForHoisting, 1) \
262     \
263     v(unsigned, minimumNumberOfScansBetweenRebalance, 100) \
264     v(unsigned, numberOfGCMarkers, computeNumberOfGCMarkers(7)) \
265     v(unsigned, opaqueRootMergeThreshold, 1000) \
266     v(double, minHeapUtilization, 0.8) \
267     v(double, minCopiedBlockUtilization, 0.9) \
268     v(double, minMarkedBlockUtilization, 0.9) \
269     v(unsigned, slowPathAllocsBetweenGCs, 0) \
270     \
271     v(double, percentCPUPerMBForFullTimer, 0.0003125) \
272     v(double, percentCPUPerMBForEdenTimer, 0.0025) \
273     v(double, collectionTimerMaxPercentCPU, 0.05) \
274     \
275     v(bool, forceWeakRandomSeed, false) \
276     v(unsigned, forcedWeakRandomSeed, 0) \
277     \
278     v(bool, useZombieMode, false) \
279     v(bool, objectsAreImmortal, false) \
280     v(bool, showObjectStatistics, false) \
281     \
282     v(gcLogLevel, logGC, GCLogging::None) \
283     v(bool, disableGC, false) \
284     v(unsigned, gcMaxHeapSize, 0) \
285     v(bool, recordGCPauseTimes, false) \
286     v(bool, logHeapStatisticsAtExit, false) \
287     v(bool, enableTypeProfiler, false) \
288     \
289     v(bool, enableExceptionFuzz, false) \
290     v(unsigned, fireExceptionFuzzAt, 0)
291
292 class Options {
293 public:
294     // This typedef is to allow us to eliminate the '_' in the field name in
295     // union inside Entry. This is needed to keep the style checker happy.
296     typedef int32_t int32;
297
298     // Declare the option IDs:
299     enum OptionID {
300 #define FOR_EACH_OPTION(type_, name_, defaultValue_) \
301         OPT_##name_,
302         JSC_OPTIONS(FOR_EACH_OPTION)
303 #undef FOR_EACH_OPTION
304         numberOfOptions
305     };
306
307
308     static void initialize();
309
310     // Parses a single command line option in the format "<optionName>=<value>"
311     // (no spaces allowed) and set the specified option if appropriate.
312     JS_EXPORT_PRIVATE static bool setOption(const char* arg);
313     JS_EXPORT_PRIVATE static void dumpAllOptions(FILE* stream = stdout);
314     static void dumpOption(OptionID id, FILE* stream = stdout, const char* header = "", const char* footer = "");
315
316     // Declare accessors for each option:
317 #define FOR_EACH_OPTION(type_, name_, defaultValue_) \
318     ALWAYS_INLINE static type_& name_() { return s_options[OPT_##name_].u.type_##Val; } \
319     static bool name_##WasOverridden() { return s_options[OPT_##name_].didOverride; }
320
321     JSC_OPTIONS(FOR_EACH_OPTION)
322 #undef FOR_EACH_OPTION
323
324 private:
325     enum EntryType {
326         boolType,
327         unsignedType,
328         doubleType,
329         int32Type,
330         optionRangeType,
331         optionStringType,
332         gcLogLevelType,
333     };
334
335     // For storing for an option value:
336     struct Entry {
337         union {
338             bool boolVal;
339             unsigned unsignedVal;
340             double doubleVal;
341             int32 int32Val;
342             OptionRange optionRangeVal;
343             const char* optionStringVal;
344             GCLogging::Level gcLogLevelVal;
345         } u;
346         bool didOverride;
347     };
348
349     // For storing constant meta data about each option:
350     struct EntryInfo {
351         const char* name;
352         EntryType type;
353     };
354
355     Options();
356
357     // Declare the options:
358 #define FOR_EACH_OPTION(type_, name_, defaultValue_) \
359     type_ m_##name_;
360     JSC_OPTIONS(FOR_EACH_OPTION)
361 #undef FOR_EACH_OPTION
362
363     // Declare the singleton instance of the options store:
364     JS_EXPORTDATA static Entry s_options[numberOfOptions];
365     static const EntryInfo s_optionsInfo[numberOfOptions];
366 };
367
368 } // namespace JSC
369
370 #endif // Options_h