Tweak memory management in the serializer.

src/serialize.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
@@ skipping 688 matching lines @@
 
 MaybeHandle<Object> Deserializer::DeserializePartial(
     Isolate* isolate, Handle<JSGlobalProxy> global_proxy,
     Handle<FixedArray>* outdated_contexts_out) {
   Initialize(isolate);
   if (!ReserveSpace()) {
     V8::FatalProcessOutOfMemory("deserialize context");
     return MaybeHandle<Object>();
   }
 
-  Vector<Handle<Object> > attached_objects = Vector<Handle<Object> >::New(1);
-  attached_objects[kGlobalProxyReference] = global_proxy;
+  Handle<Object> global_proxy_object = global_proxy;
+  Vector<Handle<Object> > attached_objects(&global_proxy_object, 1);
   SetAttachedObjects(attached_objects);

[vogelheim, 2015/02/25 14:00:19]

I don't get this. My understanding is:

- SetAttachedObjects will make a (shallow) copy of attached_objects.
- So attached_objects can go out of scope, but its content can't.
- But global_proxy_object will go out of scope - it's stack allocated.

Won't Deserializer::attached_objects_ now have an invalid reference to it after
exiting this method?

[Yang, 2015/02/25 16:06:21]

You are right. It will indeed go out of scope, though it's not used outside of
this method, so everything still works. I'll restore the old behavior for
attached objects though.

 
   DisallowHeapAllocation no_gc;
   // Keep track of the code space start and end pointers in case new
   // code objects were unserialized
   OldSpace* code_space = isolate_->heap()->code_space();
   Address start_address = code_space->top();
   Object* root;
   Object* outdated_contexts;
   VisitPointer(&root);
   VisitPointer(&outdated_contexts);
@@ skipping 24 matching lines @@
 }
 
 
 Deserializer::~Deserializer() {
   // TODO(svenpanne) Re-enable this assertion when v8 initialization is fixed.
   // DCHECK(source_.AtEOF());
   if (external_reference_decoder_) {
     delete external_reference_decoder_;
     external_reference_decoder_ = NULL;
   }
-  attached_objects_.Dispose();
 }
 
 
 // This is called on the roots.  It is the driver of the deserialization
 // process.  It is also called on the body of each function.
 void Deserializer::VisitPointers(Object** start, Object** end) {
   // The space must be new space.  Any other space would cause ReadChunk to try
   // to update the remembered using NULL as the address.
   ReadData(start, end, NEW_SPACE, NULL);
 }
@@ skipping 604 matching lines @@
     pending_chunk_[i] = 0;
     max_chunk_size_[i] = static_cast<uint32_t>(
         MemoryAllocator::PageAreaSize(static_cast<AllocationSpace>(i)));
   }
 }
 
 
 Serializer::~Serializer() {
   delete external_reference_encoder_;
   if (code_address_map_ != NULL) delete code_address_map_;
+  code_buffer_.Dispose();
 }
 
 
 void StartupSerializer::SerializeStrongReferences() {
   Isolate* isolate = this->isolate();
   // No active threads.
   CHECK_NULL(isolate->thread_manager()->FirstThreadStateInUse());
   // No active or weak handles.
   CHECK(isolate->handle_scope_implementer()->blocks()->is_empty());
   CHECK_EQ(0, isolate->global_handles()->NumberOfWeakHandles());
@@ skipping 646 matching lines @@
         return;
       }
     }
   }
   // One of the strings in the natives cache should match the resource.  We
   // don't expect any other kinds of external strings here.
   UNREACHABLE();
 }
 
 
