e2af41ad8703b056f376cd7d5b2b64ca6d69bf38
[WebKit-https.git] / Source / JavaScriptCore / heap / CopiedSpaceInlineMethods.h
1 /*
2  * Copyright (C) 2011 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 #ifndef CopiedSpaceInlineMethods_h
27 #define CopiedSpaceInlineMethods_h
28
29 #include "CopiedBlock.h"
30 #include "CopiedSpace.h"
31 #include "Heap.h"
32 #include "HeapBlock.h"
33 #include "JSGlobalData.h"
34 #include <wtf/CheckedBoolean.h>
35
36 namespace JSC {
37
38 inline bool CopiedSpace::contains(CopiedBlock* block)
39 {
40     return !m_blockFilter.ruleOut(reinterpret_cast<Bits>(block)) && m_blockSet.contains(block);
41 }
42
43 inline bool CopiedSpace::contains(void* ptr, CopiedBlock*& result)
44 {
45     CopiedBlock* block = blockFor(ptr);
46     if (contains(block)) {
47         result = block;
48         return true;
49     }
50     block = oversizeBlockFor(ptr);
51     result = block;
52     return contains(block);
53 }
54
55 inline void CopiedSpace::pin(CopiedBlock* block)
56 {
57     block->m_isPinned = true;
58 }
59
60 inline void CopiedSpace::pinIfNecessary(void* opaquePointer)
61 {
62     // Pointers into the copied space come in the following varieties:
63     // 1)  Pointers to the start of a span of memory. This is the most
64     //     natural though not necessarily the most common.
65     // 2)  Pointers to one value-sized (8 byte) word past the end of
66     //     a span of memory. This currently occurs with semi-butterflies
67     //     and should be fixed soon, once the other half of the
68     //     butterfly lands.
69     // 3)  Pointers to the innards arising from loop induction variable
70     //     optimizations (either manual ones or automatic, by the
71     //     compiler).
72     // 4)  Pointers to the end of a span of memory in arising from
73     //     induction variable optimizations combined with the
74     //     GC-to-compiler contract laid out in the C spec: a pointer to
75     //     the end of a span of memory must be considered to be a
76     //     pointer to that memory.
77     
78     EncodedJSValue* pointer = reinterpret_cast<EncodedJSValue*>(opaquePointer);
79     CopiedBlock* block;
80
81     // Handle (1) and (3).
82     if (contains(pointer, block))
83         pin(block);
84     
85     // Handle (4). We don't have to explicitly check and pin the block under this
86     // pointer because it cannot possibly point to something that cases (1) and
87     // (3) above or case (2) below wouldn't already catch.
88     pointer--;
89     
90     // Handle (2)
91     pointer--;
92     if (contains(pointer, block))
93         pin(block);
94 }
95
96 inline void CopiedSpace::startedCopying()
97 {
98     DoublyLinkedList<HeapBlock>* temp = m_fromSpace;
99     m_fromSpace = m_toSpace;
100     m_toSpace = temp;
101
102     m_blockFilter.reset();
103     m_allocator.resetCurrentBlock();
104
105     ASSERT(!m_inCopyingPhase);
106     ASSERT(!m_numberOfLoanedBlocks);
107     m_inCopyingPhase = true;
108 }
109
110 inline void CopiedSpace::recycleBlock(CopiedBlock* block)
111 {
112     m_heap->blockAllocator().deallocate(CopiedBlock::destroy(block));
113
114     {
115         MutexLocker locker(m_loanedBlocksLock);
116         ASSERT(m_numberOfLoanedBlocks > 0);
117         m_numberOfLoanedBlocks--;
118         if (!m_numberOfLoanedBlocks)
119             m_loanedBlocksCondition.signal();
120     }
121 }
122
123 inline CopiedBlock* CopiedSpace::allocateBlockForCopyingPhase()
124 {
125     ASSERT(m_inCopyingPhase);
126     CopiedBlock* block = CopiedBlock::createNoZeroFill(m_heap->blockAllocator().allocate());
127
128     {
129         MutexLocker locker(m_loanedBlocksLock);
130         m_numberOfLoanedBlocks++;
131     }
132
133     ASSERT(!block->dataSize());
134     return block;
135 }
136
137 inline void CopiedSpace::allocateBlock()
138 {
139     if (m_heap->shouldCollect())
140         m_heap->collect(Heap::DoNotSweep);
141
142     m_allocator.resetCurrentBlock();
143     
144     CopiedBlock* block = CopiedBlock::create(m_heap->blockAllocator().allocate());
145         
146     m_toSpace->push(block);
147     m_blockFilter.add(reinterpret_cast<Bits>(block));
148     m_blockSet.add(block);
149     m_allocator.setCurrentBlock(block);
150 }
151
152 inline CheckedBoolean CopiedSpace::tryAllocate(size_t bytes, void** outPtr)
153 {
154     ASSERT(!m_heap->globalData()->isInitializingObject());
155
156     if (isOversize(bytes) || !m_allocator.tryAllocate(bytes, outPtr))
157         return tryAllocateSlowCase(bytes, outPtr);
158     
159     ASSERT(*outPtr);
160     return true;
161 }
162
163 inline bool CopiedSpace::isOversize(size_t bytes)
164 {
165     return bytes > s_maxAllocationSize;
166 }
167
168 inline bool CopiedSpace::isPinned(void* ptr)
169 {
170     return blockFor(ptr)->m_isPinned;
171 }
172
173 inline CopiedBlock* CopiedSpace::oversizeBlockFor(void* ptr)
174 {
175     return reinterpret_cast<CopiedBlock*>(reinterpret_cast<size_t>(ptr) & WTF::pageMask());
176 }
177
178 inline CopiedBlock* CopiedSpace::blockFor(void* ptr)
179 {
180     return reinterpret_cast<CopiedBlock*>(reinterpret_cast<size_t>(ptr) & s_blockMask);
181 }
182
183 } // namespace JSC
184
185 #endif