]>
git.saurik.com Git - apple/javascriptcore.git/blob - bytecode/ExecutionCounter.cpp
2 * Copyright (C) 2012 Apple Inc. All rights reserved.
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
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.
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.
27 #include "ExecutionCounter.h"
29 #include "CodeBlock.h"
30 #include "ExecutableAllocator.h"
34 ExecutionCounter::ExecutionCounter()
39 bool ExecutionCounter::checkIfThresholdCrossedAndSet(CodeBlock
* codeBlock
)
41 if (hasCrossedThreshold(codeBlock
))
44 if (setThreshold(codeBlock
))
50 void ExecutionCounter::setNewThreshold(int32_t threshold
, CodeBlock
* codeBlock
)
53 m_activeThreshold
= threshold
;
54 setThreshold(codeBlock
);
57 void ExecutionCounter::deferIndefinitely()
60 m_activeThreshold
= std::numeric_limits
<int32_t>::max();
61 m_counter
= std::numeric_limits
<int32_t>::min();
64 double ExecutionCounter::applyMemoryUsageHeuristics(int32_t value
, CodeBlock
* codeBlock
)
68 ExecutableAllocator::memoryPressureMultiplier(
69 codeBlock
->predictedMachineCodeSize());
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
);
75 ASSERT(multiplier
>= 1.0);
76 return multiplier
* value
;
79 int32_t ExecutionCounter::applyMemoryUsageHeuristicsAndConvertToInt(
80 int32_t value
, CodeBlock
* codeBlock
)
82 double doubleResult
= applyMemoryUsageHeuristics(value
, codeBlock
);
84 ASSERT(doubleResult
>= 0);
86 if (doubleResult
> std::numeric_limits
<int32_t>::max())
87 return std::numeric_limits
<int32_t>::max();
89 return static_cast<int32_t>(doubleResult
);
92 bool ExecutionCounter::hasCrossedThreshold(CodeBlock
* codeBlock
) const
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).
112 double modifiedThreshold
= applyMemoryUsageHeuristics(m_activeThreshold
, codeBlock
);
114 return static_cast<double>(m_totalCount
) + m_counter
>=
115 modifiedThreshold
- static_cast<double>(m_activeThreshold
) / 2;
118 bool ExecutionCounter::setThreshold(CodeBlock
* codeBlock
)
120 if (m_activeThreshold
== std::numeric_limits
<int32_t>::max()) {
125 ASSERT(!hasCrossedThreshold(codeBlock
));
127 // Compute the true total count.
128 double trueTotalCount
= static_cast<double>(m_totalCount
) + m_counter
;
130 // Correct the threshold for current memory usage.
131 double threshold
= applyMemoryUsageHeuristics(m_activeThreshold
, codeBlock
);
133 // Threshold must be non-negative and not NaN.
134 ASSERT(threshold
>= 0);
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
;
140 if (threshold
<= 0) {
142 m_totalCount
= trueTotalCount
;
146 if (threshold
> std::numeric_limits
<int32_t>::max())
147 threshold
= std::numeric_limits
<int32_t>::max();
149 m_counter
= static_cast<int32_t>(-threshold
);
151 m_totalCount
= trueTotalCount
+ threshold
;
156 void ExecutionCounter::reset()
160 m_activeThreshold
= 0;