Make all reload zone allocations use the same zone

runtime/vm/isolate_reload.cc

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/isolate_reload.h"
 
 #include "vm/become.h"
 #include "vm/bit_vector.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
@@ skipping 29 matching lines @@
 
 #define I (isolate())
 #define Z (thread->zone())
 
 #define TIMELINE_SCOPE(name)                                                   \
     TimelineDurationScope tds##name(Thread::Current(),                         \
                                    Timeline::GetIsolateStream(),               \
                                    #name)
 
 
-InstanceMorpher::InstanceMorpher(const Class& from, const Class& to)
+InstanceMorpher::InstanceMorpher(Zone* zone, const Class& from, const Class& to)
   : from_(from), to_(to), mapping_() {
   ComputeMapping();
-  before_ = new ZoneGrowableArray<const Instance*>();
-  after_ = new ZoneGrowableArray<const Instance*>();
+  before_ = new ZoneGrowableArray<const Instance*>(zone, 0);
+  after_ = new ZoneGrowableArray<const Instance*>(zone, 0);
   ASSERT(from_.id() == to_.id());
   cid_ = from_.id();
 }
 
 
 void InstanceMorpher::AddObject(RawObject* object) const {
   ASSERT(object->GetClassId() == cid());
   const Instance& instance = Instance::Cast(Object::Handle(object));
   before_->Add(&instance);
 }
@@ skipping 144 matching lines @@
 void ClassReasonForCancelling::AppendTo(JSONArray* array) {
   JSONObject jsobj(array);
   jsobj.AddProperty("type", "ReasonForCancelling");
   jsobj.AddProperty("class", from_);
   const String& message = String::Handle(ToString());
   jsobj.AddProperty("message", message);
 }
 
 
 RawError* IsolateReloadContext::error() const {
-  ASSERT(has_error());
+  ASSERT(reload_aborted());
   // Report the first error to the surroundings.
   const Error& error =
       Error::Handle(reasons_to_cancel_reload_.At(0)->ToError());
   return error.raw();
 }
 
 
 class ScriptUrlSetTraits {
  public:
   static bool ReportStats() { return false; }
@@ skipping 122 matching lines @@
   const String& a_lib_url =
       String::Handle(a_lib.IsNull() ? String::null() : a_lib.url());
   const String& b_lib_url =
       String::Handle(b_lib.IsNull() ? String::null() : b_lib.url());
   return a_lib_url.Equals(b_lib_url);
 }
 
 
 IsolateReloadContext::IsolateReloadContext(Isolate* isolate,
                                            JSONStream* js)
-    : start_time_micros_(OS::GetCurrentMonotonicMicros()),
+    : zone_(Thread::Current()->zone()),
+      start_time_micros_(OS::GetCurrentMonotonicMicros()),
       reload_timestamp_(OS::GetCurrentTimeMillis()),
       isolate_(isolate),
       reload_skipped_(false),
