[WTF] Use m_suspendCount instead of m_suspended flag in Thread
[WebKit-https.git] / Source / JavaScriptCore / heap / GCActivityCallback.cpp
1 /*
2  * Copyright (C) 2010-2017 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  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer. 
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution. 
13  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission. 
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #include "config.h"
30 #include "GCActivityCallback.h"
31
32 #include "HeapInlines.h"
33 #include "JSLock.h"
34 #include "JSObject.h"
35 #include "VM.h"
36
37 namespace JSC {
38
39 bool GCActivityCallback::s_shouldCreateGCTimer = true;
40
41 const double timerSlop = 2.0; // Fudge factor to avoid performance cost of resetting timer.
42
43 GCActivityCallback::GCActivityCallback(Heap* heap)
44     : GCActivityCallback(heap->vm())
45 {
46 }
47
48 void GCActivityCallback::doWork()
49 {
50     Heap* heap = &m_vm->heap;
51     if (!isEnabled())
52         return;
53     
54     JSLockHolder locker(m_vm);
55     if (heap->isDeferred()) {
56         scheduleTimer(0_s);
57         return;
58     }
59
60     doCollection();
61 }
62
63 #if USE(CF)
64 void GCActivityCallback::scheduleTimer(Seconds newDelay)
65 {
66     if (newDelay * timerSlop > m_delay)
67         return;
68     Seconds delta = m_delay - newDelay;
69     m_delay = newDelay;
70     CFRunLoopTimerSetNextFireDate(m_timer.get(), CFRunLoopTimerGetNextFireDate(m_timer.get()) - delta.seconds());
71 }
72
73 void GCActivityCallback::cancelTimer()
74 {
75     m_delay = s_decade;
76     CFRunLoopTimerSetNextFireDate(m_timer.get(), CFAbsoluteTimeGetCurrent() + s_decade.seconds());
77 }
78
79 MonotonicTime GCActivityCallback::nextFireTime()
80 {
81     return MonotonicTime::now() + Seconds(CFRunLoopTimerGetNextFireDate(m_timer.get()) - CFAbsoluteTimeGetCurrent());
82 }
83 #else
84 void GCActivityCallback::scheduleTimer(Seconds newDelay)
85 {
86     if (newDelay * timerSlop > m_delay)
87         return;
88     Seconds delta = m_delay - newDelay;
89     m_delay = newDelay;
90
91     Seconds secondsUntilFire = m_timer.secondsUntilFire();
92     m_timer.startOneShot(std::max<Seconds>(secondsUntilFire - delta, 0_s));
93 }
94
95 void GCActivityCallback::cancelTimer()
96 {
97     m_delay = s_decade;
98     m_timer.startOneShot(s_decade);
99 }
100
101 MonotonicTime GCActivityCallback::nextFireTime()
102 {
103     return MonotonicTime::now() + m_timer.secondsUntilFire();
104 }
105 #endif
106
107 void GCActivityCallback::didAllocate(size_t bytes)
108 {
109     // The first byte allocated in an allocation cycle will report 0 bytes to didAllocate. 
110     // We pretend it's one byte so that we don't ignore this allocation entirely.
111     if (!bytes)
112         bytes = 1;
113     double bytesExpectedToReclaim = static_cast<double>(bytes) * deathRate();
114     Seconds newDelay = lastGCLength() / gcTimeSlice(bytesExpectedToReclaim);
115     scheduleTimer(newDelay);
116 }
117
118 void GCActivityCallback::willCollect()
119 {
120     cancelTimer();
121 }
122
123 void GCActivityCallback::cancel()
124 {
125     cancelTimer();
126 }
127
128 }
129