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