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