runtime/CollectorHeapIterator.h

   1 /*
   2  * Copyright (C) 2008, 2009 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "Collector.h"
  28
  29 #ifndef CollectorHeapIterator_h
  30 #define CollectorHeapIterator_h
  31
  32 namespace JSC {
  33
  34     class CollectorHeapIterator {
  35     public:
  36         bool operator!=(const CollectorHeapIterator& other);
  37         JSCell* operator*() const;
  38
  39     protected:
  40         CollectorHeapIterator(CollectorHeap&, size_t startBlock, size_t startCell);
  41         void advance(size_t cellsPerBlock);
  42
  43         CollectorHeap& m_heap;
  44         size_t m_block;
  45         size_t m_cell;
  46     };
  47
  48     class LiveObjectIterator : public CollectorHeapIterator {
  49     public:
  50         LiveObjectIterator(CollectorHeap&, size_t startBlock, size_t startCell = 0);
  51         LiveObjectIterator& operator++();
  52     };
  53
  54     class DeadObjectIterator : public CollectorHeapIterator {
  55     public:
  56         DeadObjectIterator(CollectorHeap&, size_t startBlock, size_t startCell = 0);
  57         DeadObjectIterator& operator++();
  58     };
  59
  60     class ObjectIterator : public CollectorHeapIterator {
  61     public:
  62         ObjectIterator(CollectorHeap&, size_t startBlock, size_t startCell = 0);
  63         ObjectIterator& operator++();
  64     };
  65
  66     inline CollectorHeapIterator::CollectorHeapIterator(CollectorHeap& heap, size_t startBlock, size_t startCell)
  67         : m_heap(heap)
  68         , m_block(startBlock)
  69         , m_cell(startCell)
  70     {
  71     }
  72
  73     inline bool CollectorHeapIterator::operator!=(const CollectorHeapIterator& other)
  74     {
  75         return m_block != other.m_block || m_cell != other.m_cell;
  76     }
  77
  78     inline JSCell* CollectorHeapIterator::operator*() const
  79     {
  80         return reinterpret_cast<JSCell*>(m_heap.blocks[m_block]->cells + m_cell);
  81     }
  82
  83     inline void CollectorHeapIterator::advance(size_t cellsPerBlock)
  84     {
  85         ++m_cell;
  86         if (m_cell == cellsPerBlock) {
  87             m_cell = 0;
  88             ++m_block;
  89         }
  90     }
  91
  92     inline LiveObjectIterator::LiveObjectIterator(CollectorHeap& heap, size_t startBlock, size_t startCell)
  93         : CollectorHeapIterator(heap, startBlock, startCell - 1)
  94     {
  95         ++(*this);
  96     }
  97
  98     inline LiveObjectIterator& LiveObjectIterator::operator++()
  99     {
 100         if (m_block < m_heap.nextBlock || m_cell < m_heap.nextCell) {
 101             advance(HeapConstants::cellsPerBlock);
 102             return *this;
 103         }
 104
 105         do {
 106             advance(HeapConstants::cellsPerBlock);
 107         } while (m_block < m_heap.usedBlocks && !m_heap.blocks[m_block]->marked.get(m_cell));
 108         return *this;
 109     }
 110
 111     inline DeadObjectIterator::DeadObjectIterator(CollectorHeap& heap, size_t startBlock, size_t startCell)
 112         : CollectorHeapIterator(heap, startBlock, startCell - 1)
 113     {
 114         ++(*this);
 115     }
 116
 117     inline DeadObjectIterator& DeadObjectIterator::operator++()
 118     {
 119         do {
 120             advance(HeapConstants::cellsPerBlock);
 121             ASSERT(m_block > m_heap.nextBlock || (m_block == m_heap.nextBlock && m_cell >= m_heap.nextCell));
 122         } while (m_block < m_heap.usedBlocks && m_heap.blocks[m_block]->marked.get(m_cell));
 123         return *this;
 124     }
 125
 126     inline ObjectIterator::ObjectIterator(CollectorHeap& heap, size_t startBlock, size_t startCell)
 127         : CollectorHeapIterator(heap, startBlock, startCell - 1)
 128     {
 129         ++(*this);
 130     }
 131
 132     inline ObjectIterator& ObjectIterator::operator++()
 133     {
 134         advance(HeapConstants::cellsPerBlock);
 135         return *this;
 136     }
 137
 138 } // namespace JSC
 139
 140 #endif // CollectorHeapIterator_h