dart::IsolateGroupReloadContext Class Reference

#include <isolate_reload.h>

Public Member Functions
	IsolateGroupReloadContext (IsolateGroup *isolate, ClassTable *class_table, JSONStream *js)
	~IsolateGroupReloadContext ()
bool	Reload (bool force_reload, const char *root_script_url=nullptr, const char *packages_url=nullptr, const uint8_t *kernel_buffer=nullptr, intptr_t kernel_buffer_size=0)
Zone *	zone () const
IsolateGroup *	isolate_group () const
bool	reload_aborted () const
bool	reload_skipped () const
ErrorPtr	error () const
int64_t	start_time_micros () const
int64_t	reload_timestamp () const

Static Public Member Functions
static Dart_FileModifiedCallback	file_modified_callback ()
static void	SetFileModifiedCallback (Dart_FileModifiedCallback callback)

Friends
class	Isolate
class	Class
class	Library
class	ObjectLocator
class	ReasonForCancelling
class	ProgramReloadContext
class	IsolateGroup

Detailed Description

Definition at line 141 of file isolate_reload.h.

Constructor & Destructor Documentation

IsolateGroupReloadContext()

dart::IsolateGroupReloadContext::IsolateGroupReloadContext	(	IsolateGroup *	isolate,
		ClassTable *	class_table,
		JSONStream *	js
	)

Definition at line 546 of file isolate_reload.cc.

    : zone_(Thread::Current()->zone()),
      isolate_group_(isolate_group),
      class_table_(class_table),
      start_time_micros_(OS::GetCurrentMonotonicMicros()),
      reload_timestamp_(OS::GetCurrentTimeMillis()),
      js_(js),
      instance_morphers_(zone_, 0),
      reasons_to_cancel_reload_(zone_, 0),
      instance_morpher_by_cid_(zone_),
      root_lib_url_(String::Handle(Z, String::null())),
      root_url_prefix_(String::null()),
      old_root_url_prefix_(String::null()) {}

~IsolateGroupReloadContext()

dart::IsolateGroupReloadContext::~IsolateGroupReloadContext

(

)

Definition at line 562 of file isolate_reload.cc.

{}

Member Function Documentation

error()

ErrorPtr dart::IsolateGroupReloadContext::error

(

)

const

Definition at line 454 of file isolate_reload.cc.

                                                {
  ASSERT(!reasons_to_cancel_reload_.is_empty());
  // Report the first error to the surroundings.
  return reasons_to_cancel_reload_.At(0)->ToError();
}

file_modified_callback()

static Dart_FileModifiedCallback dart::IsolateGroupReloadContext::file_modified_callback ( )

inlinestatic

Definition at line 165 of file isolate_reload.h.

                                                            {
    return file_modified_callback_;
  }

isolate_group()

IsolateGroup * dart::IsolateGroupReloadContext::isolate_group ( ) const

inline

Definition at line 158 of file isolate_reload.h.

{ return isolate_group_; }

Reload()

bool dart::IsolateGroupReloadContext::Reload	(	bool	force_reload,
		const char *	root_script_url = nullptr,
		const char *	packages_url = nullptr,
		const uint8_t *	kernel_buffer = nullptr,
		intptr_t	kernel_buffer_size = 0
	)

