forked from rolandoam/JavaScriptCore
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathMarkedAllocator.cpp
More file actions
128 lines (102 loc) · 3.16 KB
/
MarkedAllocator.cpp
File metadata and controls
128 lines (102 loc) · 3.16 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
#include "config.h"
#include "MarkedAllocator.h"
#include "Heap.h"
namespace JSC {
inline void* MarkedAllocator::tryAllocateHelper()
{
MarkedBlock::FreeCell* firstFreeCell = m_firstFreeCell;
if (!firstFreeCell) {
for (MarkedBlock*& block = m_currentBlock; block; block = static_cast<MarkedBlock*>(block->next())) {
firstFreeCell = block->sweep(MarkedBlock::SweepToFreeList);
if (firstFreeCell)
break;
m_markedSpace->didConsumeFreeList(block);
block->didConsumeFreeList();
}
if (!firstFreeCell)
return 0;
}
ASSERT(firstFreeCell);
m_firstFreeCell = firstFreeCell->next;
return firstFreeCell;
}
inline void* MarkedAllocator::tryAllocate()
{
m_heap->m_operationInProgress = Allocation;
void* result = tryAllocateHelper();
m_heap->m_operationInProgress = NoOperation;
return result;
}
void* MarkedAllocator::allocateSlowCase()
{
#if COLLECT_ON_EVERY_ALLOCATION
m_heap->collectAllGarbage();
ASSERT(m_heap->m_operationInProgress == NoOperation);
#endif
void* result = tryAllocate();
if (LIKELY(result != 0))
return result;
AllocationEffort allocationEffort;
if ((
#if ENABLE(GGC)
nurseryWaterMark() < m_heap->m_minBytesPerCycle
#else
m_heap->waterMark() < m_heap->highWaterMark()
#endif
) || !m_heap->m_isSafeToCollect)
allocationEffort = AllocationMustSucceed;
else
allocationEffort = AllocationCanFail;
MarkedBlock* block = allocateBlock(allocationEffort);
if (block) {
addBlock(block);
void* result = tryAllocate();
ASSERT(result);
return result;
}
m_heap->collect(Heap::DoNotSweep);
result = tryAllocate();
if (result)
return result;
ASSERT(m_heap->waterMark() < m_heap->highWaterMark());
addBlock(allocateBlock(AllocationMustSucceed));
result = tryAllocate();
ASSERT(result);
return result;
}
MarkedBlock* MarkedAllocator::allocateBlock(AllocationEffort allocationEffort)
{
MarkedBlock* block;
{
MutexLocker locker(m_heap->m_freeBlockLock);
if (m_heap->m_numberOfFreeBlocks) {
block = static_cast<MarkedBlock*>(m_heap->m_freeBlocks.removeHead());
ASSERT(block);
m_heap->m_numberOfFreeBlocks--;
} else
block = 0;
}
if (block)
block = MarkedBlock::recycle(block, m_heap, m_cellSize, m_cellsNeedDestruction);
else if (allocationEffort == AllocationCanFail)
return 0;
else
block = MarkedBlock::create(m_heap, m_cellSize, m_cellsNeedDestruction);
m_markedSpace->didAddBlock(block);
return block;
}
void MarkedAllocator::addBlock(MarkedBlock* block)
{
ASSERT(!m_currentBlock);
ASSERT(!m_firstFreeCell);
m_blockList.append(block);
m_currentBlock = block;
m_firstFreeCell = block->sweep(MarkedBlock::SweepToFreeList);
}
void MarkedAllocator::removeBlock(MarkedBlock* block)
{
if (m_currentBlock == block)
m_currentBlock = 0;
m_blockList.remove(block);
}
} // namespace JSC