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