Definition at line 686 of file isolate_reload.cc.

                                                                    {
  TIMELINE_SCOPE(Reload);
 
  Thread* thread = Thread::Current();
  ASSERT(thread->OwnsReloadSafepoint());
 
  Heap* heap = IG->heap();
  num_old_libs_ =
      GrowableObjectArray::Handle(Z, IG->object_store()->libraries()).Length();
 
  // Grab root library before calling CheckpointBeforeReload.
  GetRootLibUrl(root_script_url);
 
  std::unique_ptr<kernel::Program> kernel_program;
 
  // Reset stats.
  num_received_libs_ = 0;
  bytes_received_libs_ = 0;
  num_received_classes_ = 0;
  num_received_procedures_ = 0;
 
  bool did_kernel_compilation = false;
  bool skip_reload = false;
  {
    // Load the kernel program and figure out the modified libraries.
    intptr_t* p_num_received_classes = nullptr;
    intptr_t* p_num_received_procedures = nullptr;
 
    // ReadKernelFromFile checks to see if the file at
    // root_script_url is a valid .dill file. If that's the case, a Program*
    // is returned. Otherwise, this is likely a source file that needs to be
    // compiled, so ReadKernelFromFile returns nullptr.
    kernel_program = kernel::Program::ReadFromFile(root_script_url);
    if (kernel_program != nullptr) {
      num_received_libs_ = kernel_program->library_count();
      bytes_received_libs_ = kernel_program->binary().LengthInBytes();
      p_num_received_classes = &num_received_classes_;
      p_num_received_procedures = &num_received_procedures_;
    } else {
      if (kernel_buffer == nullptr || kernel_buffer_size == 0) {
        char* error = CompileToKernel(force_reload, packages_url,
                                      &kernel_buffer, &kernel_buffer_size);
        did_kernel_compilation = true;
        if (error != nullptr) {
          TIR_Print("---- LOAD FAILED, ABORTING RELOAD\n");
          const auto& error_str = String::Handle(Z, String::New(error));
          free(error);
          const ApiError& error = ApiError::Handle(Z, ApiError::New(error_str));
          AddReasonForCancelling(new Aborted(Z, error));
          ReportReasonsForCancelling();
          CommonFinalizeTail(num_old_libs_);
 
          RejectCompilation(thread);
          return false;
        }
      }
      const auto& typed_data = ExternalTypedData::Handle(
          Z, ExternalTypedData::NewFinalizeWithFree(
                 const_cast<uint8_t*>(kernel_buffer), kernel_buffer_size));
      kernel_program = kernel::Program::ReadFromTypedData(typed_data);
    }
 
    NoActiveIsolateScope no_active_isolate_scope;
 
    IsolateGroupSource* source = IsolateGroup::Current()->source();
    source->add_loaded_blob(Z,
                            ExternalTypedData::Cast(kernel_program->binary()));
 
    modified_libs_ = new (Z) BitVector(Z, num_old_libs_);
    kernel::KernelLoader::FindModifiedLibraries(
        kernel_program.get(), IG, modified_libs_, force_reload, &skip_reload,
        p_num_received_classes, p_num_received_procedures);
    modified_libs_transitive_ = new (Z) BitVector(Z, num_old_libs_);
    BuildModifiedLibrariesClosure(modified_libs_);
 
    ASSERT(num_saved_libs_ == -1);
    num_saved_libs_ = 0;
    for (intptr_t i = 0; i < modified_libs_->length(); i++) {
      if (!modified_libs_->Contains(i)) {
        num_saved_libs_++;
      }
    }
  }
 
  NoActiveIsolateScope no_active_isolate_scope;
 
  if (skip_reload) {
    ASSERT(modified_libs_->IsEmpty());
    reload_skipped_ = true;
    ReportOnJSON(js_, num_old_libs_);
 
    // If we use the CFE and performed a compilation, we need to notify that
    // we have accepted the compilation to clear some state in the incremental
    // compiler.
    if (did_kernel_compilation) {
      const auto& result = Object::Handle(Z, AcceptCompilation(thread));
      if (result.IsError()) {
        const auto& error = Error::Cast(result);
        AddReasonForCancelling(new Aborted(Z, error));
        ReportReasonsForCancelling();
        CommonFinalizeTail(num_old_libs_);
        return false;
      }
    }
    TIR_Print("---- SKIPPING RELOAD (No libraries were modified)\n");
    return false;
  }
 
  TIR_Print("---- STARTING RELOAD\n");
 
  intptr_t number_of_isolates = 0;
  isolate_group_->ForEachIsolate(
      [&](Isolate* isolate) { number_of_isolates++; });
 
  // Wait for any concurrent marking tasks to finish and turn off the
  // concurrent marker during reload as we might be allocating new instances
  // (constants) when loading the new kernel file and this could cause
  // inconsistency between the saved class table and the new class table.
  const bool old_concurrent_mark_flag =
      heap->old_space()->enable_concurrent_mark();
  if (old_concurrent_mark_flag) {
    heap->WaitForMarkerTasks(thread);
    heap->old_space()->set_enable_concurrent_mark(false);
  }
 
  // Ensure all functions on the stack have unoptimized code.
  // Deoptimize all code that had optimizing decisions that are dependent on
  // assumptions from field guards or CHA or deferred library prefixes.
  // TODO(johnmccutchan): Deoptimizing dependent code here (before the reload)
  // is paranoid. This likely can be moved to the commit phase.
  IG->program_reload_context()->EnsuredUnoptimizedCodeForStack();
  IG->program_reload_context()->DeoptimizeDependentCode();
  IG->program_reload_context()->ReloadPhase1AllocateStorageMapsAndCheckpoint();
 
  // Renumbering the libraries has invalidated this.
  modified_libs_ = nullptr;
  modified_libs_transitive_ = nullptr;
 
  if (FLAG_gc_during_reload) {
    // We force the GC to compact, which is more likely to discover untracked
    // pointers (and other issues, like incorrect class table).
    heap->CollectAllGarbage(GCReason::kDebugging, /*compact=*/true);
  }
 
  // Clone the class table.
  {
    TIMELINE_SCOPE(CheckpointClasses);
    IG->program_reload_context()->CheckpointClasses();
  }
 
  if (FLAG_gc_during_reload) {
    // We force the GC to compact, which is more likely to discover untracked
    // pointers (and other issues, like incorrect class table).
    heap->CollectAllGarbage(GCReason::kDebugging, /*compact=*/true);
  }
 
  // We synchronously load the hot-reload kernel diff (which includes changed
  // libraries and any libraries transitively depending on them).
  //
  // If loading the hot-reload diff succeeded we'll finalize the loading, which
  // will either commit or reject the reload request.
  const auto& result =
      Object::Handle(Z, IG->program_reload_context()->ReloadPhase2LoadKernel(
                            kernel_program.get(), root_lib_url_));
 
  if (result.IsError()) {
    TIR_Print("---- LOAD FAILED, ABORTING RELOAD\n");
 
    const auto& error = Error::Cast(result);
    AddReasonForCancelling(new Aborted(Z, error));
 
    IG->program_reload_context()->ReloadPhase4Rollback();
    CommonFinalizeTail(num_old_libs_);
  } else {
    ASSERT(!reload_skipped_ && !reload_finalized_);
    TIR_Print("---- LOAD SUCCEEDED\n");
 
    IG->program_reload_context()->ReloadPhase3FinalizeLoading();
 
    if (FLAG_gc_during_reload) {
      // We force the GC to compact, which is more likely to discover untracked
      // pointers (and other issues, like incorrect class table).
      heap->CollectAllGarbage(GCReason::kDebugging, /*compact=*/true);
    }
 
    // If we use the CFE and performed a compilation, we need to notify that
    // we have accepted the compilation to clear some state in the incremental
    // compiler.
    if (did_kernel_compilation) {
      TIMELINE_SCOPE(AcceptCompilation);
      const auto& result = Object::Handle(Z, AcceptCompilation(thread));
      if (result.IsError()) {
        const auto& error = Error::Cast(result);
        AddReasonForCancelling(new Aborted(Z, error));
      }
    }
 
    if (!FLAG_reload_force_rollback && !HasReasonsForCancelling()) {
      TIR_Print("---- COMMITTING RELOAD\n");
      isolate_group_->program_reload_context()->ReloadPhase4CommitPrepare();
      bool discard_class_tables = true;
      if (HasInstanceMorphers()) {
        // Find all objects that need to be morphed (reallocated to a new
        // layout).
        ObjectLocator locator(this);
        {
          TIMELINE_SCOPE(CollectInstances);
          HeapIterationScope iteration(thread);
          iteration.IterateObjects(&locator);
        }
 
        // We are still using the old class table at this point.
        if (FLAG_gc_during_reload) {
          // We force the GC to compact, which is more likely to discover
          // untracked pointers (and other issues, like incorrect class table).
          heap->CollectAllGarbage(GCReason::kDebugging, /*compact=*/true);
        }
        const intptr_t count = locator.count();
        if (count > 0) {
          TIMELINE_SCOPE(MorphInstances);
 
          // While we are reallocating instances to their new layout, the heap
          // will contain a mix of instances with the old and new layouts that
          // have the same cid. This makes the heap unwalkable until the
          // "become" operation below replaces all the instances of the old
          // layout with forwarding corpses. Force heap growth to prevent layout
          // confusion during this period.
          ForceGrowthScope force_growth(thread);
          // The HeapIterationScope above ensures no other GC tasks can be
          // active.
          ASSERT(HasNoTasks(heap));
 
          MorphInstancesPhase1Allocate(&locator, IG->become());
          {
            // Apply the new class table before "become". Become will replace
            // all the instances of the old layout with forwarding corpses, then
            // perform a heap walk to fix references to the forwarding corpses.
            // During this heap walk, it will encounter instances of the new
            // layout, so it requires the new class table.
            ASSERT(HasNoTasks(heap));
 
            // We accepted the hot-reload and morphed instances. So now we can
            // commit to the changed class table and deleted the saved one.
            IG->DropOriginalClassTable();
          }
          MorphInstancesPhase2Become(IG->become());
 
          discard_class_tables = false;
        }
        // We are using the new class table now.
        if (FLAG_gc_during_reload) {
          // We force the GC to compact, which is more likely to discover
          // untracked pointers (and other issues, like incorrect class table).
          heap->CollectAllGarbage(GCReason::kDebugging, /*compact=*/true);
        }
      }
      if (FLAG_identity_reload) {
        if (!discard_class_tables) {
          TIR_Print("Identity reload failed! Some instances were morphed\n");
        }
        if (IG->heap_walk_class_table()->NumCids() !=
            IG->class_table()->NumCids()) {
          TIR_Print("Identity reload failed! B#C=%" Pd " A#C=%" Pd "\n",
                    IG->heap_walk_class_table()->NumCids(),
                    IG->class_table()->NumCids());
        }
        if (IG->heap_walk_class_table()->NumTopLevelCids() !=
            IG->class_table()->NumTopLevelCids()) {
          TIR_Print("Identity reload failed! B#TLC=%" Pd " A#TLC=%" Pd "\n",
                    IG->heap_walk_class_table()->NumTopLevelCids(),
                    IG->class_table()->NumTopLevelCids());
        }
      }
      if (discard_class_tables) {
        IG->DropOriginalClassTable();
      }
      isolate_group_->program_reload_context()->ReloadPhase4CommitFinish();
      TIR_Print("---- DONE COMMIT\n");
      isolate_group_->set_last_reload_timestamp(reload_timestamp_);
    } else {
      TIR_Print("---- ROLLING BACK");
      isolate_group_->program_reload_context()->ReloadPhase4Rollback();
    }
 
    // ValidateReload mutates the direct subclass information and does
    // not remove dead subclasses.  Rebuild the direct subclass
    // information from scratch.
    {
      SafepointWriteRwLocker ml(thread, IG->program_lock());
      IG->program_reload_context()->RebuildDirectSubclasses();
    }
    const intptr_t final_library_count =
        GrowableObjectArray::Handle(Z, IG->object_store()->libraries())
            .Length();
    CommonFinalizeTail(final_library_count);
  }
 
  // Reenable concurrent marking if it was initially on.
  if (old_concurrent_mark_flag) {
    heap->old_space()->set_enable_concurrent_mark(true);
  }
 
  bool success;
  if (!result.IsError() || HasReasonsForCancelling()) {
    ReportSuccess();
    success = true;
  } else {
    ReportReasonsForCancelling();
    success = false;
  }
 
  Array& null_array = Array::Handle(Z);
  // Invalidate the URI mapping caches.
  IG->object_store()->set_uri_to_resolved_uri_map(null_array);
  IG->object_store()->set_resolved_uri_to_uri_map(null_array);
 
  // Re-queue any shutdown requests so they can inform each isolate's own thread
  // to shut down.
  if (result.IsUnwindError()) {
    const auto& error = UnwindError::Cast(result);
    ForEachIsolate([&](Isolate* isolate) {
      Isolate::KillIfExists(isolate, error.is_user_initiated()
                                         ? Isolate::kKillMsg
                                         : Isolate::kInternalKillMsg);
    });
  }
 
  return success;
}

