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