237c0e7522582dd3e47ba0c7d81cbcb26dbdec51
[WebKit-https.git] / Source / JavaScriptCore / bytecode / ExecutionCounter.cpp
1 /*
2  * Copyright (C) 2012, 2014, 2016 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 #include "config.h"
27 #include "ExecutionCounter.h"
28
29 #include "CodeBlock.h"
30 #include "ExecutableAllocator.h"
31 #include "JSCInlines.h"
32 #include "VMInlines.h"
33 #include <wtf/StringExtras.h>
34
35 namespace JSC {
36
37 template<CountingVariant countingVariant>
38 ExecutionCounter<countingVariant>::ExecutionCounter()
39 {
40     reset();
41 }
42
43 template<CountingVariant countingVariant>
44 void ExecutionCounter<countingVariant>::forceSlowPathConcurrently()
45 {
46     m_counter = 0;
47 }
48
49 template<CountingVariant countingVariant>
50 bool ExecutionCounter<countingVariant>::checkIfThresholdCrossedAndSet(CodeBlock* codeBlock)
51 {
52     if (hasCrossedThreshold(codeBlock))
53         return true;
54     
55     if (setThreshold(codeBlock))
56         return true;
57     
58     return false;
59 }
60
61 template<CountingVariant countingVariant>
62 void ExecutionCounter<countingVariant>::setNewThreshold(int32_t threshold, CodeBlock* codeBlock)
63 {
64     reset();
65     m_activeThreshold = threshold;
66     setThreshold(codeBlock);
67 }
68
69 template<CountingVariant countingVariant>
70 void ExecutionCounter<countingVariant>::deferIndefinitely()
71 {
72     m_totalCount = 0;
73     m_activeThreshold = std::numeric_limits<int32_t>::max();
74     m_counter = std::numeric_limits<int32_t>::min();
75 }
76
77 double applyMemoryUsageHeuristics(int32_t value, CodeBlock* codeBlock)
78 {
79 #if ENABLE(JIT)
80     double multiplier =
81         ExecutableAllocator::memoryPressureMultiplier(
82             codeBlock->baselineAlternative()->predictedMachineCodeSize());
83 #else
84     // This code path will probably not be taken, but if it is, we fake it.
85     double multiplier = 1.0;
86     UNUSED_PARAM(codeBlock);
87 #endif
88     ASSERT(multiplier >= 1.0);
89     return multiplier * value;
90 }
91
92 int32_t applyMemoryUsageHeuristicsAndConvertToInt(int32_t value, CodeBlock* codeBlock)
93 {
94     double doubleResult = applyMemoryUsageHeuristics(value, codeBlock);
95     
96     ASSERT(doubleResult >= 0);
97     
98     if (doubleResult > std::numeric_limits<int32_t>::max())
99         return std::numeric_limits<int32_t>::max();
100     
101     return static_cast<int32_t>(doubleResult);
102 }
103
104 template<CountingVariant countingVariant>
105 bool ExecutionCounter<countingVariant>::hasCrossedThreshold(CodeBlock* codeBlock) const
106 {
107     // This checks if the current count rounded up to the threshold we were targeting.
108     // For example, if we are using half of available executable memory and have
109     // m_activeThreshold = 1000, applyMemoryUsageHeuristics(m_activeThreshold) will be
110     // 2000, but we will pretend as if the threshold was crossed if we reach 2000 -
111     // 1000 / 2, or 1500. The reasoning here is that we want to avoid thrashing. If
112     // this method returns false, then the JIT's threshold for when it will again call
113     // into the slow path (which will call this method a second time) will be set
114     // according to the difference between the current count and the target count
115     // according to *current* memory usage. But by the time we call into this again, we
116     // may have JIT'ed more code, and so the target count will increase slightly. This
117     // may lead to a repeating pattern where the target count is slightly incremented,
118     // the JIT immediately matches that increase, calls into the slow path again, and
119     // again the target count is slightly incremented. Instead of having this vicious
120     // cycle, we declare victory a bit early if the difference between the current
121     // total and our target according to memory heuristics is small. Our definition of
122     // small is arbitrarily picked to be half of the original threshold (i.e.
123     // m_activeThreshold).
124     
125     double modifiedThreshold = applyMemoryUsageHeuristics(m_activeThreshold, codeBlock);
126     
127     double actualCount = static_cast<double>(m_totalCount) + m_counter;
128     double desiredCount = modifiedThreshold - static_cast<double>(
129         std::min(m_activeThreshold, maximumExecutionCountsBetweenCheckpoints())) / 2;
130     
131     bool result = actualCount >= desiredCount;
132     
133     CODEBLOCK_LOG_EVENT(codeBlock, "thresholdCheck", ("activeThreshold = ", m_activeThreshold, ", modifiedThreshold = ", modifiedThreshold, ", actualCount = ", actualCount, ", desiredCount = ", desiredCount));
134     
135     return result;
136 }
137
138 template<CountingVariant countingVariant>
139 bool ExecutionCounter<countingVariant>::setThreshold(CodeBlock* codeBlock)
140 {
141     if (m_activeThreshold == std::numeric_limits<int32_t>::max()) {
142         deferIndefinitely();
143         return false;
144     }
145         
146     // Compute the true total count.
147     double trueTotalCount = count();
148     
149     // Correct the threshold for current memory usage.
150     double threshold = applyMemoryUsageHeuristics(m_activeThreshold, codeBlock);
151         
152     // Threshold must be non-negative and not NaN.
153     ASSERT(threshold >= 0);
154         
155     // Adjust the threshold according to the number of executions we have already
156     // seen. This shouldn't go negative, but it might, because of round-off errors.
157     threshold -= trueTotalCount;
158         
159     if (threshold <= 0) {
160         m_counter = 0;
161         m_totalCount = trueTotalCount;
162         return true;
163     }
164
165     threshold = clippedThreshold(codeBlock->globalObject(), threshold);
166     
167     m_counter = static_cast<int32_t>(-threshold);
168         
169     m_totalCount = trueTotalCount + threshold;
170         
171     return false;
172 }
173
174 template<CountingVariant countingVariant>
175 void ExecutionCounter<countingVariant>::reset()
176 {
177     m_counter = 0;
178     m_totalCount = 0;
179     m_activeThreshold = 0;
180 }
181
182 template<CountingVariant countingVariant>
183 void ExecutionCounter<countingVariant>::dump(PrintStream& out) const
184 {
185     out.printf("%lf/%lf, %d", count(), static_cast<double>(m_activeThreshold), m_counter);
186 }
187
188 template class ExecutionCounter<CountingForBaseline>;
189 template class ExecutionCounter<CountingForUpperTiers>;
190
191 } // namespace JSC
192