-static Code* CloneCodeObject(HeapObject* code) {
-  Address copy = new byte[code->Size()];
-  MemCopy(copy, code->address(), code->Size());
-  return Code::cast(HeapObject::FromAddress(copy));
-}
-
-
-static void WipeOutRelocations(Code* code) {
+Address Serializer::ObjectSerializer::PrepareCode() {
+  // To make snapshots reproducible, we make a copy of the code object
+  // and wipe all pointers in the copy, which we then serialize.
+  Code* original = Code::cast(object_);
+  int size = original->CodeSize();
+  Address copy = serializer_->GetCodeBuffer(size);
+  MemCopy(copy, original->address(), size);
+  Code* code = Code::cast(HeapObject::FromAddress(copy));
+  // Code age headers are not serializable.
+  code->MakeYoung(serializer_->isolate());
   int mode_mask =
       RelocInfo::kCodeTargetMask |
       RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT) |
       RelocInfo::ModeMask(RelocInfo::EXTERNAL_REFERENCE) |
       RelocInfo::ModeMask(RelocInfo::RUNTIME_ENTRY);
   for (RelocIterator it(code, mode_mask); !it.done(); it.next()) {
     if (!(FLAG_enable_ool_constant_pool && it.rinfo()->IsInConstantPool())) {
       it.rinfo()->WipeOut();
     }
   }
+  // We need to wipe out the header fields *after* wiping out the
+  // relocations, because some of these fields are needed for the latter.
+  code->WipeOutHeader();
+  return code->address();
 }
 
 
 int Serializer::ObjectSerializer::OutputRawData(
     Address up_to, Serializer::ObjectSerializer::ReturnSkip return_skip) {
   Address object_start = object_->address();
   int base = bytes_processed_so_far_;
   int up_to_offset = static_cast<int>(up_to - object_start);
   int to_skip = up_to_offset - bytes_processed_so_far_;
   int bytes_to_output = to_skip;
@@ skipping 17 matching lines @@
       to_skip = 0;  /* This insn already skips. */                             \
     } else  /* NOLINT */
     COMMON_RAW_LENGTHS(RAW_CASE)
 #undef RAW_CASE
     {  /* NOLINT */
       // We always end up here if we are outputting the code of a code object.
       sink_->Put(kRawData, "RawData");
       sink_->PutInt(bytes_to_output, "length");
     }
 
-    // To make snapshots reproducible, we need to wipe out all pointers in code.
-    if (code_object_) {
-      Code* code = CloneCodeObject(object_);
-      // Code age headers are not serializable.
-      code->MakeYoung(serializer_->isolate());
-      WipeOutRelocations(code);
-      // We need to wipe out the header fields *after* wiping out the
-      // relocations, because some of these fields are needed for the latter.
-      code->WipeOutHeader();
-      object_start = code->address();
-    }
+    if (code_object_) object_start = PrepareCode();
 
     const char* description = code_object_ ? "Code" : "Byte";
 #ifdef MEMORY_SANITIZER
     // Object sizes are usually rounded up with uninitialized padding space.
     MSAN_MEMORY_IS_INITIALIZED(object_start + base, bytes_to_output);
 #endif  // MEMORY_SANITIZER
     sink_->PutRaw(object_start + base, bytes_to_output, description);
-    if (code_object_) delete[] object_start;
   }
   if (to_skip != 0 && return_skip == kIgnoringReturn) {
     sink_->Put(kSkip, "Skip");
     sink_->PutInt(to_skip, "SkipDistance");
     to_skip = 0;
   }
   return to_skip;
 }
 
 
@@ skipping 278 matching lines @@
   attached_objects[kSourceObjectIndex] = source;
   for (int i = 0; i < code_stub_keys.length(); i++) {
     attached_objects[i + kCodeStubsBaseIndex] =
         CodeStub::GetCode(isolate, code_stub_keys[i]).ToHandleChecked();
   }
 
   Deserializer deserializer(scd.get());
   deserializer.SetAttachedObjects(attached_objects);
 
   // Deserialize.
+  MaybeHandle<SharedFunctionInfo> maybe = deserializer.DeserializeCode(isolate);
+  attached_objects.Dispose();
+
   Handle<SharedFunctionInfo> result;
-  if (!deserializer.DeserializeCode(isolate).ToHandle(&result)) {
+  if (!maybe.ToHandle(&result)) {
     // Deserializing may fail if the reservations cannot be fulfilled.
     if (FLAG_profile_deserialization) PrintF("[Deserializing failed]\n");
     return MaybeHandle<SharedFunctionInfo>();
   }
   deserializer.FlushICacheForNewCodeObjects();
 
   if (FLAG_profile_deserialization) {
     double ms = timer.Elapsed().InMillisecondsF();
     int length = cached_data->length();
     PrintF("[Deserializing from %d bytes took %0.3f ms]\n", length, ms);
@@ skipping 233 matching lines @@
   DisallowHeapAllocation no_gc;
   SerializedCodeData* scd = new SerializedCodeData(cached_data);
   SanityCheckResult r = scd->SanityCheck(source);
   if (r == CHECK_SUCCESS) return scd;
   cached_data->Reject();
   source->GetIsolate()->counters()->code_cache_reject_reason()->AddSample(r);
   delete scd;
   return NULL;
 }
 } }  // namespace v8::internal