heap: make array buffer maps disjoint

src/heap/heap.cc

Index: src/heap/heap.cc
diff --git a/src/heap/heap.cc b/src/heap/heap.cc
index 5d67854462dbaa5d3a6967a5696014509f9e8cf1..31884a873d53ffeaa3f4bae0931cad128c8178a2 100644
--- a/src/heap/heap.cc
+++ b/src/heap/heap.cc
@@ -1758,16 +1758,25 @@ void Heap::RegisterLiveArrayBufferHelper(
 
 
 size_t Heap::FreeDeadArrayBuffersHelper(

[Michael Lippautz, 2015/08/28 08:05:02]

We should get rid of this one. See below.

[fedor.indutny, 2015/08/28 11:03:34]

Acknowledged.

-    Isolate* isolate, std::map<void*, size_t>& live_buffers,
+    Isolate* isolate, bool from_scavenge,
     std::map<void*, size_t>& not_yet_discovered_buffers) {
   size_t freed_memory = 0;
   for (auto buffer = not_yet_discovered_buffers.begin();
        buffer != not_yet_discovered_buffers.end(); ++buffer) {
     isolate->array_buffer_allocator()->Free(buffer->first, buffer->second);
     freed_memory += buffer->second;
-    live_buffers.erase(buffer->first);
+    if (!from_scavenge) {
+      live_array_buffers_.erase(buffer->first);
+    }
+    live_array_buffers_for_scavenge_.erase(buffer->first);
+  }
+  if (from_scavenge) {
+    not_yet_discovered_buffers = live_array_buffers_for_scavenge_;
+  } else {
+    not_yet_discovered_buffers = live_array_buffers_;
+    not_yet_discovered_buffers.insert(live_array_buffers_for_scavenge_.begin(),
+                                      live_array_buffers_for_scavenge_.end());
   }
-  not_yet_discovered_buffers = live_buffers;
   return freed_memory;
 }
 
@@ -1787,10 +1796,11 @@ void Heap::TearDownArrayBuffersHelper(
 void Heap::RegisterNewArrayBuffer(bool in_new_space, void* data,
                                   size_t length) {
   if (!data) return;
-  RegisterNewArrayBufferHelper(live_array_buffers_, data, length);
   if (in_new_space) {
     RegisterNewArrayBufferHelper(live_array_buffers_for_scavenge_, data,
                                  length);
+  } else {
+    RegisterNewArrayBufferHelper(live_array_buffers_, data, length);
   }
   reinterpret_cast<v8::Isolate*>(isolate_)
       ->AdjustAmountOfExternalAllocatedMemory(length);
@@ -1799,12 +1809,14 @@ void Heap::RegisterNewArrayBuffer(bool in_new_space, void* data,
 
 void Heap::UnregisterArrayBuffer(bool in_new_space, void* data) {
   if (!data) return;
-  UnregisterArrayBufferHelper(live_array_buffers_,
-                              not_yet_discovered_array_buffers_, data);
   if (in_new_space) {
     UnregisterArrayBufferHelper(live_array_buffers_for_scavenge_,
                                 not_yet_discovered_array_buffers_for_scavenge_,
                                 data);
+    not_yet_discovered_array_buffers_.erase(data);
+  } else {
+    UnregisterArrayBufferHelper(live_array_buffers_,
+                                not_yet_discovered_array_buffers_, data);
   }
 }
 
@@ -1823,7 +1835,6 @@ void Heap::FreeDeadArrayBuffers(bool from_scavenge) {
   if (from_scavenge) {
     for (auto& buffer : not_yet_discovered_array_buffers_for_scavenge_) {
       not_yet_discovered_array_buffers_.erase(buffer.first);
-      live_array_buffers_.erase(buffer.first);
     }
   } else {
     for (auto& buffer : not_yet_discovered_array_buffers_) {
@@ -1836,7 +1847,7 @@ void Heap::FreeDeadArrayBuffers(bool from_scavenge) {
   }
   size_t freed_memory = FreeDeadArrayBuffersHelper(
       isolate_,
-      from_scavenge ? live_array_buffers_for_scavenge_ : live_array_buffers_,
+      from_scavenge,
       from_scavenge ? not_yet_discovered_array_buffers_for_scavenge_
                     : not_yet_discovered_array_buffers_);
   if (freed_memory) {
@@ -1850,6 +1861,8 @@ void Heap::FreeDeadArrayBuffers(bool from_scavenge) {
 void Heap::TearDownArrayBuffers() {
   TearDownArrayBuffersHelper(isolate_, live_array_buffers_,
                              not_yet_discovered_array_buffers_);
+  TearDownArrayBuffersHelper(isolate_, live_array_buffers_for_scavenge_,
+                             not_yet_discovered_array_buffers_for_scavenge_);
 }
 
 
@@ -1867,7 +1880,7 @@ void Heap::PromoteArrayBuffer(Object* obj) {
   // ArrayBuffer might be in the middle of being constructed.
   if (data == undefined_value()) return;
   DCHECK(live_array_buffers_for_scavenge_.count(data) > 0);
-  DCHECK(live_array_buffers_.count(data) > 0);
+  live_array_buffers_[data] = live_array_buffers_for_scavenge_[data];
   live_array_buffers_for_scavenge_.erase(data);
   not_yet_discovered_array_buffers_for_scavenge_.erase(data);
 }