GC allocation trigger should be tuned to system RAM
[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 "WeakSetInlines.h"
37 #include <algorithm>
38 #include <wtf/RAMSize.h>
39 #include <wtf/CurrentTime.h>
40
41 using namespace std;
42 using namespace JSC;
43
44 namespace JSC {
45
46 namespace { 
47
48 static const size_t largeHeapSize = 32 * MB; // About 1.5X the average webpage.
49 static const size_t smallHeapSize = 1 * MB; // Matches the FastMalloc per-thread cache.
50
51 #if ENABLE(GC_LOGGING)
52 #if COMPILER(CLANG)
53 #define DEFINE_GC_LOGGING_GLOBAL(type, name, arguments) \
54 _Pragma("clang diagnostic push") \
55 _Pragma("clang diagnostic ignored \"-Wglobal-constructors\"") \
56 _Pragma("clang diagnostic ignored \"-Wexit-time-destructors\"") \
57 static type name arguments; \
58 _Pragma("clang diagnostic pop")
59 #else
60 #define DEFINE_GC_LOGGING_GLOBAL(type, name, arguments) \
61 static type name arguments;
62 #endif // COMPILER(CLANG)
63
64 struct GCTimer {
65     GCTimer(const char* name)
66         : m_time(0)
67         , m_min(100000000)
68         , m_max(0)
69         , m_count(0)
70         , m_name(name)
71     {
72     }
73     ~GCTimer()
74     {
75         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);
76     }
77     double m_time;
78     double m_min;
79     double m_max;
80     size_t m_count;
81     const char* m_name;
82 };
83
84 struct GCTimerScope {
85     GCTimerScope(GCTimer* timer)
86         : m_timer(timer)
87         , m_start(WTF::currentTime())
88     {
89     }
90     ~GCTimerScope()
91     {
92         double delta = WTF::currentTime() - m_start;
93         if (delta < m_timer->m_min)
94             m_timer->m_min = delta;
95         if (delta > m_timer->m_max)
96             m_timer->m_max = delta;
97         m_timer->m_count++;
98         m_timer->m_time += delta;
99     }
100     GCTimer* m_timer;
101     double m_start;
102 };
103
104 struct GCCounter {
105     GCCounter(const char* name)
106         : m_name(name)
107         , m_count(0)
108         , m_total(0)
109         , m_min(10000000)
110         , m_max(0)
111     {
112     }
113     
114     void count(size_t amount)
115     {
116         m_count++;
117         m_total += amount;
118         if (amount < m_min)
119             m_min = amount;
120         if (amount > m_max)
121             m_max = amount;
122     }
123     ~GCCounter()
124     {
125         dataLog("%s: %zu values (avg. %zu, min. %zu, max. %zu)\n", m_name, m_total, m_total / m_count, m_min, m_max);
126     }
127     const char* m_name;
128     size_t m_count;
129     size_t m_total;
130     size_t m_min;
131     size_t m_max;
132 };
133
134 #define GCPHASE(name) DEFINE_GC_LOGGING_GLOBAL(GCTimer, name##Timer, (#name)); GCTimerScope name##TimerScope(&name##Timer)
135 #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)
136 #define GCCOUNTER(name, value) do { DEFINE_GC_LOGGING_GLOBAL(GCCounter, name##Counter, (#name)); name##Counter.count(value); } while (false)
137     
138 #else
139
140 #define GCPHASE(name) do { } while (false)
141 #define COND_GCPHASE(cond, name1, name2) do { } while (false)
142 #define GCCOUNTER(name, value) do { } while (false)
143 #endif
144
145 static inline size_t minHeapSize(HeapType heapType, size_t ramSize)
146 {
147     if (heapType == LargeHeap)
148         return min(largeHeapSize, ramSize / 4);
149     return smallHeapSize;
150 }
151
152 static inline size_t proportionalHeapSize(size_t heapSize, size_t ramSize)
153 {
154     // Try to stay under 1/2 RAM size to leave room for the DOM, rendering, networking, etc.
155     if (heapSize < ramSize / 4)
156         return 2 * heapSize;
157     if (heapSize < ramSize / 2)
158         return 1.5 * heapSize;
159     return 1.25 * heapSize;
160 }
161
162 static inline bool isValidSharedInstanceThreadState()
163 {
164     if (!JSLock::lockCount())
165         return false;
166
167     if (!JSLock::currentThreadIsHoldingLock())
168         return false;
169
170     return true;
171 }
172
173 static inline bool isValidThreadState(JSGlobalData* globalData)
174 {
175     if (globalData->identifierTable != wtfThreadData().currentIdentifierTable())
176         return false;
177
178     if (globalData->isSharedInstance() && !isValidSharedInstanceThreadState())
179         return false;
180
181     return true;
182 }
183
184 struct Count : public MarkedBlock::CountFunctor {
185     void operator()(JSCell*) { count(1); }
186 };
187
188 struct CountIfGlobalObject : MarkedBlock::CountFunctor {
189     void operator()(JSCell* cell) {
190         if (!cell->isObject())
191             return;
192         if (!asObject(cell)->isGlobalObject())
193             return;
194         count(1);
195     }
196 };
197
198 class RecordType {
199 public:
200     typedef PassOwnPtr<TypeCountSet> ReturnType;
201
202     RecordType();
203     void operator()(JSCell*);
204     ReturnType returnValue();
205
206 private:
207     const char* typeName(JSCell*);
208     OwnPtr<TypeCountSet> m_typeCountSet;
209 };
210
211 inline RecordType::RecordType()
212     : m_typeCountSet(adoptPtr(new TypeCountSet))
213 {
214 }
215
216 inline const char* RecordType::typeName(JSCell* cell)
217 {
218     const ClassInfo* info = cell->classInfo();
219     if (!info || !info->className)
220         return "[unknown]";
221     return info->className;
222 }
223
224 inline void RecordType::operator()(JSCell* cell)
225 {
226     m_typeCountSet->add(typeName(cell));
227 }
228
229 inline PassOwnPtr<TypeCountSet> RecordType::returnValue()
230 {
231     return m_typeCountSet.release();
232 }
233
234 } // anonymous namespace
235
236 Heap::Heap(JSGlobalData* globalData, HeapType heapType)
237     : m_heapType(heapType)
238     , m_ramSize(ramSize())
239     , m_minBytesPerCycle(minHeapSize(m_heapType, m_ramSize))
240     , m_sizeAfterLastCollect(0)
241     , m_bytesAllocatedLimit(m_minBytesPerCycle)
242     , m_bytesAllocated(0)
243     , m_bytesAbandoned(0)
244     , m_operationInProgress(NoOperation)
245     , m_objectSpace(this)
246     , m_storageSpace(this)
247     , m_markListSet(0)
248     , m_activityCallback(DefaultGCActivityCallback::create(this))
249     , m_machineThreads(this)
250     , m_sharedData(globalData)
251     , m_slotVisitor(m_sharedData)
252     , m_weakSet(this)
253     , m_handleSet(globalData)
254     , m_isSafeToCollect(false)
255     , m_globalData(globalData)
256     , m_lastGCLength(0)
257     , m_lastCodeDiscardTime(WTF::currentTime())
258 {
259     m_storageSpace.init();
260 }
261
262 Heap::~Heap()
263 {
264     delete m_markListSet;
265
266     m_objectSpace.shrink();
267     m_storageSpace.freeAllBlocks();
268
269     ASSERT(!size());
270     ASSERT(!capacity());
271 }
272
273 bool Heap::isPagedOut(double deadline)
274 {
275     return m_objectSpace.isPagedOut(deadline) || m_storageSpace.isPagedOut(deadline);
276 }
277
278 // The JSGlobalData is being destroyed and the collector will never run again.
279 // Run all pending finalizers now because we won't get another chance.
280 void Heap::lastChanceToFinalize()
281 {
282     ASSERT(!m_globalData->dynamicGlobalObject);
283     ASSERT(m_operationInProgress == NoOperation);
284
285     // FIXME: Make this a release-mode crash once we're sure no one's doing this.
286     if (size_t size = m_protectedValues.size())
287         WTFLogAlways("ERROR: JavaScriptCore heap deallocated while %ld values were still protected", static_cast<unsigned long>(size));
288
289     m_weakSet.finalizeAll();
290     m_objectSpace.canonicalizeCellLivenessData();
291     m_objectSpace.clearMarks();
292     m_objectSpace.sweep();
293     m_globalData->smallStrings.finalizeSmallStrings();
294
295 #if ENABLE(SIMPLE_HEAP_PROFILING)
296     m_slotVisitor.m_visitedTypeCounts.dump(WTF::dataFile(), "Visited Type Counts");
297     m_destroyedTypeCounts.dump(WTF::dataFile(), "Destroyed Type Counts");
298 #endif
299 }
300
301 void Heap::reportExtraMemoryCostSlowCase(size_t cost)
302 {
303     // Our frequency of garbage collection tries to balance memory use against speed
304     // by collecting based on the number of newly created values. However, for values
305     // that hold on to a great deal of memory that's not in the form of other JS values,
306     // that is not good enough - in some cases a lot of those objects can pile up and
307     // use crazy amounts of memory without a GC happening. So we track these extra
308     // memory costs. Only unusually large objects are noted, and we only keep track
309     // of this extra cost until the next GC. In garbage collected languages, most values
310     // are either very short lived temporaries, or have extremely long lifetimes. So
311     // if a large value survives one garbage collection, there is not much point to
312     // collecting more frequently as long as it stays alive.
313
314     didAllocate(cost);
315     if (shouldCollect())
316         collect(DoNotSweep);
317 }
318
319 void Heap::reportAbandonedObjectGraph()
320 {
321     // Our clients don't know exactly how much memory they
322     // are abandoning so we just guess for them.
323     double abandonedBytes = 0.10 * m_sizeAfterLastCollect;
324
325     // We want to accelerate the next collection. Because memory has just 
326     // been abandoned, the next collection has the potential to 
327     // be more profitable. Since allocation is the trigger for collection, 
328     // we hasten the next collection by pretending that we've allocated more memory. 
329     didAbandon(abandonedBytes);
330 }
331
332 void Heap::didAbandon(size_t bytes)
333 {
334     m_activityCallback->didAllocate(m_bytesAllocated + m_bytesAbandoned);
335     m_bytesAbandoned += bytes;
336 }
337
338 void Heap::protect(JSValue k)
339 {
340     ASSERT(k);
341     ASSERT(JSLock::currentThreadIsHoldingLock() || !m_globalData->isSharedInstance());
342
343     if (!k.isCell())
344         return;
345
346     m_protectedValues.add(k.asCell());
347 }
348
349 bool Heap::unprotect(JSValue k)
350 {
351     ASSERT(k);
352     ASSERT(JSLock::currentThreadIsHoldingLock() || !m_globalData->isSharedInstance());
353
354     if (!k.isCell())
355         return false;
356
357     return m_protectedValues.remove(k.asCell());
358 }
359
360 void Heap::jettisonDFGCodeBlock(PassOwnPtr<CodeBlock> codeBlock)
361 {
362     m_dfgCodeBlocks.jettison(codeBlock);
363 }
364
365 void Heap::markProtectedObjects(HeapRootVisitor& heapRootVisitor)
366 {
367     ProtectCountSet::iterator end = m_protectedValues.end();
368     for (ProtectCountSet::iterator it = m_protectedValues.begin(); it != end; ++it)
369         heapRootVisitor.visit(&it->first);
370 }
371
372 void Heap::pushTempSortVector(Vector<ValueStringPair>* tempVector)
373 {
374     m_tempSortingVectors.append(tempVector);
375 }
376
377 void Heap::popTempSortVector(Vector<ValueStringPair>* tempVector)
378 {
379     ASSERT_UNUSED(tempVector, tempVector == m_tempSortingVectors.last());
380     m_tempSortingVectors.removeLast();
381 }
382
383 void Heap::markTempSortVectors(HeapRootVisitor& heapRootVisitor)
384 {
385     typedef Vector<Vector<ValueStringPair>* > VectorOfValueStringVectors;
386
387     VectorOfValueStringVectors::iterator end = m_tempSortingVectors.end();
388     for (VectorOfValueStringVectors::iterator it = m_tempSortingVectors.begin(); it != end; ++it) {
389         Vector<ValueStringPair>* tempSortingVector = *it;
390
391         Vector<ValueStringPair>::iterator vectorEnd = tempSortingVector->end();
392         for (Vector<ValueStringPair>::iterator vectorIt = tempSortingVector->begin(); vectorIt != vectorEnd; ++vectorIt) {
393             if (vectorIt->first)
394                 heapRootVisitor.visit(&vectorIt->first);
395         }
396     }
397 }
398
399 void Heap::harvestWeakReferences()
400 {
401     m_slotVisitor.harvestWeakReferences();
402 }
403
404 void Heap::finalizeUnconditionalFinalizers()
405 {
406     m_slotVisitor.finalizeUnconditionalFinalizers();
407 }
408
409 inline RegisterFile& Heap::registerFile()
410 {
411     return m_globalData->interpreter->registerFile();
412 }
413
414 void Heap::getConservativeRegisterRoots(HashSet<JSCell*>& roots)
415 {
416     ASSERT(isValidThreadState(m_globalData));
417     if (m_operationInProgress != NoOperation)
418         CRASH();
419     m_operationInProgress = Collection;
420     ConservativeRoots registerFileRoots(&m_objectSpace.blocks(), &m_storageSpace);
421     registerFile().gatherConservativeRoots(registerFileRoots);
422     size_t registerFileRootCount = registerFileRoots.size();
423     JSCell** registerRoots = registerFileRoots.roots();
424     for (size_t i = 0; i < registerFileRootCount; i++) {
425         setMarked(registerRoots[i]);
426         roots.add(registerRoots[i]);
427     }
428     m_operationInProgress = NoOperation;
429 }
430
431 void Heap::markRoots(bool fullGC)
432 {
433     SamplingRegion samplingRegion("Garbage Collection: Tracing");
434
435     COND_GCPHASE(fullGC, MarkFullRoots, MarkYoungRoots);
436     UNUSED_PARAM(fullGC);
437     ASSERT(isValidThreadState(m_globalData));
438     if (m_operationInProgress != NoOperation)
439         CRASH();
440     m_operationInProgress = Collection;
441
442     void* dummy;
443     
444     // We gather conservative roots before clearing mark bits because conservative
445     // gathering uses the mark bits to determine whether a reference is valid.
446     ConservativeRoots machineThreadRoots(&m_objectSpace.blocks(), &m_storageSpace);
447     {
448         GCPHASE(GatherConservativeRoots);
449         m_machineThreads.gatherConservativeRoots(machineThreadRoots, &dummy);
450     }
451
452     ConservativeRoots registerFileRoots(&m_objectSpace.blocks(), &m_storageSpace);
453     m_dfgCodeBlocks.clearMarks();
454     {
455         GCPHASE(GatherRegisterFileRoots);
456         registerFile().gatherConservativeRoots(registerFileRoots, m_dfgCodeBlocks);
457     }
458
459 #if ENABLE(DFG_JIT)
460     ConservativeRoots scratchBufferRoots(&m_objectSpace.blocks(), &m_storageSpace);
461     {
462         GCPHASE(GatherScratchBufferRoots);
463         m_globalData->gatherConservativeRoots(scratchBufferRoots);
464     }
465 #endif
466
467 #if ENABLE(GGC)
468     MarkedBlock::DirtyCellVector dirtyCells;
469     if (!fullGC) {
470         GCPHASE(GatheringDirtyCells);
471         m_objectSpace.gatherDirtyCells(dirtyCells);
472     } else
473 #endif
474     {
475         GCPHASE(clearMarks);
476         m_objectSpace.clearMarks();
477     }
478
479     m_storageSpace.startedCopying();
480     SlotVisitor& visitor = m_slotVisitor;
481     HeapRootVisitor heapRootVisitor(visitor);
482
483     {
484         ParallelModeEnabler enabler(visitor);
485 #if ENABLE(GGC)
486         {
487             size_t dirtyCellCount = dirtyCells.size();
488             GCPHASE(VisitDirtyCells);
489             GCCOUNTER(DirtyCellCount, dirtyCellCount);
490             for (size_t i = 0; i < dirtyCellCount; i++) {
491                 heapRootVisitor.visitChildren(dirtyCells[i]);
492                 visitor.donateAndDrain();
493             }
494         }
495 #endif
496     
497         if (m_globalData->codeBlocksBeingCompiled.size()) {
498             GCPHASE(VisitActiveCodeBlock);
499             for (size_t i = 0; i < m_globalData->codeBlocksBeingCompiled.size(); i++)
500                 m_globalData->codeBlocksBeingCompiled[i]->visitAggregate(visitor);
501         }
502     
503         {
504             GCPHASE(VisitMachineRoots);
505             visitor.append(machineThreadRoots);
506             visitor.donateAndDrain();
507         }
508         {
509             GCPHASE(VisitRegisterFileRoots);
510             visitor.append(registerFileRoots);
511             visitor.donateAndDrain();
512         }
513 #if ENABLE(DFG_JIT)
514         {
515             GCPHASE(VisitScratchBufferRoots);
516             visitor.append(scratchBufferRoots);
517             visitor.donateAndDrain();
518         }
519 #endif
520         {
521             GCPHASE(VisitProtectedObjects);
522             markProtectedObjects(heapRootVisitor);
523             visitor.donateAndDrain();
524         }
525         {
526             GCPHASE(VisitTempSortVectors);
527             markTempSortVectors(heapRootVisitor);
528             visitor.donateAndDrain();
529         }
530
531         {
532             GCPHASE(MarkingArgumentBuffers);
533             if (m_markListSet && m_markListSet->size()) {
534                 MarkedArgumentBuffer::markLists(heapRootVisitor, *m_markListSet);
535                 visitor.donateAndDrain();
536             }
537         }
538         if (m_globalData->exception) {
539             GCPHASE(MarkingException);
540             heapRootVisitor.visit(&m_globalData->exception);
541             visitor.donateAndDrain();
542         }
543     
544         {
545             GCPHASE(VisitStrongHandles);
546             m_handleSet.visitStrongHandles(heapRootVisitor);
547             visitor.donateAndDrain();
548         }
549     
550         {
551             GCPHASE(HandleStack);
552             m_handleStack.visit(heapRootVisitor);
553             visitor.donateAndDrain();
554         }
555     
556         {
557             GCPHASE(TraceCodeBlocks);
558             m_dfgCodeBlocks.traceMarkedCodeBlocks(visitor);
559             visitor.donateAndDrain();
560         }
561     
562 #if ENABLE(PARALLEL_GC)
563         {
564             GCPHASE(Convergence);
565             visitor.drainFromShared(SlotVisitor::MasterDrain);
566         }
567 #endif
568     }
569
570     // Weak references must be marked last because their liveness depends on
571     // the liveness of the rest of the object graph.
572     {
573         GCPHASE(VisitingLiveWeakHandles);
574         while (true) {
575             m_weakSet.visitLiveWeakImpls(heapRootVisitor);
576             harvestWeakReferences();
577             if (visitor.isEmpty())
578                 break;
579             {
580                 ParallelModeEnabler enabler(visitor);
581                 visitor.donateAndDrain();
582 #if ENABLE(PARALLEL_GC)
583                 visitor.drainFromShared(SlotVisitor::MasterDrain);
584 #endif
585             }
586         }
587     }
588
589     {
590         GCPHASE(VisitingDeadWeakHandles);
591         m_weakSet.visitDeadWeakImpls(heapRootVisitor);
592     }
593
594     GCCOUNTER(VisitedValueCount, visitor.visitCount());
595
596     visitor.doneCopying();
597     visitor.reset();
598     m_sharedData.reset();
599     m_storageSpace.doneCopying();
600
601     m_operationInProgress = NoOperation;
602 }
603
604 size_t Heap::objectCount()
605 {
606     return m_objectSpace.objectCount();
607 }
608
609 size_t Heap::size()
610 {
611     return m_objectSpace.size() + m_storageSpace.size();
612 }
613
614 size_t Heap::capacity()
615 {
616     return m_objectSpace.capacity() + m_storageSpace.capacity();
617 }
618
619 size_t Heap::protectedGlobalObjectCount()
620 {
621     return forEachProtectedCell<CountIfGlobalObject>();
622 }
623
624 size_t Heap::globalObjectCount()
625 {
626     return m_objectSpace.forEachCell<CountIfGlobalObject>();
627 }
628
629 size_t Heap::protectedObjectCount()
630 {
631     return forEachProtectedCell<Count>();
632 }
633
634 PassOwnPtr<TypeCountSet> Heap::protectedObjectTypeCounts()
635 {
636     return forEachProtectedCell<RecordType>();
637 }
638
639 PassOwnPtr<TypeCountSet> Heap::objectTypeCounts()
640 {
641     return m_objectSpace.forEachCell<RecordType>();
642 }
643
644 void Heap::discardAllCompiledCode()
645 {
646     // If JavaScript is running, it's not safe to recompile, since we'll end
647     // up throwing away code that is live on the stack.
648     if (m_globalData->dynamicGlobalObject)
649         return;
650
651     for (FunctionExecutable* current = m_functions.head(); current; current = current->next())
652         current->discardCode();
653 }
654
655 void Heap::collectAllGarbage()
656 {
657     if (!m_isSafeToCollect)
658         return;
659
660     collect(DoSweep);
661 }
662
663 static double minute = 60.0;
664
665 void Heap::collect(SweepToggle sweepToggle)
666 {
667     SamplingRegion samplingRegion("Garbage Collection");
668     
669     GCPHASE(Collect);
670     ASSERT(globalData()->identifierTable == wtfThreadData().currentIdentifierTable());
671     ASSERT(m_isSafeToCollect);
672     JAVASCRIPTCORE_GC_BEGIN();
673
674     m_activityCallback->willCollect();
675
676     double lastGCStartTime = WTF::currentTime();
677     if (lastGCStartTime - m_lastCodeDiscardTime > minute) {
678         discardAllCompiledCode();
679         m_lastCodeDiscardTime = WTF::currentTime();
680     }
681
682 #if ENABLE(GGC)
683     bool fullGC = sweepToggle == DoSweep;
684     if (!fullGC)
685         fullGC = (capacity() > 4 * m_sizeAfterLastCollect);  
686 #else
687     bool fullGC = true;
688 #endif
689     {
690         GCPHASE(Canonicalize);
691         m_objectSpace.canonicalizeCellLivenessData();
692     }
693
694     markRoots(fullGC);
695     
696     {
697         GCPHASE(FinalizeUnconditionalFinalizers);
698         finalizeUnconditionalFinalizers();
699     }
700         
701     {
702         GCPHASE(FinalizeWeakHandles);
703         m_weakSet.sweep();
704         m_globalData->smallStrings.finalizeSmallStrings();
705     }
706     
707     JAVASCRIPTCORE_GC_MARKED();
708
709     {
710         GCPHASE(ResetAllocators);
711         m_objectSpace.resetAllocators();
712         m_weakSet.resetAllocator();
713     }
714     
715     {
716         GCPHASE(DeleteCodeBlocks);
717         m_dfgCodeBlocks.deleteUnmarkedJettisonedCodeBlocks();
718     }
719
720     if (sweepToggle == DoSweep) {
721         SamplingRegion samplingRegion("Garbage Collection: Sweeping");
722         GCPHASE(Sweeping);
723         m_objectSpace.sweep();
724         m_objectSpace.shrink();
725         m_weakSet.shrink();
726         m_bytesAbandoned = 0;
727     }
728
729     size_t currentHeapSize = size();
730     if (fullGC) {
731         m_sizeAfterLastCollect = currentHeapSize;
732
733         // To avoid pathological GC churn in very small and very large heaps, we set
734         // the new allocation limit based on the current size of the heap, with a
735         // fixed minimum.
736         size_t maxHeapSize = max(minHeapSize(m_heapType, m_ramSize), proportionalHeapSize(currentHeapSize, m_ramSize));
737         m_bytesAllocatedLimit = maxHeapSize - currentHeapSize;
738     }
739     m_bytesAllocated = 0;
740     double lastGCEndTime = WTF::currentTime();
741     m_lastGCLength = lastGCEndTime - lastGCStartTime;
742     JAVASCRIPTCORE_GC_END();
743 }
744
745 void Heap::setActivityCallback(PassOwnPtr<GCActivityCallback> activityCallback)
746 {
747     m_activityCallback = activityCallback;
748 }
749
750 GCActivityCallback* Heap::activityCallback()
751 {
752     return m_activityCallback.get();
753 }
754
755 void Heap::setGarbageCollectionTimerEnabled(bool enable)
756 {
757     activityCallback()->setEnabled(enable);
758 }
759
760 void Heap::didAllocate(size_t bytes)
761 {
762     m_activityCallback->didAllocate(m_bytesAllocated + m_bytesAbandoned);
763     m_bytesAllocated += bytes;
764 }
765
766 bool Heap::isValidAllocation(size_t bytes)
767 {
768     if (!isValidThreadState(m_globalData))
769         return false;
770
771     if (bytes > MarkedSpace::maxCellSize)
772         return false;
773
774     if (m_operationInProgress != NoOperation)
775         return false;
776     
777     return true;
778 }
779
780 void Heap::addFinalizer(JSCell* cell, Finalizer finalizer)
781 {
782     WeakSet::allocate(cell, &m_finalizerOwner, reinterpret_cast<void*>(finalizer)); // Balanced by FinalizerOwner::finalize().
783 }
784
785 void Heap::FinalizerOwner::finalize(Handle<Unknown> handle, void* context)
786 {
787     HandleSlot slot = handle.slot();
788     Finalizer finalizer = reinterpret_cast<Finalizer>(context);
789     finalizer(slot->asCell());
790     WeakSet::deallocate(WeakImpl::asWeakImpl(slot));
791 }
792
793 void Heap::addFunctionExecutable(FunctionExecutable* executable)
794 {
795     m_functions.append(executable);
796 }
797
798 void Heap::removeFunctionExecutable(FunctionExecutable* executable)
799 {
800     m_functions.remove(executable);
801 }
802
803 } // namespace JSC