+      reload_aborted_(false),
       js_(js),
       saved_num_cids_(-1),
       saved_class_table_(NULL),
       num_saved_libs_(-1),
       instance_morphers_(),
       reasons_to_cancel_reload_(),
       cid_mapper_(),
       modified_libs_(NULL),
       script_uri_(String::null()),
       error_(Error::null()),
       old_classes_set_storage_(Array::null()),
       class_map_storage_(Array::null()),
       old_libraries_set_storage_(Array::null()),
       library_map_storage_(Array::null()),
       become_map_storage_(Array::null()),
       become_enum_mappings_(GrowableObjectArray::null()),
       saved_root_library_(Library::null()),
       saved_libraries_(GrowableObjectArray::null()) {
   // NOTE: DO NOT ALLOCATE ANY RAW OBJECTS HERE. The IsolateReloadContext is not
   // associated with the isolate yet and if a GC is triggered here the raw
   // objects will not be properly accounted for.
+  ASSERT(zone_ != NULL);
 }
 
 
 IsolateReloadContext::~IsolateReloadContext() {
 }
 
 
 void IsolateReloadContext::ReportError(const Error& error) {
   if (FLAG_trace_reload) {
     THR_Print("ISO-RELOAD: Error: %s\n", error.ToErrorCString());
   }
   ServiceEvent service_event(I, ServiceEvent::kIsolateReload);
   service_event.set_reload_error(&error);
   Service::HandleEvent(&service_event);
 }
 
 
 void IsolateReloadContext::ReportSuccess() {
   ServiceEvent service_event(I, ServiceEvent::kIsolateReload);
   Service::HandleEvent(&service_event);
 }
 
 
 class Aborted : public ReasonForCancelling {
  public:
-  explicit Aborted(const Error& error)
-      : ReasonForCancelling(), error_(error) { }
+  explicit Aborted(Zone* zone, const Error& error)
+      : ReasonForCancelling(zone), error_(error) { }
 
  private:
   const Error& error_;
 
   RawError* ToError() { return error_.raw(); }
   RawString* ToString() {
     return String::NewFormatted("%s", error_.ToErrorCString());
   }
 };
 
 