reload_aborted()

bool dart::IsolateGroupReloadContext::reload_aborted ( ) const

inline

Definition at line 159 of file isolate_reload.h.

{ return HasReasonsForCancelling(); }

reload_skipped()

bool dart::IsolateGroupReloadContext::reload_skipped ( ) const

inline

Definition at line 160 of file isolate_reload.h.

{ return reload_skipped_; }

reload_timestamp()

int64_t dart::IsolateGroupReloadContext::reload_timestamp ( ) const

inline

Definition at line 163 of file isolate_reload.h.

{ return reload_timestamp_; }

SetFileModifiedCallback()

static void dart::IsolateGroupReloadContext::SetFileModifiedCallback ( Dart_FileModifiedCallback  callback )

inlinestatic

Definition at line 168 of file isolate_reload.h.

                                                                          {
    file_modified_callback_ = callback;
  }

start_time_micros()

int64_t dart::IsolateGroupReloadContext::start_time_micros ( ) const

inline

Definition at line 162 of file isolate_reload.h.

{ return start_time_micros_; }

zone()

Zone * dart::IsolateGroupReloadContext::zone ( ) const

inline

Definition at line 156 of file isolate_reload.h.

{ return zone_; }

Friends And Related Function Documentation

Class

friend class Class

friend

Definition at line 281 of file isolate_reload.h.

Isolate

friend class Isolate

friend

Definition at line 280 of file isolate_reload.h.

IsolateGroup

friend class IsolateGroup

friend

Definition at line 286 of file isolate_reload.h.

Library

friend class Library

friend

Definition at line 282 of file isolate_reload.h.

ObjectLocator

friend class ObjectLocator

friend

Definition at line 283 of file isolate_reload.h.

ProgramReloadContext

friend class ProgramReloadContext

friend

Definition at line 285 of file isolate_reload.h.

ReasonForCancelling

friend class ReasonForCancelling

friend

Definition at line 284 of file isolate_reload.h.

---

The documentation for this class was generated from the following files:

• third_party/dart-lang/sdk/runtime/vm/isolate_reload.h
• third_party/dart-lang/sdk/runtime/vm/isolate_reload.cc