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         RegisterFile& registerFile();
 118
 119         MarkedSpace m_markedSpace;
 120         OperationInProgress m_operationInProgress;
 121
 122         ProtectCountSet m_protectedValues;
 123         WTF::Vector<PageAllocationAligned> m_weakGCHandlePools;
 124         WTF::Vector<WTF::Vector<ValueStringPair>* > m_tempSortingVectors;
 125
 126         HashSet<MarkedArgumentBuffer*>* m_markListSet;
 127
 128         OwnPtr<GCActivityCallback> m_activityCallback;
 129
 130         JSGlobalData* m_globalData;
 131
 132         MachineStackMarker m_machineStackMarker;
 133         MarkStack m_markStack;
 134
 135         size_t m_extraCost;
 136     };
 137
 138     inline bool Heap::isCellMarked(const JSCell* cell)
 139     {
 140         return MarkedSpace::isCellMarked(cell);
 141     }
 142
 143     inline bool Heap::checkMarkCell(const JSCell* cell)
 144     {
 145         return MarkedSpace::checkMarkCell(cell);
 146     }
 147
 148     inline void Heap::markCell(JSCell* cell)
 149     {
 150         MarkedSpace::markCell(cell);
 151     }
 152
 153     inline bool Heap::contains(void* p)
 154     {
 155         return m_markedSpace.contains(p);
 156     }
 157
 158     inline void Heap::reportExtraMemoryCost(size_t cost)
 159     {
 160         if (cost > minExtraCost)
 161             reportExtraMemoryCostSlowCase(cost);
 162     }
 163
 164     inline WeakGCHandlePool* Heap::weakGCHandlePool(size_t index)
 165     {
 166         return static_cast<WeakGCHandlePool*>(m_weakGCHandlePools[index].base());
 167     }
 168
 169 } // namespace JSC
 170
 171 #endif // Heap_h