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         MarkedSpace m_markedSpace;
 126         OperationInProgress m_operationInProgress;
 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