Start using store buffers. Handle store buffer overflow situation....

src/spaces-inl.h

 // Copyright 2006-2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 65 matching lines @@
 
 
 void Page::SetAllocationWatermark(Address allocation_watermark) {
   if ((Heap::gc_state() == Heap::SCAVENGE) && IsWatermarkValid()) {
     // When iterating intergenerational references during scavenge
     // we might decide to promote an encountered young object.
     // We will allocate a space for such an object and put it
     // into the promotion queue to process it later.
     // If space for object was allocated somewhere beyond allocation
     // watermark this might cause garbage pointers to appear under allocation
-    // watermark. To avoid visiting them during dirty regions iteration
+    // watermark. To avoid visiting them during pointer-to-newspace iteration
     // which might be still in progress we store a valid allocation watermark
     // value and mark this page as having an invalid watermark.
     SetCachedAllocationWatermark(AllocationWatermark());
     InvalidateWatermark(true);
   }
 
   flags_ = (flags_ & kFlagsMask) |
            Offset(allocation_watermark) << kAllocationWatermarkOffsetShift;
   ASSERT(AllocationWatermarkOffset()
          == static_cast<uint32_t>(Offset(allocation_watermark)));
 }
 
 
 void Page::SetCachedAllocationWatermark(Address allocation_watermark) {
   allocation_watermark_ = allocation_watermark;
 }
 
 
 Address Page::CachedAllocationWatermark() {
   return allocation_watermark_;
 }
 
 
-uint32_t Page::GetRegionMarks() {
-#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
-  return dirty_regions_;
-#else
-  return kAllRegionsDirtyMarks;
-#endif
-}
-
-
-void Page::SetRegionMarks(uint32_t marks) {
-#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
-  dirty_regions_ = marks;
-#endif
-}
-
-
-int Page::GetRegionNumberForAddress(Address addr) {
-#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
-  // Each page is divided into 256 byte regions. Each region has a corresponding
-  // dirty mark bit in the page header. Region can contain intergenerational
-  // references iff its dirty mark is set.
-  // A normal 8K page contains exactly 32 regions so all region marks fit
-  // into 32-bit integer field. To calculate a region number we just divide
-  // offset inside page by region size.
-  // A large page can contain more then 32 regions. But we want to avoid
-  // additional write barrier code for distinguishing between large and normal
-  // pages so we just ignore the fact that addr points into a large page and
-  // calculate region number as if addr pointed into a normal 8K page. This way
-  // we get a region number modulo 32 so for large pages several regions might
-  // be mapped to a single dirty mark.
-  ASSERT_PAGE_ALIGNED(this->address());
-  STATIC_ASSERT((kPageAlignmentMask >> kRegionSizeLog2) < kBitsPerInt);
-
-  // We are using masking with kPageAlignmentMask instead of Page::Offset()
-  // to get an offset to the beginning of 8K page containing addr not to the
-  // beginning of actual page which can be bigger then 8K.
-  intptr_t offset_inside_normal_page = OffsetFrom(addr) & kPageAlignmentMask;
-  return static_cast<int>(offset_inside_normal_page >> kRegionSizeLog2);
-#else
-  return 0;
-#endif
-}
-
-
-uint32_t Page::GetRegionMaskForAddress(Address addr) {
-  return 1 << GetRegionNumberForAddress(addr);
-}
-
-
-uint32_t Page::GetRegionMaskForSpan(Address start, int length_in_bytes) {
-#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
-  uint32_t result = 0;
-  if (length_in_bytes >= kPageSize) {
-    result = kAllRegionsDirtyMarks;
-  } else if (length_in_bytes > 0) {
-    int start_region = GetRegionNumberForAddress(start);
-    int end_region =
-        GetRegionNumberForAddress(start + length_in_bytes - kPointerSize);
-    uint32_t start_mask = (~0) << start_region;
-    uint32_t end_mask = ~((~1) << end_region);
-    result = start_mask & end_mask;
-    // if end_region < start_region, the mask is ored.
-    if (result == 0) result = start_mask | end_mask;
-  }
-#ifdef DEBUG
-  if (FLAG_enable_slow_asserts) {
-    uint32_t expected = 0;
-    for (Address a = start; a < start + length_in_bytes; a += kPointerSize) {
-      expected |= GetRegionMaskForAddress(a);
-    }
-    ASSERT(expected == result);
-  }
-#endif
-  return result;
-#else
-  return Page::kAllRegionsDirtyMarks;
-#endif
-}
-
-
-void Page::MarkRegionDirty(Address address) {
-  SetRegionMarks(GetRegionMarks() | GetRegionMaskForAddress(address));
-}
-
-
-bool Page::IsRegionDirty(Address address) {
-  return GetRegionMarks() & GetRegionMaskForAddress(address);
-}
-
-
-void Page::ClearRegionMarks(Address start, Address end, bool reaches_limit) {
-#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
-  int rstart = GetRegionNumberForAddress(start);
-  int rend = GetRegionNumberForAddress(end);
-
-  if (reaches_limit) {
-    end += 1;
-  }
-
-  if ((rend - rstart) == 0) {
-    return;
-  }
-
-  uint32_t bitmask = 0;
-
-  if ((OffsetFrom(start) & kRegionAlignmentMask) == 0
-      || (start == ObjectAreaStart())) {
-    // First region is fully covered
-    bitmask = 1 << rstart;
-  }
-
-  while (++rstart < rend) {
-    bitmask |= 1 << rstart;
-  }
-
-  if (bitmask) {
-    SetRegionMarks(GetRegionMarks() & ~bitmask);
-  }
-#endif
-}
-
-
 void Page::FlipMeaningOfInvalidatedWatermarkFlag() {
   watermark_invalidated_mark_ ^= 1 << WATERMARK_INVALIDATED;
 }
 
 
 bool Page::IsWatermarkValid() {
   return (flags_ & (1 << WATERMARK_INVALIDATED)) != watermark_invalidated_mark_;
 }
 
 
 void Page::InvalidateWatermark(bool value) {
   if (value) {
     flags_ = (flags_ & ~(1 << WATERMARK_INVALIDATED)) |
              watermark_invalidated_mark_;
   } else {
     flags_ = (flags_ & ~(1 << WATERMARK_INVALIDATED)) |
              (watermark_invalidated_mark_ ^ (1 << WATERMARK_INVALIDATED));
   }
 
   ASSERT(IsWatermarkValid() == !value);
 }
 
 
 void Page::ClearGCFields() {
   InvalidateWatermark(true);
   SetAllocationWatermark(ObjectAreaStart());
   if (Heap::gc_state() == Heap::SCAVENGE) {
     SetCachedAllocationWatermark(ObjectAreaStart());
   }
-  SetRegionMarks(kAllRegionsCleanMarks);
 }
 
 
 // -----------------------------------------------------------------------------
 // MemoryAllocator
 
 #ifdef ENABLE_HEAP_PROTECTION
 
 void MemoryAllocator::Protect(Address start, size_t size) {
   OS::Protect(start, size);
@@ skipping 98 matching lines @@
 
 bool FreeListNode::IsFreeListNode(HeapObject* object) {
   return object->map() == Heap::raw_unchecked_byte_array_map()
       || object->map() == Heap::raw_unchecked_one_pointer_filler_map()
       || object->map() == Heap::raw_unchecked_two_pointer_filler_map();
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_INL_H_