-void IsolateReloadContext::StartReload(bool force_reload) {
+// NOTE: This function returns *after* FinalizeLoading is called.
+void IsolateReloadContext::Reload(bool force_reload) {
   TIMELINE_SCOPE(Reload);
   Thread* thread = Thread::Current();
   ASSERT(isolate() == thread->isolate());
+  fprintf(stderr, "Reload\n");

[rmacnak, 2016/08/02 16:30:22]

Remove

[Cutch, 2016/08/02 16:32:33]

Done.

 
   // Grab root library before calling CheckpointBeforeReload.
   const Library& root_lib = Library::Handle(object_store()->root_library());
   ASSERT(!root_lib.IsNull());
   const String& root_lib_url = String::Handle(root_lib.url());
 
   // Check to see which libraries have been modified.
   modified_libs_ = FindModifiedLibraries(force_reload);
   if (!modified_libs_->Contains(root_lib.index())) {
     ASSERT(modified_libs_->IsEmpty());
@@ skipping 40 matching lines @@
     Api::Scope api_scope(thread);
 
     Dart_Handle retval =
         (I->library_tag_handler())(Dart_kScriptTag,
                                    Api::NewHandle(thread, Library::null()),
                                    Api::NewHandle(thread, root_lib_url.raw()));
     result = Api::UnwrapHandle(retval);
   }
   if (result.IsError()) {
     const Error& error = Error::Cast(result);
-    AddReasonForCancelling(new Aborted(error));
+    AddReasonForCancelling(new Aborted(zone_, error));
   }
 }
 
 
 void IsolateReloadContext::RegisterClass(const Class& new_cls) {
   const Class& old_cls = Class::Handle(OldClassOrNull(new_cls));
   if (old_cls.IsNull()) {
     I->class_table()->Register(new_cls);
 
     if (FLAG_identity_reload) {
@@ skipping 10 matching lines @@
   isolate()->class_table()->SetAt(old_cls.id(), new_cls.raw());
   if (!old_cls.is_enum_class()) {
     new_cls.CopyCanonicalConstants(old_cls);
   }
   new_cls.CopyCanonicalType(old_cls);
   AddBecomeMapping(old_cls, new_cls);
   AddClassMapping(new_cls, old_cls);
 }
 
 
-void IsolateReloadContext::FinishReload() {
+// FinalizeLoading will be called *before* Reload() returns.
+void IsolateReloadContext::FinalizeLoading() {
   if (reload_skipped_) {
     return;
   }
+  fprintf(stderr, "FinalizeLoading\n");

[rmacnak, 2016/08/02 16:30:22]

"

[Cutch, 2016/08/02 16:32:33]

Done.

   BuildLibraryMapping();
   TIR_Print("---- DONE FINALIZING\n");
   if (ValidateReload()) {
     Commit();
     PostCommit();
     isolate()->set_last_reload_timestamp(reload_timestamp_);
   } else {
     ReportReasonsForCancelling();
     Rollback();
   }
   // ValidateReload mutates the direct subclass information and does
   // not remove dead subclasses.  Rebuild the direct subclass
   // information from scratch.
   RebuildDirectSubclasses();
 
   if (FLAG_write_protect_code) {
     // Re-enable code page write protection.
     I->heap()->WriteProtectCode(true);
   }
 
   BackgroundCompiler::Enable();
 
+  reload_aborted_ = HasReasonsForCancelling();
   ReportOnJSON(js_);
 }
 
 
 void IsolateReloadContext::ReportOnJSON(JSONStream* stream) {
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", "ReloadReport");
   jsobj.AddProperty("success", !HasReasonsForCancelling());
   {
     JSONObject details(&jsobj, "details");
@@ skipping 17 matching lines @@
       JSONArray array(&jsobj, "shapeChangeMappings");
       for (intptr_t i = 0; i < instance_morphers_.length(); i++) {
         instance_morphers_.At(i)->AppendTo(&array);
       }
     }
   }
 }
 
 
 void IsolateReloadContext::AbortReload(const Error& error) {
-  AddReasonForCancelling(new Aborted(error));
+  AddReasonForCancelling(new Aborted(zone_, error));
   ReportReasonsForCancelling();
   Rollback();
 }
 
 
 void IsolateReloadContext::EnsuredUnoptimizedCodeForStack() {
   TIMELINE_SCOPE(EnsuredUnoptimizedCodeForStack);
   StackFrameIterator it(StackFrameIterator::kDontValidateFrames);
 
   Function& func = Function::Handle();
@@ skipping 121 matching lines @@
 
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(object_store()->libraries());
   Library& lib = Library::Handle();
   Array& scripts = Array::Handle();
   Script& script = Script::Handle();
   intptr_t num_libs = libs.Length();
 
   // Construct the imported-by graph.
   ZoneGrowableArray<ZoneGrowableArray<intptr_t>* >* imported_by =
-      new ZoneGrowableArray<ZoneGrowableArray<intptr_t>* >(num_libs);
+      new ZoneGrowableArray<ZoneGrowableArray<intptr_t>* >(zone_, num_libs);
   imported_by->SetLength(num_libs);
   for (intptr_t i = 0; i < num_libs; i++) {
-    (*imported_by)[i] = new ZoneGrowableArray<intptr_t>();
+    (*imported_by)[i] = new ZoneGrowableArray<intptr_t>(zone_, 0);
   }
   Array& imports = Array::Handle();
   Namespace& ns = Namespace::Handle();
   Library& target = Library::Handle();
 
   for (intptr_t lib_idx = 0; lib_idx < num_libs; lib_idx++) {
     lib ^= libs.At(lib_idx);
     ASSERT(lib_idx == lib.index());
     if (lib.is_dart_scheme()) {
       // We don't care about imports among dart scheme libraries.
@@ skipping 461 matching lines @@
   // must be zapped to prevent the forwarding in GetClassForHeapWalkAt.
   // Instance will from now be described by the isolate's class table.
   free(saved_class_table_);
   saved_class_table_ = NULL;
   Become::ElementsForwardIdentity(before, after);
 }
 
 
 bool IsolateReloadContext::ValidateReload() {
   TIMELINE_SCOPE(ValidateReload);
-  if (has_error()) return false;
+  if (reload_aborted()) return false;
 
   // Validate libraries.
   {
     ASSERT(library_map_storage_ != Array::null());
     UnorderedHashMap<LibraryMapTraits> map(library_map_storage_);
     UnorderedHashMap<LibraryMapTraits>::Iterator it(&map);
     Library& lib = Library::Handle();
     Library& new_lib = Library::Handle();
     while (it.MoveNext()) {
       const intptr_t entry = it.Current();
@@ skipping 365 matching lines @@
         ASSERT(!super_cls.IsNull());
         super_cls.AddDirectSubclass(cls);
       }
     }
   }
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart