91a7e8849a8bd68dd632edf8b035a40284ac11b5
[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 JSCell;
36     class JSGlobalData;
37     class JSValue;
38     class JSValue;
39     class LiveObjectIterator;
40     class MarkStack;
41     class MarkedArgumentBuffer;
42     class RegisterFile;
43     class UString;
44     class WeakGCHandlePool;
45
46     typedef std::pair<JSValue, UString> ValueStringPair;
47     typedef HashCountedSet<JSCell*> ProtectCountSet;
48
49     enum OperationInProgress { NoOperation, Allocation, Collection };
50
51     class Heap {
52         WTF_MAKE_NONCOPYABLE(Heap);
53     public:
54         static Heap* heap(JSValue); // 0 for immediate values
55         static Heap* heap(JSCell*);
56
57         static bool isCellMarked(const JSCell*);
58         static bool checkMarkCell(const JSCell*);
59         static void markCell(JSCell*);
60         
61         Heap(JSGlobalData*);
62         ~Heap();
63         void destroy(); // JSGlobalData must call destroy() before ~Heap().
64
65         JSGlobalData* globalData() const { return m_globalData; }
66         MarkedSpace& markedSpace() { return m_markedSpace; }
67         MachineStackMarker& machineStackMarker() { return m_machineStackMarker; }
68
69         GCActivityCallback* activityCallback();
70         void setActivityCallback(PassOwnPtr<GCActivityCallback>);
71
72         bool isBusy(); // true if an allocation or collection is in progress
73         void* allocate(size_t);
74         void collectAllGarbage();
75
76         void reportExtraMemoryCost(size_t cost);
77
78         void protect(JSValue);
79         bool unprotect(JSValue); // True when the protect count drops to 0.
80
81         bool contains(void*);
82
83         size_t size() const;
84         size_t capacity() const;
85         size_t objectCount() const;
86         size_t globalObjectCount();
87         size_t protectedObjectCount();
88         size_t protectedGlobalObjectCount();
89         HashCountedSet<const char*>* protectedObjectTypeCounts();
90         HashCountedSet<const char*>* objectTypeCounts();
91
92         WeakGCHandle* addWeakGCHandle(JSCell*);
93
94         void pushTempSortVector(WTF::Vector<ValueStringPair>*);
95         void popTempSortVector(WTF::Vector<ValueStringPair>*);        
96
97         HashSet<MarkedArgumentBuffer*>& markListSet() { if (!m_markListSet) m_markListSet = new HashSet<MarkedArgumentBuffer*>; return *m_markListSet; }
98
99         LiveObjectIterator primaryHeapBegin();
100         LiveObjectIterator primaryHeapEnd();
101         
102     private:
103         friend class JSGlobalData;
104
105         static const size_t minExtraCost = 256;
106         static const size_t maxExtraCost = 1024 * 1024;
107
108         void reportExtraMemoryCostSlowCase(size_t);
109
110         void markRoots();
111         void markProtectedObjects(MarkStack&);
112         void markTempSortVectors(MarkStack&);
113
114         void updateWeakGCHandles();
115         WeakGCHandlePool* weakGCHandlePool(size_t index);
116         
117         enum SweepToggle { DoNotSweep, DoSweep };
118         void reset(SweepToggle);
119
120         RegisterFile& registerFile();
121
122         MarkedSpace m_markedSpace;
123         OperationInProgress m_operationInProgress;
124
125         ProtectCountSet m_protectedValues;
126         WTF::Vector<PageAllocationAligned> m_weakGCHandlePools;
127         WTF::Vector<WTF::Vector<ValueStringPair>* > m_tempSortingVectors;
128
129         HashSet<MarkedArgumentBuffer*>* m_markListSet;
130
131         OwnPtr<GCActivityCallback> m_activityCallback;
132
133         JSGlobalData* m_globalData;
134         
135         MachineStackMarker m_machineStackMarker;
136         MarkStack m_markStack;
137         
138         size_t m_extraCost;
139     };
140
141     inline bool Heap::isCellMarked(const JSCell* cell)
142     {
143         return MarkedSpace::isCellMarked(cell);
144     }
145
146     inline bool Heap::checkMarkCell(const JSCell* cell)
147     {
148         return MarkedSpace::checkMarkCell(cell);
149     }
150
151     inline void Heap::markCell(JSCell* cell)
152     {
153         MarkedSpace::markCell(cell);
154     }
155
156     inline bool Heap::contains(void* p)
157     {
158         return m_markedSpace.contains(p);
159     }
160
161     inline void Heap::reportExtraMemoryCost(size_t cost)
162     {
163         if (cost > minExtraCost) 
164             reportExtraMemoryCostSlowCase(cost);
165     }
166     
167     inline WeakGCHandlePool* Heap::weakGCHandlePool(size_t index)
168     {
169         return static_cast<WeakGCHandlePool*>(m_weakGCHandlePools[index].base());
170     }
171
172 } // namespace JSC
173
174 #endif // Heap_h