Simplify memory usage tracking in CopiedSpace
[WebKit-https.git] / Source / JavaScriptCore / heap / Heap.cpp
1 /*
2  *  Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2011 Apple Inc. All rights reserved.
3  *  Copyright (C) 2007 Eric Seidel <eric@webkit.org>
4  *
5  *  This library is free software; you can redistribute it and/or
6  *  modify it under the terms of the GNU Lesser General Public
7  *  License as published by the Free Software Foundation; either
8  *  version 2 of the License, or (at your option) any later version.
9  *
10  *  This library is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  *  Lesser General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Lesser General Public
16  *  License along with this library; if not, write to the Free Software
17  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
18  *
19  */
20
21 #include "config.h"
22 #include "Heap.h"
23
24 #include "CopiedSpace.h"
25 #include "CopiedSpaceInlineMethods.h"
26 #include "CodeBlock.h"
27 #include "ConservativeRoots.h"
28 #include "GCActivityCallback.h"
29 #include "HeapRootVisitor.h"
30 #include "Interpreter.h"
31 #include "JSGlobalData.h"
32 #include "JSGlobalObject.h"
33 #include "JSLock.h"
34 #include "JSONObject.h"
35 #include "Tracing.h"
36 #include <algorithm>
37 #include <wtf/CurrentTime.h>
38
39
40 using namespace std;
41 using namespace JSC;
42
43 namespace JSC {
44
45 namespace { 
46
47 #if CPU(X86) || CPU(X86_64)
48 static const size_t largeHeapSize = 16 * 1024 * 1024;
49 #elif PLATFORM(IOS)
50 static const size_t largeHeapSize = 8 * 1024 * 1024;
51 #else
52 static const size_t largeHeapSize = 512 * 1024;
53 #endif
54 static const size_t smallHeapSize = 512 * 1024;
55
56 #if ENABLE(GC_LOGGING)
57 #if COMPILER(CLANG)
58 #define DEFINE_GC_LOGGING_GLOBAL(type, name, arguments) \
59 _Pragma("clang diagnostic push") \
60 _Pragma("clang diagnostic ignored \"-Wglobal-constructors\"") \
61 _Pragma("clang diagnostic ignored \"-Wexit-time-destructors\"") \
62 static type name arguments; \
63 _Pragma("clang diagnostic pop")
64 #else
65 #define DEFINE_GC_LOGGING_GLOBAL(type, name, arguments) \
66 static type name arguments;
67 #endif // COMPILER(CLANG)
68
69 struct GCTimer {
70     GCTimer(const char* name)
71         : m_time(0)
72         , m_min(100000000)
73         , m_max(0)
74         , m_count(0)
75         , m_name(name)
76     {
77     }
78     ~GCTimer()
79     {
80         dataLog("%s: %.2lfms (avg. %.2lf, min. %.2lf, max. %.2lf)\n", m_name, m_time * 1000, m_time * 1000 / m_count, m_min*1000, m_max*1000);
81     }
82     double m_time;
83     double m_min;
84     double m_max;
85     size_t m_count;
86     const char* m_name;
87 };
88
89 struct GCTimerScope {
90     GCTimerScope(GCTimer* timer)
91         : m_timer(timer)
92         , m_start(WTF::currentTime())
93     {
94     }
95     ~GCTimerScope()
96     {
97         double delta = WTF::currentTime() - m_start;
98         if (delta < m_timer->m_min)
99             m_timer->m_min = delta;
100         if (delta > m_timer->m_max)
101             m_timer->m_max = delta;
102         m_timer->m_count++;
103         m_timer->m_time += delta;
104     }
105     GCTimer* m_timer;
106     double m_start;
107 };
108
109 struct GCCounter {
110     GCCounter(const char* name)
111         : m_name(name)
112         , m_count(0)
113         , m_total(0)
114         , m_min(10000000)
115         , m_max(0)
116     {
117     }
118     
119     void count(size_t amount)
120     {
121         m_count++;
122         m_total += amount;
123         if (amount < m_min)
124             m_min = amount;
125         if (amount > m_max)
126             m_max = amount;
127     }
128     ~GCCounter()
129     {
130         dataLog("%s: %zu values (avg. %zu, min. %zu, max. %zu)\n", m_name, m_total, m_total / m_count, m_min, m_max);
131     }
132     const char* m_name;
133     size_t m_count;
134     size_t m_total;
135     size_t m_min;
136     size_t m_max;
137 };
138
139 #define GCPHASE(name) DEFINE_GC_LOGGING_GLOBAL(GCTimer, name##Timer, (#name)); GCTimerScope name##TimerScope(&name##Timer)
140 #define COND_GCPHASE(cond, name1, name2) DEFINE_GC_LOGGING_GLOBAL(GCTimer, name1##Timer, (#name1)); DEFINE_GC_LOGGING_GLOBAL(GCTimer, name2##Timer, (#name2)); GCTimerScope name1##CondTimerScope(cond ? &name1##Timer : &name2##Timer)
141 #define GCCOUNTER(name, value) do { DEFINE_GC_LOGGING_GLOBAL(GCCounter, name##Counter, (#name)); name##Counter.count(value); } while (false)
142     
143 #else
144
145 #define GCPHASE(name) do { } while (false)
146 #define COND_GCPHASE(cond, name1, name2) do { } while (false)
147 #define GCCOUNTER(name, value) do { } while (false)
148 #endif
149
150 static size_t heapSizeForHint(HeapSize heapSize)
151 {
152     if (heapSize == LargeHeap)
153         return largeHeapSize;
154     ASSERT(heapSize == SmallHeap);
155     return smallHeapSize;
156 }
157
158 static inline bool isValidSharedInstanceThreadState()
159 {
160     if (!JSLock::lockCount())
161         return false;
162
163     if (!JSLock::currentThreadIsHoldingLock())
164         return false;
165
166     return true;
167 }
168
169 static inline bool isValidThreadState(JSGlobalData* globalData)
170 {
171     if (globalData->identifierTable != wtfThreadData().currentIdentifierTable())
172         return false;
173
174     if (globalData->isSharedInstance() && !isValidSharedInstanceThreadState())
175         return false;
176
177     return true;
178 }
179
180 class CountFunctor {
181 public:
182     typedef size_t ReturnType;
183
184     CountFunctor();
185     void count(size_t);
186     ReturnType returnValue();
187
188 private:
189     ReturnType m_count;
190 };
191
192 inline CountFunctor::CountFunctor()
193     : m_count(0)
194 {
195 }
196
197 inline void CountFunctor::count(size_t count)
198 {
199     m_count += count;
200 }
201
202 inline CountFunctor::ReturnType CountFunctor::returnValue()
203 {
204     return m_count;
205 }
206
207 struct ClearMarks : MarkedBlock::VoidFunctor {
208     void operator()(MarkedBlock*);
209 };
210
211 inline void ClearMarks::operator()(MarkedBlock* block)
212 {
213     block->clearMarks();
214 }
215
216 struct Sweep : MarkedBlock::VoidFunctor {
217     void operator()(MarkedBlock*);
218 };
219
220 inline void Sweep::operator()(MarkedBlock* block)
221 {
222     block->sweep();
223 }
224
225 struct MarkCount : CountFunctor {
226     void operator()(MarkedBlock*);
227 };
228
229 inline void MarkCount::operator()(MarkedBlock* block)
230 {
231     count(block->markCount());
232 }
233
234 struct Size : CountFunctor {
235     void operator()(MarkedBlock*);
236 };
237
238 inline void Size::operator()(MarkedBlock* block)
239 {
240     count(block->markCount() * block->cellSize());
241 }
242
243 struct Capacity : CountFunctor {
244     void operator()(MarkedBlock*);
245 };
246
247 inline void Capacity::operator()(MarkedBlock* block)
248 {
249     count(block->capacity());
250 }
251
252 struct Count : public CountFunctor {
253     void operator()(JSCell*);
254 };
255
256 inline void Count::operator()(JSCell*)
257 {
258     count(1);
259 }
260
261 struct CountIfGlobalObject : CountFunctor {
262     void operator()(JSCell*);
263 };
264
265 inline void CountIfGlobalObject::operator()(JSCell* cell)
266 {
267     if (!cell->isObject())
268         return;
269     if (!asObject(cell)->isGlobalObject())
270         return;
271     count(1);
272 }
273
274 class RecordType {
275 public:
276     typedef PassOwnPtr<TypeCountSet> ReturnType;
277
278     RecordType();
279     void operator()(JSCell*);
280     ReturnType returnValue();
281
282 private:
283     const char* typeName(JSCell*);
284     OwnPtr<TypeCountSet> m_typeCountSet;
285 };
286
287 inline RecordType::RecordType()
288     : m_typeCountSet(adoptPtr(new TypeCountSet))
289 {
290 }
291
292 inline const char* RecordType::typeName(JSCell* cell)
293 {
294     const ClassInfo* info = cell->classInfo();
295     if (!info || !info->className)
296         return "[unknown]";
297     return info->className;
298 }
299
300 inline void RecordType::operator()(JSCell* cell)
301 {
302     m_typeCountSet->add(typeName(cell));
303 }
304
305 inline PassOwnPtr<TypeCountSet> RecordType::returnValue()
306 {
307     return m_typeCountSet.release();
308 }
309
310 } // anonymous namespace
311
312 Heap::Heap(JSGlobalData* globalData, HeapSize heapSize)
313     : m_heapSize(heapSize)
314     , m_minBytesPerCycle(heapSizeForHint(heapSize))
315     , m_lastFullGCSize(0)
316     , m_waterMark(0)
317     , m_highWaterMark(m_minBytesPerCycle)
318     , m_operationInProgress(NoOperation)
319     , m_objectSpace(this)
320     , m_storageSpace(this)
321     , m_blockFreeingThreadShouldQuit(false)
322     , m_extraCost(0)
323     , m_markListSet(0)
324     , m_activityCallback(DefaultGCActivityCallback::create(this))
325     , m_machineThreads(this)
326     , m_sharedData(globalData)
327     , m_slotVisitor(m_sharedData)
328     , m_handleHeap(globalData)
329     , m_isSafeToCollect(false)
330     , m_globalData(globalData)
331     , m_lastGCLength(0)
332 {
333     (*m_activityCallback)();
334     m_numberOfFreeBlocks = 0;
335     m_blockFreeingThread = createThread(blockFreeingThreadStartFunc, this, "JavaScriptCore::BlockFree");
336     
337     ASSERT(m_blockFreeingThread);
338     m_storageSpace.init();
339 }
340
341 Heap::~Heap()
342 {
343     // Destroy our block freeing thread.
344     {
345         MutexLocker locker(m_freeBlockLock);
346         m_blockFreeingThreadShouldQuit = true;
347         m_freeBlockCondition.broadcast();
348     }
349     waitForThreadCompletion(m_blockFreeingThread);
350
351     // The destroy function must already have been called, so assert this.
352     ASSERT(!m_globalData);
353 }
354
355 void Heap::destroy()
356 {
357     JSLock lock(SilenceAssertionsOnly);
358
359     if (!m_globalData)
360         return;
361
362     ASSERT(!m_globalData->dynamicGlobalObject);
363     ASSERT(m_operationInProgress == NoOperation);
364     
365     // The global object is not GC protected at this point, so sweeping may delete it
366     // (and thus the global data) before other objects that may use the global data.
367     RefPtr<JSGlobalData> protect(m_globalData);
368
369 #if ENABLE(JIT)
370     m_globalData->jitStubs->clearHostFunctionStubs();
371 #endif
372
373     delete m_markListSet;
374     m_markListSet = 0;
375
376     canonicalizeCellLivenessData();
377     clearMarks();
378
379     m_handleHeap.finalizeWeakHandles();
380     m_globalData->smallStrings.finalizeSmallStrings();
381     shrink();
382     m_storageSpace.destroy();
383     ASSERT(!size());
384
385 #if ENABLE(SIMPLE_HEAP_PROFILING)
386     m_slotVisitor.m_visitedTypeCounts.dump(WTF::dataFile(), "Visited Type Counts");
387     m_destroyedTypeCounts.dump(WTF::dataFile(), "Destroyed Type Counts");
388 #endif
389     
390     releaseFreeBlocks();
391
392     m_globalData = 0;
393 }
394
395 void Heap::waitForRelativeTimeWhileHoldingLock(double relative)
396 {
397     if (m_blockFreeingThreadShouldQuit)
398         return;
399     m_freeBlockCondition.timedWait(m_freeBlockLock, currentTime() + relative);
400 }
401
402 void Heap::waitForRelativeTime(double relative)
403 {
404     // If this returns early, that's fine, so long as it doesn't do it too
405     // frequently. It would only be a bug if this function failed to return
406     // when it was asked to do so.
407     
408     MutexLocker locker(m_freeBlockLock);
409     waitForRelativeTimeWhileHoldingLock(relative);
410 }
411
412 void Heap::blockFreeingThreadStartFunc(void* heap)
413 {
414     static_cast<Heap*>(heap)->blockFreeingThreadMain();
415 }
416
417 void Heap::blockFreeingThreadMain()
418 {
419     while (!m_blockFreeingThreadShouldQuit) {
420         // Generally wait for one second before scavenging free blocks. This
421         // may return early, particularly when we're being asked to quit.
422         waitForRelativeTime(1.0);
423         if (m_blockFreeingThreadShouldQuit)
424             break;
425         
426         // Now process the list of free blocks. Keep freeing until half of the
427         // blocks that are currently on the list are gone. Assume that a size_t
428         // field can be accessed atomically.
429         size_t currentNumberOfFreeBlocks = m_numberOfFreeBlocks;
430         if (!currentNumberOfFreeBlocks)
431             continue;
432         
433         size_t desiredNumberOfFreeBlocks = currentNumberOfFreeBlocks / 2;
434         
435         while (!m_blockFreeingThreadShouldQuit) {
436             MarkedBlock* block;
437             {
438                 MutexLocker locker(m_freeBlockLock);
439                 if (m_numberOfFreeBlocks <= desiredNumberOfFreeBlocks)
440                     block = 0;
441                 else {
442                     block = static_cast<MarkedBlock*>(m_freeBlocks.removeHead());
443                     ASSERT(block);
444                     m_numberOfFreeBlocks--;
445                 }
446             }
447             
448             if (!block)
449                 break;
450             
451             MarkedBlock::destroy(block);
452         }
453     }
454 }
455
456 void Heap::reportExtraMemoryCostSlowCase(size_t cost)
457 {
458     // Our frequency of garbage collection tries to balance memory use against speed
459     // by collecting based on the number of newly created values. However, for values
460     // that hold on to a great deal of memory that's not in the form of other JS values,
461     // that is not good enough - in some cases a lot of those objects can pile up and
462     // use crazy amounts of memory without a GC happening. So we track these extra
463     // memory costs. Only unusually large objects are noted, and we only keep track
464     // of this extra cost until the next GC. In garbage collected languages, most values
465     // are either very short lived temporaries, or have extremely long lifetimes. So
466     // if a large value survives one garbage collection, there is not much point to
467     // collecting more frequently as long as it stays alive.
468
469     if (m_extraCost > maxExtraCost && m_extraCost > highWaterMark() / 2)
470         collectAllGarbage();
471     m_extraCost += cost;
472 }
473
474 void Heap::protect(JSValue k)
475 {
476     ASSERT(k);
477     ASSERT(JSLock::currentThreadIsHoldingLock() || !m_globalData->isSharedInstance());
478
479     if (!k.isCell())
480         return;
481
482     m_protectedValues.add(k.asCell());
483 }
484
485 bool Heap::unprotect(JSValue k)
486 {
487     ASSERT(k);
488     ASSERT(JSLock::currentThreadIsHoldingLock() || !m_globalData->isSharedInstance());
489
490     if (!k.isCell())
491         return false;
492
493     return m_protectedValues.remove(k.asCell());
494 }
495
496 void Heap::jettisonDFGCodeBlock(PassOwnPtr<CodeBlock> codeBlock)
497 {
498     m_dfgCodeBlocks.jettison(codeBlock);
499 }
500
501 void Heap::markProtectedObjects(HeapRootVisitor& heapRootVisitor)
502 {
503     ProtectCountSet::iterator end = m_protectedValues.end();
504     for (ProtectCountSet::iterator it = m_protectedValues.begin(); it != end; ++it)
505         heapRootVisitor.visit(&it->first);
506 }
507
508 void Heap::pushTempSortVector(Vector<ValueStringPair>* tempVector)
509 {
510     m_tempSortingVectors.append(tempVector);
511 }
512
513 void Heap::popTempSortVector(Vector<ValueStringPair>* tempVector)
514 {
515     ASSERT_UNUSED(tempVector, tempVector == m_tempSortingVectors.last());
516     m_tempSortingVectors.removeLast();
517 }
518
519 void Heap::markTempSortVectors(HeapRootVisitor& heapRootVisitor)
520 {
521     typedef Vector<Vector<ValueStringPair>* > VectorOfValueStringVectors;
522
523     VectorOfValueStringVectors::iterator end = m_tempSortingVectors.end();
524     for (VectorOfValueStringVectors::iterator it = m_tempSortingVectors.begin(); it != end; ++it) {
525         Vector<ValueStringPair>* tempSortingVector = *it;
526
527         Vector<ValueStringPair>::iterator vectorEnd = tempSortingVector->end();
528         for (Vector<ValueStringPair>::iterator vectorIt = tempSortingVector->begin(); vectorIt != vectorEnd; ++vectorIt) {
529             if (vectorIt->first)
530                 heapRootVisitor.visit(&vectorIt->first);
531         }
532     }
533 }
534
535 void Heap::harvestWeakReferences()
536 {
537     m_slotVisitor.harvestWeakReferences();
538 }
539
540 void Heap::finalizeUnconditionalFinalizers()
541 {
542     m_slotVisitor.finalizeUnconditionalFinalizers();
543 }
544
545 inline RegisterFile& Heap::registerFile()
546 {
547     return m_globalData->interpreter->registerFile();
548 }
549
550 void Heap::getConservativeRegisterRoots(HashSet<JSCell*>& roots)
551 {
552     ASSERT(isValidThreadState(m_globalData));
553     if (m_operationInProgress != NoOperation)
554         CRASH();
555     m_operationInProgress = Collection;
556     ConservativeRoots registerFileRoots(&m_objectSpace.blocks(), &m_storageSpace);
557     registerFile().gatherConservativeRoots(registerFileRoots);
558     size_t registerFileRootCount = registerFileRoots.size();
559     JSCell** registerRoots = registerFileRoots.roots();
560     for (size_t i = 0; i < registerFileRootCount; i++) {
561         setMarked(registerRoots[i]);
562         roots.add(registerRoots[i]);
563     }
564     m_operationInProgress = NoOperation;
565 }
566
567 void Heap::markRoots(bool fullGC)
568 {
569     SamplingRegion samplingRegion("Garbage Collection: Tracing");
570
571     COND_GCPHASE(fullGC, MarkFullRoots, MarkYoungRoots);
572     UNUSED_PARAM(fullGC);
573     ASSERT(isValidThreadState(m_globalData));
574     if (m_operationInProgress != NoOperation)
575         CRASH();
576     m_operationInProgress = Collection;
577
578     void* dummy;
579     
580     // We gather conservative roots before clearing mark bits because conservative
581     // gathering uses the mark bits to determine whether a reference is valid.
582     ConservativeRoots machineThreadRoots(&m_objectSpace.blocks(), &m_storageSpace);
583     {
584         GCPHASE(GatherConservativeRoots);
585         m_machineThreads.gatherConservativeRoots(machineThreadRoots, &dummy);
586     }
587
588     ConservativeRoots registerFileRoots(&m_objectSpace.blocks(), &m_storageSpace);
589     m_dfgCodeBlocks.clearMarks();
590     {
591         GCPHASE(GatherRegisterFileRoots);
592         registerFile().gatherConservativeRoots(registerFileRoots, m_dfgCodeBlocks);
593     }
594 #if ENABLE(GGC)
595     MarkedBlock::DirtyCellVector dirtyCells;
596     if (!fullGC) {
597         GCPHASE(GatheringDirtyCells);
598         m_objectSpace.gatherDirtyCells(dirtyCells);
599     } else
600 #endif
601     {
602         GCPHASE(clearMarks);
603         clearMarks();
604     }
605
606     m_storageSpace.startedCopying();
607     SlotVisitor& visitor = m_slotVisitor;
608     HeapRootVisitor heapRootVisitor(visitor);
609
610     {
611         ParallelModeEnabler enabler(visitor);
612 #if ENABLE(GGC)
613         {
614             size_t dirtyCellCount = dirtyCells.size();
615             GCPHASE(VisitDirtyCells);
616             GCCOUNTER(DirtyCellCount, dirtyCellCount);
617             for (size_t i = 0; i < dirtyCellCount; i++) {
618                 heapRootVisitor.visitChildren(dirtyCells[i]);
619                 visitor.donateAndDrain();
620             }
621         }
622 #endif
623     
624         if (m_globalData->codeBlocksBeingCompiled.size()) {
625             GCPHASE(VisitActiveCodeBlock);
626             for (size_t i = 0; i < m_globalData->codeBlocksBeingCompiled.size(); i++)
627                 m_globalData->codeBlocksBeingCompiled[i]->visitAggregate(visitor);
628         }
629     
630         {
631             GCPHASE(VisitMachineRoots);
632             visitor.append(machineThreadRoots);
633             visitor.donateAndDrain();
634         }
635         {
636             GCPHASE(VisitRegisterFileRoots);
637             visitor.append(registerFileRoots);
638             visitor.donateAndDrain();
639         }
640         {
641             GCPHASE(VisitProtectedObjects);
642             markProtectedObjects(heapRootVisitor);
643             visitor.donateAndDrain();
644         }
645         {
646             GCPHASE(VisitTempSortVectors);
647             markTempSortVectors(heapRootVisitor);
648             visitor.donateAndDrain();
649         }
650
651         {
652             GCPHASE(MarkingArgumentBuffers);
653             if (m_markListSet && m_markListSet->size()) {
654                 MarkedArgumentBuffer::markLists(heapRootVisitor, *m_markListSet);
655                 visitor.donateAndDrain();
656             }
657         }
658         if (m_globalData->exception) {
659             GCPHASE(MarkingException);
660             heapRootVisitor.visit(&m_globalData->exception);
661             visitor.donateAndDrain();
662         }
663     
664         {
665             GCPHASE(VisitStrongHandles);
666             m_handleHeap.visitStrongHandles(heapRootVisitor);
667             visitor.donateAndDrain();
668         }
669     
670         {
671             GCPHASE(HandleStack);
672             m_handleStack.visit(heapRootVisitor);
673             visitor.donateAndDrain();
674         }
675     
676         {
677             GCPHASE(TraceCodeBlocks);
678             m_dfgCodeBlocks.traceMarkedCodeBlocks(visitor);
679             visitor.donateAndDrain();
680         }
681     
682 #if ENABLE(PARALLEL_GC)
683         {
684             GCPHASE(Convergence);
685             visitor.drainFromShared(SlotVisitor::MasterDrain);
686         }
687 #endif
688     }
689
690     // Weak handles must be marked last, because their owners use the set of
691     // opaque roots to determine reachability.
692     {
693         GCPHASE(VisitingWeakHandles);
694         while (true) {
695             m_handleHeap.visitWeakHandles(heapRootVisitor);
696             harvestWeakReferences();
697             if (visitor.isEmpty())
698                 break;
699             {
700                 ParallelModeEnabler enabler(visitor);
701                 visitor.donateAndDrain();
702 #if ENABLE(PARALLEL_GC)
703                 visitor.drainFromShared(SlotVisitor::MasterDrain);
704 #endif
705             }
706         }
707     }
708     GCCOUNTER(VisitedValueCount, visitor.visitCount());
709
710     visitor.doneCopying();
711     visitor.reset();
712     m_sharedData.reset();
713     m_storageSpace.doneCopying();
714
715     m_operationInProgress = NoOperation;
716 }
717
718 void Heap::clearMarks()
719 {
720     m_objectSpace.forEachBlock<ClearMarks>();
721 }
722
723 void Heap::sweep()
724 {
725     m_objectSpace.forEachBlock<Sweep>();
726 }
727
728 size_t Heap::objectCount()
729 {
730     return m_objectSpace.forEachBlock<MarkCount>();
731 }
732
733 size_t Heap::size()
734 {
735     return m_objectSpace.forEachBlock<Size>() + m_storageSpace.size();
736 }
737
738 size_t Heap::capacity()
739 {
740     return m_objectSpace.forEachBlock<Capacity>() + m_storageSpace.capacity();
741 }
742
743 size_t Heap::protectedGlobalObjectCount()
744 {
745     return forEachProtectedCell<CountIfGlobalObject>();
746 }
747
748 size_t Heap::globalObjectCount()
749 {
750     return m_objectSpace.forEachCell<CountIfGlobalObject>();
751 }
752
753 size_t Heap::protectedObjectCount()
754 {
755     return forEachProtectedCell<Count>();
756 }
757
758 PassOwnPtr<TypeCountSet> Heap::protectedObjectTypeCounts()
759 {
760     return forEachProtectedCell<RecordType>();
761 }
762
763 PassOwnPtr<TypeCountSet> Heap::objectTypeCounts()
764 {
765     return m_objectSpace.forEachCell<RecordType>();
766 }
767
768 void Heap::collectAllGarbage()
769 {
770     if (!m_isSafeToCollect)
771         return;
772     if (!m_globalData->dynamicGlobalObject)
773         m_globalData->recompileAllJSFunctions();
774
775     collect(DoSweep);
776 }
777
778 void Heap::collect(SweepToggle sweepToggle)
779 {
780     SamplingRegion samplingRegion("Garbage Collection");
781     
782     GCPHASE(Collect);
783     ASSERT(globalData()->identifierTable == wtfThreadData().currentIdentifierTable());
784     ASSERT(m_isSafeToCollect);
785     JAVASCRIPTCORE_GC_BEGIN();
786     double lastGCStartTime = WTF::currentTime();
787 #if ENABLE(GGC)
788     bool fullGC = sweepToggle == DoSweep;
789     if (!fullGC)
790         fullGC = (capacity() > 4 * m_lastFullGCSize);  
791 #else
792     bool fullGC = true;
793 #endif
794     {
795         GCPHASE(Canonicalize);
796         canonicalizeCellLivenessData();
797     }
798
799     markRoots(fullGC);
800     
801     {
802         GCPHASE(FinalizeUnconditionalFinalizers);
803         finalizeUnconditionalFinalizers();
804     }
805         
806     {
807         GCPHASE(FinalizeWeakHandles);
808         m_handleHeap.finalizeWeakHandles();
809         m_globalData->smallStrings.finalizeSmallStrings();
810     }
811     
812     JAVASCRIPTCORE_GC_MARKED();
813
814     {
815         GCPHASE(ResetAllocator);
816         resetAllocators();
817     }
818     
819     {
820         GCPHASE(DeleteCodeBlocks);
821         m_dfgCodeBlocks.deleteUnmarkedJettisonedCodeBlocks();
822     }
823
824     if (sweepToggle == DoSweep) {
825         SamplingRegion samplingRegion("Garbage Collection: Sweeping");
826         GCPHASE(Sweeping);
827         sweep();
828         shrink();
829     }
830
831     // To avoid pathological GC churn in large heaps, we set the allocation high
832     // water mark to be proportional to the current size of the heap. The exact
833     // proportion is a bit arbitrary. A 2X multiplier gives a 1:1 (heap size :
834     // new bytes allocated) proportion, and seems to work well in benchmarks.
835     size_t newSize = size();
836     size_t proportionalBytes = 2 * newSize;
837     if (fullGC) {
838         m_lastFullGCSize = newSize;
839         setHighWaterMark(max(proportionalBytes, m_minBytesPerCycle));
840     }
841     double lastGCEndTime = WTF::currentTime();
842     m_lastGCLength = lastGCEndTime - lastGCStartTime;
843     JAVASCRIPTCORE_GC_END();
844
845     (*m_activityCallback)();
846 }
847
848 void Heap::canonicalizeCellLivenessData()
849 {
850     m_objectSpace.canonicalizeCellLivenessData();
851 }
852
853 void Heap::resetAllocators()
854 {
855     m_extraCost = 0;
856     m_objectSpace.resetAllocators();
857 }
858
859 void Heap::setActivityCallback(PassOwnPtr<GCActivityCallback> activityCallback)
860 {
861     m_activityCallback = activityCallback;
862 }
863
864 GCActivityCallback* Heap::activityCallback()
865 {
866     return m_activityCallback.get();
867 }
868
869 bool Heap::isValidAllocation(size_t bytes)
870 {
871     if (!isValidThreadState(m_globalData))
872         return false;
873
874     if (bytes > MarkedSpace::maxCellSize)
875         return false;
876
877     if (m_operationInProgress != NoOperation)
878         return false;
879     
880     return true;
881 }
882
883 void Heap::freeBlocks(MarkedBlock* head)
884 {
885     m_objectSpace.freeBlocks(head);
886 }
887
888 void Heap::shrink()
889 {
890     m_objectSpace.shrink();
891 }
892
893 void Heap::releaseFreeBlocks()
894 {
895     while (true) {
896         MarkedBlock* block;
897         {
898             MutexLocker locker(m_freeBlockLock);
899             if (!m_numberOfFreeBlocks)
900                 block = 0;
901             else {
902                 block = static_cast<MarkedBlock*>(m_freeBlocks.removeHead());
903                 ASSERT(block);
904                 m_numberOfFreeBlocks--;
905             }
906         }
907         
908         if (!block)
909             break;
910         
911         MarkedBlock::destroy(block);
912     }
913 }
914
915 void Heap::addFinalizer(JSCell* cell, Finalizer finalizer)
916 {
917     Weak<JSCell> weak(*globalData(), cell, &m_finalizerOwner, reinterpret_cast<void*>(finalizer));
918     weak.leakHandle(); // Balanced by FinalizerOwner::finalize().
919 }
920
921 void Heap::FinalizerOwner::finalize(Handle<Unknown> handle, void* context)
922 {
923     Weak<JSCell> weak(Weak<JSCell>::Adopt, handle);
924     Finalizer finalizer = reinterpret_cast<Finalizer>(context);
925     finalizer(weak.get());
926 }
927
928 } // namespace JSC