Home | History | Annotate | Download | only in src 
      1 // Copyright 2011 the V8 project authors. All rights reserved.
      2 // Redistribution and use in source and binary forms, with or without
      3 // modification, are permitted provided that the following conditions are
      4 // met:
      5 //
      6 //     * Redistributions of source code must retain the above copyright
      7 //       notice, this list of conditions and the following disclaimer.
      8 //     * Redistributions in binary form must reproduce the above
      9 //       copyright notice, this list of conditions and the following
     10 //       disclaimer in the documentation and/or other materials provided
     11 //       with the distribution.
     12 //     * Neither the name of Google Inc. nor the names of its
     13 //       contributors may be used to endorse or promote products derived
     14 //       from this software without specific prior written permission.
     15 //
     16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27 
     28 #ifndef V8_MARK_COMPACT_INL_H_
     29 #define V8_MARK_COMPACT_INL_H_
     30 
     31 #include "isolate.h"
     32 #include "memory.h"
     33 #include "mark-compact.h"
     34 
     35 
     36 namespace v8 {
     37 namespace internal {
     38 
     39 
     40 MarkBit Marking::MarkBitFrom(Address addr) {
     41   MemoryChunk* p = MemoryChunk::FromAddress(addr);
     42   return p->markbits()->MarkBitFromIndex(p->AddressToMarkbitIndex(addr),
     43                                          p->ContainsOnlyData());
     44 }
     45 
     46 
     47 void MarkCompactCollector::SetFlags(int flags) {
     48   sweep_precisely_ = ((flags & Heap::kSweepPreciselyMask) != 0);
     49   reduce_memory_footprint_ = ((flags & Heap::kReduceMemoryFootprintMask) != 0);
     50   abort_incremental_marking_ =
     51       ((flags & Heap::kAbortIncrementalMarkingMask) != 0);
     52 }
     53 
     54 
     55 void MarkCompactCollector::MarkObject(HeapObject* obj, MarkBit mark_bit) {
     56   ASSERT(Marking::MarkBitFrom(obj) == mark_bit);
     57   if (!mark_bit.Get()) {
     58     mark_bit.Set();
     59     MemoryChunk::IncrementLiveBytesFromGC(obj->address(), obj->Size());
     60     ProcessNewlyMarkedObject(obj);
     61   }
     62 }
     63 
     64 
     65 bool MarkCompactCollector::MarkObjectWithoutPush(HeapObject* object) {
     66   MarkBit mark = Marking::MarkBitFrom(object);
     67   bool old_mark = mark.Get();
     68   if (!old_mark) SetMark(object, mark);
     69   return old_mark;
     70 }
     71 
     72 
     73 void MarkCompactCollector::MarkObjectAndPush(HeapObject* object) {
     74   if (!MarkObjectWithoutPush(object)) marking_deque_.PushBlack(object);
     75 }
     76 
     77 
     78 void MarkCompactCollector::SetMark(HeapObject* obj, MarkBit mark_bit) {
     79   ASSERT(!mark_bit.Get());
     80   ASSERT(Marking::MarkBitFrom(obj) == mark_bit);
     81   mark_bit.Set();
     82   MemoryChunk::IncrementLiveBytesFromGC(obj->address(), obj->Size());
     83   if (obj->IsMap()) {
     84     heap_->ClearCacheOnMap(Map::cast(obj));
     85   }
     86 }
     87 
     88 
     89 bool MarkCompactCollector::IsMarked(Object* obj) {
     90   ASSERT(obj->IsHeapObject());
     91   HeapObject* heap_object = HeapObject::cast(obj);
     92   return Marking::MarkBitFrom(heap_object).Get();
     93 }
     94 
     95 
     96 void MarkCompactCollector::RecordSlot(Object** anchor_slot,
     97                                       Object** slot,
     98                                       Object* object) {
     99   Page* object_page = Page::FromAddress(reinterpret_cast<Address>(object));
    100   if (object_page->IsEvacuationCandidate() &&
    101       !ShouldSkipEvacuationSlotRecording(anchor_slot)) {
    102     if (!SlotsBuffer::AddTo(&slots_buffer_allocator_,
    103                             object_page->slots_buffer_address(),
    104                             slot,
    105                             SlotsBuffer::FAIL_ON_OVERFLOW)) {
    106       EvictEvacuationCandidate(object_page);
    107     }
    108   }
    109 }
    110 
    111 
    112 } }  // namespace v8::internal
    113 
    114 #endif  // V8_MARK_COMPACT_INL_H_
    115