Repository navigation
Expand file tree
/
Copy pathMarkedAllocator.h
More file actions
149 lines (124 loc) · 3.62 KB
/
Copy pathMarkedAllocator.h
File metadata and controls
149 lines (124 loc) · 3.62 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
#ifndef MarkedAllocator_h
#define MarkedAllocator_h
#include "MarkedBlock.h"
#include <wtf/DoublyLinkedList.h>
namespace JSC {
class Heap;
class MarkedSpace;
class LLIntOffsetsExtractor;
namespace DFG {
class SpeculativeJIT;
}
class MarkedAllocator {
friend class LLIntOffsetsExtractor;
public:
static ptrdiff_t offsetOfFreeListHead();
MarkedAllocator();
void lastChanceToFinalize();
void reset();
void stopAllocating();
void resumeAllocating();
size_t cellSize() { return m_cellSize; }
MarkedBlock::DestructorType destructorType() { return m_destructorType; }
void* allocate(size_t);
Heap* heap() { return m_heap; }
MarkedBlock* takeLastActiveBlock()
{
MarkedBlock* block = m_lastActiveBlock;
m_lastActiveBlock = 0;
return block;
}
template<typename Functor> void forEachBlock(Functor&);
void addBlock(MarkedBlock*);
void removeBlock(MarkedBlock*);
void init(Heap*, MarkedSpace*, size_t cellSize, MarkedBlock::DestructorType);
bool isPagedOut(double deadline);
private:
JS_EXPORT_PRIVATE void* allocateSlowCase(size_t);
void* tryAllocate(size_t);
void* tryAllocateHelper(size_t);
void* tryPopFreeList(size_t);
MarkedBlock* allocateBlock(size_t);
ALWAYS_INLINE void doTestCollectionsIfNeeded();
MarkedBlock::FreeList m_freeList;
MarkedBlock* m_currentBlock;
MarkedBlock* m_lastActiveBlock;
MarkedBlock* m_nextBlockToSweep;
DoublyLinkedList<MarkedBlock> m_blockList;
DoublyLinkedList<MarkedBlock> m_retiredBlocks;
size_t m_cellSize;
MarkedBlock::DestructorType m_destructorType;
Heap* m_heap;
MarkedSpace* m_markedSpace;
};
inline ptrdiff_t MarkedAllocator::offsetOfFreeListHead()
{
return OBJECT_OFFSETOF(MarkedAllocator, m_freeList) + OBJECT_OFFSETOF(MarkedBlock::FreeList, head);
}
inline MarkedAllocator::MarkedAllocator()
: m_currentBlock(0)
, m_lastActiveBlock(0)
, m_nextBlockToSweep(0)
, m_cellSize(0)
, m_destructorType(MarkedBlock::None)
, m_heap(0)
, m_markedSpace(0)
{
}
inline void MarkedAllocator::init(Heap* heap, MarkedSpace* markedSpace, size_t cellSize, MarkedBlock::DestructorType destructorType)
{
m_heap = heap;
m_markedSpace = markedSpace;
m_cellSize = cellSize;
m_destructorType = destructorType;
}
inline void* MarkedAllocator::allocate(size_t bytes)
{
MarkedBlock::FreeCell* head = m_freeList.head;
if (UNLIKELY(!head)) {
void* result = allocateSlowCase(bytes);
#ifndef NDEBUG
memset(result, 0xCD, bytes);
#endif
return result;
}
m_freeList.head = head->next;
#ifndef NDEBUG
memset(head, 0xCD, bytes);
#endif
return head;
}
inline void MarkedAllocator::stopAllocating()
{
ASSERT(!m_lastActiveBlock);
if (!m_currentBlock) {
ASSERT(!m_freeList.head);
return;
}
m_currentBlock->stopAllocating(m_freeList);
m_lastActiveBlock = m_currentBlock;
m_currentBlock = 0;
m_freeList = MarkedBlock::FreeList();
}
inline void MarkedAllocator::resumeAllocating()
{
if (!m_lastActiveBlock)
return;
m_freeList = m_lastActiveBlock->resumeAllocating();
m_currentBlock = m_lastActiveBlock;
m_lastActiveBlock = 0;
}
template <typename Functor> inline void MarkedAllocator::forEachBlock(Functor& functor)
{
MarkedBlock* next;
for (MarkedBlock* block = m_blockList.head(); block; block = next) {
next = block->next();
functor(block);
}
for (MarkedBlock* block = m_retiredBlocks.head(); block; block = next) {
next = block->next();
functor(block);
}
}
} // namespace JSC
#endif