[v8-dev] Keep track of ArrayBuffers based on collector type, not space (issue 1199913002 by [email protected])

Mon, 22 Jun 2015 01:39:56 -0700 

Reviewers: Hannes Payer,

Description:
Keep track of ArrayBuffers based on collector type, not space

Since Mark/Compact also collects garbage in the new space, we can't just
free old space ArrayBuffers during MC - otherwise we run the risk of
never freeing new array buffers

BUG=v8:4201
[email protected]
LOG=n

Please review this at https://codereview.chromium.org/1199913002/

Base URL: https://chromium.googlesource.com/v8/v8.git@master

Affected files (+25, -12 lines):
  M src/heap/heap.h
  M src/heap/heap.cc
  M src/heap/objects-visiting-inl.h


Index: src/heap/heap.cc
diff --git a/src/heap/heap.cc b/src/heap/heap.cc
index 78618798dde37220297a6953a21f0fdb1a8c1646..01dba82709708435c68c65e78dca1b80f8a86e98 100644 
--- a/src/heap/heap.cc
+++ b/src/heap/heap.cc
@@ -1863,9 +1863,10 @@ void Heap::TearDownArrayBuffersHelper(
 void Heap::RegisterNewArrayBuffer(bool in_new_space, void* data,
                                   size_t length) {
   if (!data) return;
-  RegisterNewArrayBufferHelper(
-      in_new_space ? live_new_array_buffers_ : live_array_buffers_, data,
-      length);
+  RegisterNewArrayBufferHelper(live_array_buffers_, data, length);
+  if (in_new_space) {
+    RegisterNewArrayBufferHelper(live_new_array_buffers_, data, length);
+  }
   reinterpret_cast<v8::Isolate*>(isolate_)
       ->AdjustAmountOfExternalAllocatedMemory(length);
 }
@@ -1873,11 +1874,12 @@ void Heap::RegisterNewArrayBuffer(bool in_new_space, void* data, 

 void Heap::UnregisterArrayBuffer(bool in_new_space, void* data) {
   if (!data) return;
-  UnregisterArrayBufferHelper(
-      in_new_space ? live_new_array_buffers_ : live_array_buffers_,
-      in_new_space ? not_yet_discovered_new_array_buffers_
-                   : not_yet_discovered_array_buffers_,
-      data);
+  UnregisterArrayBufferHelper(live_array_buffers_,
+                              not_yet_discovered_array_buffers_, data);
+  if (in_new_space) {
+    UnregisterArrayBufferHelper(live_new_array_buffers_,
+ not_yet_discovered_new_array_buffers_, data); 
+  }
 }
@@ -1892,6 +1894,18 @@ void Heap::RegisterLiveArrayBuffer(bool in_new_space, void* data) { 


 void Heap::FreeDeadArrayBuffers(bool in_new_space) {
+  if (in_new_space) {
+    for (auto& buffer : not_yet_discovered_new_array_buffers_) {
+      not_yet_discovered_array_buffers_.erase(buffer.first);
+      live_array_buffers_.erase(buffer.first);
+    }
+  } else {
+    for (auto& buffer : not_yet_discovered_array_buffers_) {
+ // Scavenge can't happend during evacuation, so we only need to update 
+      // live_new_array_buffers_.
+      live_new_array_buffers_.erase(buffer.first);
+    }
+  }
   size_t freed_memory = FreeDeadArrayBuffersHelper(
isolate_, in_new_space ? live_new_array_buffers_ : live_array_buffers_, 
       in_new_space ? not_yet_discovered_new_array_buffers_
@@ -1907,8 +1921,6 @@ void Heap::FreeDeadArrayBuffers(bool in_new_space) {
 void Heap::TearDownArrayBuffers() {
   TearDownArrayBuffersHelper(isolate_, live_array_buffers_,
                              not_yet_discovered_array_buffers_);
-  TearDownArrayBuffersHelper(isolate_, live_new_array_buffers_,
-                             not_yet_discovered_new_array_buffers_);
 }


@@ -1925,7 +1937,7 @@ void Heap::PromoteArrayBuffer(Object* obj) {
   // ArrayBuffer might be in the middle of being constructed.
   if (data == undefined_value()) return;
   DCHECK(live_new_array_buffers_.count(data) > 0);
-  live_array_buffers_[data] = live_new_array_buffers_[data];
+  DCHECK(live_array_buffers_.count(data) > 0);
   live_new_array_buffers_.erase(data);
   not_yet_discovered_new_array_buffers_.erase(data);
 }
Index: src/heap/heap.h
diff --git a/src/heap/heap.h b/src/heap/heap.h
index db57591984d341f0c893b603deb2e760a63b9c73..0b6b18bfdd2c1472cd7a9fa67be54179aac45dc5 100644 
--- a/src/heap/heap.h
+++ b/src/heap/heap.h
@@ -2372,6 +2372,7 @@ class Heap {

   bool concurrent_sweeping_enabled_;

+  // The _new_ variants keep track of array buffers during scavenge.
   std::map<void*, size_t> live_array_buffers_;
   std::map<void*, size_t> live_new_array_buffers_;
   std::map<void*, size_t> not_yet_discovered_array_buffers_;
Index: src/heap/objects-visiting-inl.h
diff --git a/src/heap/objects-visiting-inl.h b/src/heap/objects-visiting-inl.h index 433fc6deab3e0efc7cb921501d7757d1c42a2688..fa90be5c40b1351959cc392604419655f063759d 100644 
--- a/src/heap/objects-visiting-inl.h
+++ b/src/heap/objects-visiting-inl.h
@@ -508,7 +508,7 @@ void StaticMarkingVisitor<StaticVisitor>::VisitJSArrayBuffer( HeapObject::RawField(object, JSArrayBuffer::BodyDescriptor::kStartOffset), HeapObject::RawField(object, JSArrayBuffer::kSizeWithInternalFields)); 
   if (!JSArrayBuffer::cast(object)->is_external()) {
-    heap->RegisterLiveArrayBuffer(heap->InNewSpace(object),
+    heap->RegisterLiveArrayBuffer(false,
JSArrayBuffer::cast(object)->backing_store()); 
   }
 }


--
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
--- You received this message because you are subscribed to the Google Groups "v8-dev" group. 
To unsubscribe from this group and stop receiving emails from it, send an email 
to [email protected].
For more options, visit https://groups.google.com/d/optout.

Reply via email to