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