[v8-dev] When adjusting page's live bytes counter from the mutator adjust owners unswept free bytes counter. (issue 9178021)

Tue, 17 Jan 2012 09:46:05 -0800 

Reviewers: Michael Starzinger,

Description:
When adjusting page's live bytes counter from the mutator adjust owners unswept 
free bytes counter.

[email protected]
BUG=
TEST=


Please review this at https://chromiumcodereview.appspot.com/9178021/

SVN Base: https://v8.googlecode.com/svn/branches/bleeding_edge

Affected files:
  M src/builtins.cc
  M src/heap.cc
  M src/incremental-marking-inl.h
  M src/incremental-marking.cc
  M src/mark-compact-inl.h
  M src/mark-compact.h
  M src/mark-compact.cc
  M src/objects.cc
  M src/runtime.cc
  M src/spaces-inl.h
  M src/spaces.h
  M src/spaces.cc


Index: src/builtins.cc
diff --git a/src/builtins.cc b/src/builtins.cc
index 69e5161ce518e50482bebefe1325ae5d4e6d24fc..90a8d3e1b843caa04ec42c00cc04457c13364c5c 100644 
--- a/src/builtins.cc
+++ b/src/builtins.cc
@@ -411,7 +411,7 @@ static FixedArray* LeftTrimFixedArray(Heap* heap,
   int size_delta = to_trim * kPointerSize;
   if (heap->marking()->TransferMark(elms->address(),
                                     elms->address() + size_delta)) {
-    MemoryChunk::IncrementLiveBytes(elms->address(), -size_delta);
+ MemoryChunk::IncrementLiveBytesFromMutator(elms->address(), -size_delta); 
   }

   return FixedArray::cast(HeapObject::FromAddress(
Index: src/heap.cc
diff --git a/src/heap.cc b/src/heap.cc
index 4ce355c38762440e90c8ef08386a407accc75137..b59eb50ddf760351b908a4d64555f0e50291d7ac 100644 
--- a/src/heap.cc
+++ b/src/heap.cc
@@ -1552,7 +1552,7 @@ class ScavengingVisitor : public StaticVisitorBase {

     if (marks_handling == TRANSFER_MARKS) {
       if (Marking::TransferColor(source, target)) {
-        MemoryChunk::IncrementLiveBytes(target->address(), size);
+        MemoryChunk::IncrementLiveBytesFromGC(target->address(), size);
       }
     }
   }
Index: src/incremental-marking-inl.h
diff --git a/src/incremental-marking-inl.h b/src/incremental-marking-inl.h
index 7ae2c99a0da282aca016d29ae2b92c9f9d181176..3e3d6c43fda9c1c97c7a30238d0add88bd8c1224 100644 
--- a/src/incremental-marking-inl.h
+++ b/src/incremental-marking-inl.h
@@ -95,7 +95,7 @@ void IncrementalMarking::BlackToGreyAndUnshift(HeapObject* obj, 
   ASSERT(IsMarking());
   Marking::BlackToGrey(mark_bit);
   int obj_size = obj->Size();
-  MemoryChunk::IncrementLiveBytes(obj->address(), -obj_size);
+  MemoryChunk::IncrementLiveBytesFromGC(obj->address(), -obj_size);
   bytes_scanned_ -= obj_size;
   int64_t old_bytes_rescanned = bytes_rescanned_;
   bytes_rescanned_ = old_bytes_rescanned + obj_size;
Index: src/incremental-marking.cc
diff --git a/src/incremental-marking.cc b/src/incremental-marking.cc
index f6d5a5963dbcbd24854f55963cd8db4270660668..6248524668186dc0fe2162abd347d38b0ab13257 100644 
--- a/src/incremental-marking.cc
+++ b/src/incremental-marking.cc
@@ -225,8 +225,8 @@ class IncrementalMarkingMarkingVisitor : public ObjectVisitor { 
     MarkBit mark_bit = Marking::MarkBitFrom(heap_object);
     if (mark_bit.data_only()) {
       if (incremental_marking_->MarkBlackOrKeepGrey(mark_bit)) {
-        MemoryChunk::IncrementLiveBytes(heap_object->address(),
-                                        heap_object->Size());
+        MemoryChunk::IncrementLiveBytesFromGC(heap_object->address(),
+                                              heap_object->Size());
       }
     } else if (Marking::IsWhite(mark_bit)) {
       incremental_marking_->WhiteToGreyAndPush(heap_object, mark_bit);
@@ -263,8 +263,8 @@ class IncrementalMarkingRootMarkingVisitor : public ObjectVisitor { 
     MarkBit mark_bit = Marking::MarkBitFrom(heap_object);
     if (mark_bit.data_only()) {
       if (incremental_marking_->MarkBlackOrKeepGrey(mark_bit)) {
-          MemoryChunk::IncrementLiveBytes(heap_object->address(),
-                                          heap_object->Size());
+          MemoryChunk::IncrementLiveBytesFromGC(heap_object->address(),
+                                                heap_object->Size());
       }
     } else {
       if (Marking::IsWhite(mark_bit)) {
@@ -491,8 +491,8 @@ static void MarkObjectGreyDoNotEnqueue(Object* obj) {
     HeapObject* heap_obj = HeapObject::cast(obj);
     MarkBit mark_bit = Marking::MarkBitFrom(HeapObject::cast(obj));
     if (Marking::IsBlack(mark_bit)) {
-      MemoryChunk::IncrementLiveBytes(heap_obj->address(),
-                                      -heap_obj->Size());
+      MemoryChunk::IncrementLiveBytesFromGC(heap_obj->address(),
+                                            -heap_obj->Size());
     }
     Marking::AnyToGrey(mark_bit);
   }
@@ -658,7 +658,7 @@ void IncrementalMarking::Hurry() {
       MarkBit mark_bit = Marking::MarkBitFrom(obj);
       ASSERT(!Marking::IsBlack(mark_bit));
       Marking::MarkBlack(mark_bit);
-      MemoryChunk::IncrementLiveBytes(obj->address(), obj->Size());
+      MemoryChunk::IncrementLiveBytesFromGC(obj->address(), obj->Size());
     }
     state_ = COMPLETE;
     if (FLAG_trace_incremental_marking) {
@@ -671,8 +671,8 @@ void IncrementalMarking::Hurry() {
   if (FLAG_cleanup_code_caches_at_gc) {
     PolymorphicCodeCache* poly_cache = heap_->polymorphic_code_cache();
     Marking::GreyToBlack(Marking::MarkBitFrom(poly_cache));
-    MemoryChunk::IncrementLiveBytes(poly_cache->address(),
-                                    PolymorphicCodeCache::kSize);
+    MemoryChunk::IncrementLiveBytesFromGC(poly_cache->address(),
+                                          PolymorphicCodeCache::kSize);
   }

   Object* context = heap_->global_contexts_list();
@@ -685,7 +685,7 @@ void IncrementalMarking::Hurry() {
       MarkBit mark_bit = Marking::MarkBitFrom(cache);
       if (Marking::IsGrey(mark_bit)) {
         Marking::GreyToBlack(mark_bit);
-        MemoryChunk::IncrementLiveBytes(cache->address(), cache->Size());
+ MemoryChunk::IncrementLiveBytesFromGC(cache->address(), cache->Size()); 
       }
     }
     context = Context::cast(context)->get(Context::NEXT_CONTEXT_LINK);
@@ -819,7 +819,7 @@ void IncrementalMarking::Step(intptr_t allocated_bytes) { 
       SLOW_ASSERT(Marking::IsGrey(obj_mark_bit) ||
                   (obj->IsFiller() && Marking::IsWhite(obj_mark_bit)));
       Marking::MarkBlack(obj_mark_bit);
-      MemoryChunk::IncrementLiveBytes(obj->address(), size);
+      MemoryChunk::IncrementLiveBytesFromGC(obj->address(), size);
     }
     if (marking_deque_.IsEmpty()) MarkingComplete();
   }
Index: src/mark-compact-inl.h
diff --git a/src/mark-compact-inl.h b/src/mark-compact-inl.h
index 573715e286a2f6a444ebd52e587d4a78157db48b..ae0e61f70165ccbec4719f2b1c44a68eb47a83b4 100644 
--- a/src/mark-compact-inl.h
+++ b/src/mark-compact-inl.h
@@ -53,7 +53,7 @@ void MarkCompactCollector::MarkObject(HeapObject* obj, MarkBit mark_bit) { 
   ASSERT(Marking::MarkBitFrom(obj) == mark_bit);
   if (!mark_bit.Get()) {
     mark_bit.Set();
-    MemoryChunk::IncrementLiveBytes(obj->address(), obj->Size());
+    MemoryChunk::IncrementLiveBytesFromGC(obj->address(), obj->Size());
     ProcessNewlyMarkedObject(obj);
   }
 }
@@ -63,7 +63,7 @@ void MarkCompactCollector::SetMark(HeapObject* obj, MarkBit mark_bit) { 
   ASSERT(!mark_bit.Get());
   ASSERT(Marking::MarkBitFrom(obj) == mark_bit);
   mark_bit.Set();
-  MemoryChunk::IncrementLiveBytes(obj->address(), obj->Size());
+  MemoryChunk::IncrementLiveBytesFromGC(obj->address(), obj->Size());
 }


Index: src/mark-compact.cc
diff --git a/src/mark-compact.cc b/src/mark-compact.cc
index 87e4bf9f04fedb3ad25a7859bd9a4e29a3179da1..7f08de9b831efd599e93b55b16354c904be410d8 100644 
--- a/src/mark-compact.cc
+++ b/src/mark-compact.cc
@@ -1641,8 +1641,8 @@ void MarkCompactCollector::MarkMapContents(Map* map) {
   MarkBit mark = Marking::MarkBitFrom(prototype_transitions);
   if (!mark.Get()) {
     mark.Set();
-    MemoryChunk::IncrementLiveBytes(prototype_transitions->address(),
-                                    prototype_transitions->Size());
+    MemoryChunk::IncrementLiveBytesFromGC(prototype_transitions->address(),
+                                          prototype_transitions->Size());
   }

   Object** raw_descriptor_array_slot =
@@ -1756,7 +1756,7 @@ static void DiscoverGreyObjectsWithIterator(Heap* heap, 
     MarkBit markbit = Marking::MarkBitFrom(object);
     if ((object->map() != filler_map) && Marking::IsGrey(markbit)) {
       Marking::GreyToBlack(markbit);
-      MemoryChunk::IncrementLiveBytes(object->address(), object->Size());
+ MemoryChunk::IncrementLiveBytesFromGC(object->address(), object->Size()); 
       marking_deque->PushBlack(object);
       if (marking_deque->IsFull()) return;
     }
@@ -1808,7 +1808,7 @@ static void DiscoverGreyObjectsOnPage(MarkingDeque* marking_deque, Page* p) { 
       Marking::GreyToBlack(markbit);
       Address addr = cell_base + offset * kPointerSize;
       HeapObject* object = HeapObject::FromAddress(addr);
-      MemoryChunk::IncrementLiveBytes(object->address(), object->Size());
+ MemoryChunk::IncrementLiveBytesFromGC(object->address(), object->Size()); 
       marking_deque->PushBlack(object);
       if (marking_deque->IsFull()) return;
       offset += 2;
Index: src/mark-compact.h
diff --git a/src/mark-compact.h b/src/mark-compact.h
index 486be6811da9f18250b087f1608b562dddc6a549..51e172b98a337f6cce426f521802d1385c56962b 100644 
--- a/src/mark-compact.h
+++ b/src/mark-compact.h
@@ -198,7 +198,7 @@ class MarkingDeque {
     ASSERT(object->IsHeapObject());
     if (IsFull()) {
       Marking::BlackToGrey(object);
-      MemoryChunk::IncrementLiveBytes(object->address(), -object->Size());
+ MemoryChunk::IncrementLiveBytesFromGC(object->address(), -object->Size()); 
       SetOverflowed();
     } else {
       array_[top_] = object;
Index: src/objects.cc
diff --git a/src/objects.cc b/src/objects.cc
index cb627ff527f0ae7b2aa6c8ebc70f9cc055ad5944..47e93c5d328049b399edc014f8a24cf31527b3b6 100644 
--- a/src/objects.cc
+++ b/src/objects.cc
@@ -993,7 +993,7 @@ bool String::MakeExternal(v8::String::ExternalStringResource* resource) { 
   int new_size = this->Size();  // Byte size of the external String object.
   heap->CreateFillerObjectAt(this->address() + new_size, size - new_size);
   if (Marking::IsBlack(Marking::MarkBitFrom(this))) {
-    MemoryChunk::IncrementLiveBytes(this->address(), new_size - size);
+ MemoryChunk::IncrementLiveBytesFromMutator(this->address(), new_size - size); 
   }
   return true;
 }
@@ -1037,7 +1037,7 @@ bool String::MakeExternal(v8::String::ExternalAsciiStringResource* resource) { 
   int new_size = this->Size();  // Byte size of the external String object.
   heap->CreateFillerObjectAt(this->address() + new_size, size - new_size);
   if (Marking::IsBlack(Marking::MarkBitFrom(this))) {
-    MemoryChunk::IncrementLiveBytes(this->address(), new_size - size);
+ MemoryChunk::IncrementLiveBytesFromMutator(this->address(), new_size - size); 
   }
   return true;
 }
@@ -3460,7 +3460,8 @@ MaybeObject* JSObject::NormalizeProperties(PropertyNormalizationMode mode, 
   current_heap->CreateFillerObjectAt(this->address() + new_instance_size,
                                      instance_size_delta);
   if (Marking::IsBlack(Marking::MarkBitFrom(this))) {
-    MemoryChunk::IncrementLiveBytes(this->address(), -instance_size_delta);
+    MemoryChunk::IncrementLiveBytesFromMutator(this->address(),
+                                               -instance_size_delta);
   }


Index: src/runtime.cc
diff --git a/src/runtime.cc b/src/runtime.cc
index aaf14a48988abff36b0bbe9cc628cab01a32a8b5..b9ec719806f420e7d59efbfcfc0cdf7f8b3cc57e 100644 
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -3178,7 +3178,7 @@ MUST_USE_RESULT static MaybeObject* StringReplaceRegExpWithEmptyString( 
   Address end_of_string = answer->address() + string_size;
   isolate->heap()->CreateFillerObjectAt(end_of_string, delta);
   if (Marking::IsBlack(Marking::MarkBitFrom(*answer))) {
-    MemoryChunk::IncrementLiveBytes(answer->address(), -delta);
+    MemoryChunk::IncrementLiveBytesFromMutator(answer->address(), -delta);
   }

   return *answer;
Index: src/spaces-inl.h
diff --git a/src/spaces-inl.h b/src/spaces-inl.h
index bd544ce639e13cadc4405a65727c37cbfe139d4e..d0cddebf787de98cc1171b57eeaf8d125a28f102 100644 
--- a/src/spaces-inl.h
+++ b/src/spaces-inl.h
@@ -332,7 +332,7 @@ void NewSpace::ShrinkStringAtAllocationBoundary(String* string, int length) { 
   string->set_length(length);
   if (Marking::IsBlack(Marking::MarkBitFrom(string))) {
     int delta = static_cast<int>(old_top - allocation_info_.top);
-    MemoryChunk::IncrementLiveBytes(string->address(), -delta);
+    MemoryChunk::IncrementLiveBytesFromMutator(string->address(), -delta);
   }
 }

Index: src/spaces.cc
diff --git a/src/spaces.cc b/src/spaces.cc
index 8c893c07d4f1ed5844f8a9bf1e5c21ea76efead9..1b78e6d5acf30b766e829f659711f5d2395501c1 100644 
--- a/src/spaces.cc
+++ b/src/spaces.cc
@@ -649,6 +649,17 @@ void MemoryAllocator::ReportStatistics() {
 #endif
// ----------------------------------------------------------------------------- 
+// MemoryChunk implementation
+
+void MemoryChunk::IncrementLiveBytesFromMutator(Address address, int by) {
+  MemoryChunk* chunk = MemoryChunk::FromAddress(address);
+  if (!chunk->InNewSpace()) {
+ static_cast<PagedSpace*>(chunk->owner())->IncrementUnsweptFreeBytes(-by); 
+  }
+  chunk->IncrementLiveBytes(by);
+}
+
+// ----------------------------------------------------------------------------- 
 // PagedSpace implementation

 PagedSpace::PagedSpace(Heap* heap,
@@ -2515,7 +2526,7 @@ void LargeObjectSpace::FreeUnmarkedObjects() {
     MarkBit mark_bit = Marking::MarkBitFrom(object);
     if (mark_bit.Get()) {
       mark_bit.Clear();
-      MemoryChunk::IncrementLiveBytes(object->address(), -object->Size());
+ MemoryChunk::IncrementLiveBytesFromGC(object->address(), -object->Size()); 
       previous = current;
       current = current->next_page();
     } else {
Index: src/spaces.h
diff --git a/src/spaces.h b/src/spaces.h
index dc61949d19406faef903219d363884c9ec06bdfb..f49873ac4ffb5303b9b7227391625105ea623368 100644 
--- a/src/spaces.h
+++ b/src/spaces.h
@@ -472,10 +472,13 @@ class MemoryChunk {
     ASSERT(static_cast<unsigned>(live_byte_count_) <= size_);
     return live_byte_count_;
   }
-  static void IncrementLiveBytes(Address address, int by) {
+
+  static void IncrementLiveBytesFromGC(Address address, int by) {
     MemoryChunk::FromAddress(address)->IncrementLiveBytes(by);
   }

+  static void IncrementLiveBytesFromMutator(Address address, int by);
+
   static const intptr_t kAlignment =
       (static_cast<uintptr_t>(1) << kPageSizeBits);

@@ -1563,6 +1566,10 @@ class PagedSpace : public Space {
     first_unswept_page_ = first;
   }

+  void IncrementUnsweptFreeBytes(int by) {
+    unswept_free_bytes_ += by;
+  }
+
   void IncreaseUnsweptFreeBytes(Page* p) {
     ASSERT(ShouldBeSweptLazily(p));
     unswept_free_bytes_ += (Page::kObjectAreaSize - p->LiveBytes());


--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev

Reply via email to