2011-02-04 Geoffrey Garen <ggaren@apple.com>
[WebKit.git] / Source / JavaScriptCore / runtime / Heap.h
1 /*
2  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
4  *  Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
5  *
6  *  This library is free software; you can redistribute it and/or
7  *  modify it under the terms of the GNU Lesser General Public
8  *  License as published by the Free Software Foundation; either
9  *  version 2 of the License, or (at your option) any later version.
10  *
11  *  This library is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  *  Lesser General Public License for more details.
15  *
16  *  You should have received a copy of the GNU Lesser General Public
17  *  License along with this library; if not, write to the Free Software
18  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
19  *
20  */
21
22 #ifndef Heap_h
23 #define Heap_h
24
25 #include "MarkStack.h"
26 #include "MarkedSpace.h"
27 #include <wtf/Forward.h>
28 #include <wtf/HashSet.h>
29
30 #define ASSERT_CLASS_FITS_IN_CELL(class) COMPILE_ASSERT(sizeof(class) <= CELL_SIZE, class_fits_in_cell)
31
32 namespace JSC {
33
34     class GCActivityCallback;
35     class GlobalCodeBlock;
36     class JSCell;
37     class JSGlobalData;
38     class JSValue;
39     class JSValue;
40     class LiveObjectIterator;
41     class MarkStack;
42     class MarkedArgumentBuffer;
43     class RegisterFile;
44     class UString;
45     class WeakGCHandlePool;
46
47     typedef std::pair<JSValue, UString> ValueStringPair;
48     typedef HashCountedSet<JSCell*> ProtectCountSet;
49
50     enum OperationInProgress { NoOperation, Allocation, Collection };
51
52     class Heap {
53         WTF_MAKE_NONCOPYABLE(Heap);
54     public:
55         static Heap* heap(JSValue); // 0 for immediate values
56         static Heap* heap(JSCell*);
57
58         static bool isMarked(const JSCell*);
59         static bool testAndSetMarked(const JSCell*);
60         static void setMarked(JSCell*);
61         
62         Heap(JSGlobalData*);
63         ~Heap();
64         void destroy(); // JSGlobalData must call destroy() before ~Heap().
65
66         JSGlobalData* globalData() const { return m_globalData; }
67         MarkedSpace& markedSpace() { return m_markedSpace; }
68         MachineStackMarker& machineStackMarker() { return m_machineStackMarker; }
69
70         GCActivityCallback* activityCallback();
71         void setActivityCallback(PassOwnPtr<GCActivityCallback>);
72
73         bool isBusy(); // true if an allocation or collection is in progress
74         void* allocate(size_t);
75         void collectAllGarbage();
76
77         void reportExtraMemoryCost(size_t cost);
78
79         void protect(JSValue);
80         bool unprotect(JSValue); // True when the protect count drops to 0.
81
82         bool contains(void*);
83
84         size_t size() const;
85         size_t capacity() const;
86         size_t objectCount() const;
87         size_t globalObjectCount();
88         size_t protectedObjectCount();
89         size_t protectedGlobalObjectCount();
90         HashCountedSet<const char*>* protectedObjectTypeCounts();
91         HashCountedSet<const char*>* objectTypeCounts();
92
93         WeakGCHandle* addWeakGCHandle(JSCell*);
94
95         void pushTempSortVector(Vector<ValueStringPair>*);
96         void popTempSortVector(Vector<ValueStringPair>*);
97         
98         HashSet<GlobalCodeBlock*>& codeBlocks() { return m_codeBlocks; }
99
100         HashSet<MarkedArgumentBuffer*>& markListSet() { if (!m_markListSet) m_markListSet = new HashSet<MarkedArgumentBuffer*>; return *m_markListSet; }
101
102         LiveObjectIterator primaryHeapBegin();
103         LiveObjectIterator primaryHeapEnd();
104         
105     private:
106         friend class JSGlobalData;
107
108         static const size_t minExtraCost = 256;
109         static const size_t maxExtraCost = 1024 * 1024;
110
111         void reportExtraMemoryCostSlowCase(size_t);
112
113         void markRoots();
114         void markProtectedObjects(MarkStack&);
115         void markTempSortVectors(MarkStack&);
116
117         void updateWeakGCHandles();
118         WeakGCHandlePool* weakGCHandlePool(size_t index);
119         
120         enum SweepToggle { DoNotSweep, DoSweep };
121         void reset(SweepToggle);
122
123         RegisterFile& registerFile();
124
125         OperationInProgress m_operationInProgress;
126         MarkedSpace m_markedSpace;
127
128         ProtectCountSet m_protectedValues;
129         Vector<PageAllocationAligned> m_weakGCHandlePools;
130         Vector<Vector<ValueStringPair>* > m_tempSortingVectors;
131         HashSet<GlobalCodeBlock*> m_codeBlocks;
132
133         HashSet<MarkedArgumentBuffer*>* m_markListSet;
134
135         OwnPtr<GCActivityCallback> m_activityCallback;
136
137         JSGlobalData* m_globalData;
138         
139         MachineStackMarker m_machineStackMarker;
140         MarkStack m_markStack;
141         
142         size_t m_extraCost;
143     };
144
145     inline bool Heap::isMarked(const JSCell* cell)
146     {
147         return MarkedSpace::isMarked(cell);
148     }
149
150     inline bool Heap::testAndSetMarked(const JSCell* cell)
151     {
152         return MarkedSpace::testAndSetMarked(cell);
153     }
154
155     inline void Heap::setMarked(JSCell* cell)
156     {
157         MarkedSpace::setMarked(cell);
158     }
159
160     inline bool Heap::contains(void* p)
161     {
162         return m_markedSpace.contains(p);
163     }
164
165     inline void Heap::reportExtraMemoryCost(size_t cost)
166     {
167         if (cost > minExtraCost) 
168             reportExtraMemoryCostSlowCase(cost);
169     }
170     
171     inline WeakGCHandlePool* Heap::weakGCHandlePool(size_t index)
172     {
173         return static_cast<WeakGCHandlePool*>(m_weakGCHandlePools[index].base());
174     }
175
176 } // namespace JSC
177
178 #endif // Heap_h