heap/MarkedSpace.cpp

   1 /*
   2  *  Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
   3  *  Copyright (C) 2007 Eric Seidel <eric@webkit.org>
   4  *
   5  *  This library is free software; you can redistribute it and/or
   6  *  modify it under the terms of the GNU Lesser General Public
   7  *  License as published by the Free Software Foundation; either
   8  *  version 2 of the License, or (at your option) any later version.
   9  *
  10  *  This library is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  *  Lesser General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU Lesser General Public
  16  *  License along with this library; if not, write to the Free Software
  17  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  18  *
  19  */
  20
  21 #include "config.h"
  22 #include "MarkedSpace.h"
  23
  24 #include "JSGlobalObject.h"
  25 #include "JSCell.h"
  26 #include "JSGlobalData.h"
  27 #include "JSLock.h"
  28 #include "JSObject.h"
  29 #include "ScopeChain.h"
  30
  31 namespace JSC {
  32
  33 class Structure;
  34
  35 MarkedSpace::MarkedSpace(JSGlobalData* globalData)
  36     : m_waterMark(0)
  37     , m_highWaterMark(0)
  38     , m_globalData(globalData)
  39 {
  40     for (size_t cellSize = preciseStep; cellSize < preciseCutoff; cellSize += preciseStep)
  41         sizeClassFor(cellSize).cellSize = cellSize;
  42
  43     for (size_t cellSize = impreciseStep; cellSize < impreciseCutoff; cellSize += impreciseStep)
  44         sizeClassFor(cellSize).cellSize = cellSize;
  45 }
  46
  47 void MarkedSpace::destroy()
  48 {
  49     clearMarks();
  50     shrink();
  51     ASSERT(!size());
  52 }
  53
  54 MarkedBlock* MarkedSpace::allocateBlock(SizeClass& sizeClass)
  55 {
  56     MarkedBlock* block = MarkedBlock::create(globalData(), sizeClass.cellSize);
  57     sizeClass.blockList.append(block);
  58     sizeClass.nextBlock = block;
  59     m_blocks.add(block);
  60
  61     return block;
  62 }
  63
  64 void MarkedSpace::freeBlocks(DoublyLinkedList<MarkedBlock>& blocks)
  65 {
  66     MarkedBlock* next;
  67     for (MarkedBlock* block = blocks.head(); block; block = next) {
  68         next = block->next();
  69
  70         blocks.remove(block);
  71         m_blocks.remove(block);
  72         MarkedBlock::destroy(block);
  73     }
  74 }
  75
  76 void* MarkedSpace::allocateFromSizeClass(SizeClass& sizeClass)
  77 {
  78     for (MarkedBlock*& block = sizeClass.nextBlock ; block; block = block->next()) {
  79         if (void* result = block->allocate())
  80             return result;
  81
  82         m_waterMark += block->capacity();
  83     }
  84
  85     if (m_waterMark < m_highWaterMark)
  86         return allocateBlock(sizeClass)->allocate();
  87
  88     return 0;
  89 }
  90
  91 void MarkedSpace::shrink()
  92 {
  93     // We record a temporary list of empties to avoid modifying m_blocks while iterating it.
  94     DoublyLinkedList<MarkedBlock> empties;
  95
  96     BlockIterator end = m_blocks.end();
  97     for (BlockIterator it = m_blocks.begin(); it != end; ++it) {
  98         MarkedBlock* block = *it;
  99         if (block->isEmpty()) {
 100             SizeClass& sizeClass = sizeClassFor(block->cellSize());
 101             sizeClass.blockList.remove(block);
 102             sizeClass.nextBlock = sizeClass.blockList.head();
 103             empties.append(block);
 104         }
 105     }
 106
 107     freeBlocks(empties);
 108     ASSERT(empties.isEmpty());
 109 }
 110
 111 void MarkedSpace::clearMarks()
 112 {
 113     BlockIterator end = m_blocks.end();
 114     for (BlockIterator it = m_blocks.begin(); it != end; ++it)
 115         (*it)->clearMarks();
 116 }
 117
 118 void MarkedSpace::sweep()
 119 {
 120     BlockIterator end = m_blocks.end();
 121     for (BlockIterator it = m_blocks.begin(); it != end; ++it)
 122         (*it)->sweep();
 123 }
 124
 125 size_t MarkedSpace::objectCount() const
 126 {
 127     size_t result = 0;
 128     BlockIterator end = m_blocks.end();
 129     for (BlockIterator it = m_blocks.begin(); it != end; ++it)
 130         result += (*it)->markCount();
 131     return result;
 132 }
 133
 134 size_t MarkedSpace::size() const
 135 {
 136     size_t result = 0;
 137     BlockIterator end = m_blocks.end();
 138     for (BlockIterator it = m_blocks.begin(); it != end; ++it)
 139         result += (*it)->size();
 140     return result;
 141 }
 142
 143 size_t MarkedSpace::capacity() const
 144 {
 145     size_t result = 0;
 146     BlockIterator end = m_blocks.end();
 147     for (BlockIterator it = m_blocks.begin(); it != end; ++it)
 148         result += (*it)->capacity();
 149     return result;
 150 }
 151
 152 void MarkedSpace::reset()
 153 {
 154     m_waterMark = 0;
 155
 156     for (size_t cellSize = preciseStep; cellSize < preciseCutoff; cellSize += preciseStep)
 157         sizeClassFor(cellSize).reset();
 158
 159     for (size_t cellSize = impreciseStep; cellSize < impreciseCutoff; cellSize += impreciseStep)
 160         sizeClassFor(cellSize).reset();
 161
 162     BlockIterator end = m_blocks.end();
 163     for (BlockIterator it = m_blocks.begin(); it != end; ++it)
 164         (*it)->reset();
 165 }
 166
 167 } // namespace JSC