#include <isolate.h>

Inheritance diagram for dart::IsolateGroup:

Public Member Functions
	IsolateGroup (std::shared_ptr< IsolateGroupSource > source, void embedder_data, ObjectStore object_store, Dart_IsolateFlags api_flags, bool is_vm_isolate)

	IsolateGroup (std::shared_ptr< IsolateGroupSource > source, void *embedder_data, Dart_IsolateFlags api_flags, bool is_vm_isolate)

	~IsolateGroup ()

void	RehashConstants (Become *become)

IsolateGroupSource *	source () const

std::shared_ptr< IsolateGroupSource >	shareable_source () const

bool	is_vm_isolate () const

void *	embedder_data () const

bool	initial_spawn_successful ()

void	set_initial_spawn_successful ()

Heap *	heap () const

BackgroundCompiler *	background_compiler () const

intptr_t	optimization_counter_threshold () const

GroupDebugger *	debugger () const

IdleTimeHandler *	idle_time_handler ()

void	RegisterIsolate (Isolate *isolate)

void	UnregisterIsolate (Isolate *isolate)

bool	UnregisterIsolateDecrementCount ()

bool	ContainsOnlyOneIsolate ()

void	RunWithLockedGroup (std::function< void()> fun)

void	ScheduleInterrupts (uword interrupt_bits)

ThreadRegistry *	thread_registry () const

SafepointHandler *	safepoint_handler ()

void	CreateHeap (bool is_vm_isolate, bool is_service_or_kernel_isolate)

void	SetupImagePage (const uint8_t *snapshot_buffer, bool is_executable)

void	Shutdown ()

	ISOLATE_GROUP_METRIC_LIST (ISOLATE_METRIC_ACCESSOR)

void	UpdateLastAllocationProfileAccumulatorResetTimestamp ()

int64_t	last_allocationprofile_accumulator_reset_timestamp () const

void	UpdateLastAllocationProfileGCTimestamp ()

int64_t	last_allocationprofile_gc_timestamp () const

DispatchTable *	dispatch_table () const

void	set_dispatch_table (DispatchTable *table)

const uint8_t *	dispatch_table_snapshot () const

void	set_dispatch_table_snapshot (const uint8_t *snapshot)

intptr_t	dispatch_table_snapshot_size () const

void	set_dispatch_table_snapshot_size (intptr_t size)

ClassTableAllocator *	class_table_allocator ()

ClassPtr *	cached_class_table_table ()

void	set_cached_class_table_table (ClassPtr *cached_class_table_table)

void	set_object_store (ObjectStore *object_store)

void	set_obfuscation_map (const char **map)

const char **	obfuscation_map () const

Random *	random ()

bool	is_system_isolate_group () const

void	FlagsCopyTo (Dart_IsolateFlags *api_flags)

void	FlagsCopyFrom (const Dart_IsolateFlags &api_flags)

bool	should_load_vmservice () const

void	set_should_load_vmservice (bool value)

void	set_asserts (bool value)

void	set_branch_coverage (bool value)

bool	HasAttemptedReload () const

void	SetHasAttemptedReload (bool value)

void	MaybeIncreaseReloadEveryNStackOverflowChecks ()

intptr_t	reload_every_n_stack_overflow_checks () const

void	set_use_osr (bool use_osr)

ClassTable *	class_table () const

ClassTable *	heap_walk_class_table () const

void	CloneClassTableForReload ()

void	RestoreOriginalClassTable ()

void	DropOriginalClassTable ()

StoreBuffer *	store_buffer () const

ObjectStore *	object_store () const

Mutex *	symbols_mutex ()

Mutex *	type_canonicalization_mutex ()

Mutex *	type_arguments_canonicalization_mutex ()

Mutex *	subtype_test_cache_mutex ()

Mutex *	megamorphic_table_mutex ()

Mutex *	type_feedback_mutex ()

Mutex *	patchable_call_mutex ()

Mutex *	constant_canonicalization_mutex ()

Mutex *	kernel_data_lib_cache_mutex ()

Mutex *	kernel_data_class_cache_mutex ()

Mutex *	kernel_constants_mutex ()

Mutex *	initializer_functions_mutex ()

SafepointRwLock *	program_lock ()

void	IncreaseMutatorCount (Isolate *mutator, bool is_nested_reenter)

void	DecreaseMutatorCount (Isolate *mutator, bool is_nested_exit)

intptr_t	MutatorCount () const

bool	HasTagHandler () const

ObjectPtr	CallTagHandler (Dart_LibraryTag tag, const Object &arg1, const Object &arg2)

Dart_LibraryTagHandler	library_tag_handler () const

void	set_library_tag_handler (Dart_LibraryTagHandler handler)

Dart_DeferredLoadHandler	deferred_load_handler () const

void	set_deferred_load_handler (Dart_DeferredLoadHandler handler)

void	ReleaseStoreBuffers ()

void	FlushMarkingStacks ()

void	EnableIncrementalBarrier (MarkingStack marking_stack, MarkingStack deferred_marking_stack)

void	DisableIncrementalBarrier ()

MarkingStack *	marking_stack () const

MarkingStack *	deferred_marking_stack () const

void	ForEachIsolate (std::function< void(Isolate *isolate)> function, bool at_safepoint=false)

Isolate *	FirstIsolate () const

Isolate *	FirstIsolateLocked () const

void	RunWithStoppedMutatorsCallable (Callable single_current_mutator, Callable otherwise, bool use_force_growth_in_otherwise=false)

template<typename T , typename S >
void	RunWithStoppedMutators (T single_current_mutator, S otherwise, bool use_force_growth_in_otherwise=false)

template<typename T >
void	RunWithStoppedMutators (T function, bool use_force_growth=false)

void	PrintJSON (JSONStream *stream, bool ref=true)

void	PrintToJSONObject (JSONObject *jsobj, bool ref)

void	PrintMemoryUsageJSON (JSONStream *stream)

bool	ReloadSources (JSONStream js, bool force_reload, const char root_script_url=nullptr, const char *packages_url=nullptr, bool dont_delete_reload_context=false)

bool	ReloadKernel (JSONStream js, bool force_reload, const uint8_t kernel_buffer=nullptr, intptr_t kernel_buffer_size=0, bool dont_delete_reload_context=false)

void	set_last_reload_timestamp (int64_t value)

int64_t	last_reload_timestamp () const

IsolateGroupReloadContext *	reload_context ()

ProgramReloadContext *	program_reload_context ()

void	DeleteReloadContext ()

bool	CanReload ()

bool	IsReloading () const

Become *	become () const

void	set_become (Become *become)

uint64_t	id () const

int64_t	UptimeMicros () const

ApiState *	api_state () const

void	VisitObjectPointers (ObjectPointerVisitor *visitor, ValidationPolicy validate_frames)

void	VisitSharedPointers (ObjectPointerVisitor *visitor)

void	VisitStackPointers (ObjectPointerVisitor *visitor, ValidationPolicy validate_frames)

void	VisitObjectIdRingPointers (ObjectPointerVisitor *visitor)

void	VisitWeakPersistentHandles (HandleVisitor *visitor)

bool	all_classes_finalized () const

void	set_all_classes_finalized (bool value)

bool	remapping_cids () const

void	set_remapping_cids (bool value)

void	RememberLiveTemporaries ()

void	DeferredMarkLiveTemporaries ()

ArrayPtr	saved_unlinked_calls () const

void	set_saved_unlinked_calls (const Array &saved_unlinked_calls)

FieldTable *	initial_field_table () const

std::shared_ptr< FieldTable >	initial_field_table_shareable ()

void	set_initial_field_table (std::shared_ptr< FieldTable > field_table)

MutatorThreadPool *	thread_pool ()

void	RegisterClass (const Class &cls)

void	RegisterStaticField (const Field &field, const Object &initial_value)

void	FreeStaticField (const Field &field)

Isolate *	EnterTemporaryIsolate ()

Public Member Functions inherited from dart::IntrusiveDListEntry< IsolateGroup >
	IntrusiveDListEntry ()

	~IntrusiveDListEntry ()

Static Public Member Functions
static intptr_t	class_table_offset ()

static intptr_t	cached_class_table_table_offset ()

static intptr_t	object_store_offset ()

static void	FlagsInitialize (Dart_IsolateFlags *api_flags)

static IsolateGroup *	Current ()

static void	Init ()

static void	Cleanup ()

static void	ForEach (std::function< void(IsolateGroup *)> action)

static void	RunWithIsolateGroup (uint64_t id, std::function< void(IsolateGroup *)> action, std::function< void()> not_found)

static void	RegisterIsolateGroup (IsolateGroup *isolate_group)

static void	UnregisterIsolateGroup (IsolateGroup *isolate_group)

static bool	HasApplicationIsolateGroups ()

static bool	HasOnlyVMIsolateGroup ()

static bool	IsSystemIsolateGroup (const IsolateGroup *group)

static void	ExitTemporaryIsolate ()

Friends
class	Dart

class	Heap

class	StackFrame

class	Isolate

Detailed Description

Definition at line 267 of file isolate.h.

Constructor & Destructor Documentation

◆ IsolateGroup() [1/2]

dart::IsolateGroup::IsolateGroup	(	std::shared_ptr< IsolateGroupSource >	source,
		void *	embedder_data,
		ObjectStore *	object_store,
		Dart_IsolateFlags	api_flags,
		bool	is_vm_isolate
	)

Definition at line 325 of file isolate.cc.

    : class_table_(nullptr),
      cached_class_table_table_(nullptr),
      object_store_(object_store),
      class_table_allocator_(),
      is_vm_isolate_(is_vm_isolate),
      embedder_data_(embedder_data),
      thread_pool_(),
      isolates_lock_(new SafepointRwLock()),
      isolates_(),
      start_time_micros_(OS::GetCurrentMonotonicMicros()),
      is_system_isolate_group_(source->flags.is_system_isolate),
      random_(),
#if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
      last_reload_timestamp_(OS::GetCurrentTimeMillis()),
      reload_every_n_stack_overflow_checks_(FLAG_reload_every),
#endif
      source_(std::move(source)),
      api_state_(new ApiState()),
      thread_registry_(new ThreadRegistry()),
      safepoint_handler_(new SafepointHandler(this)),
      store_buffer_(new StoreBuffer()),
      heap_(nullptr),
      saved_unlinked_calls_(Array::null()),
      initial_field_table_(new FieldTable(/*isolate=*/nullptr)),
#if !defined(DART_PRECOMPILED_RUNTIME)
      background_compiler_(new BackgroundCompiler(this)),
#endif
      symbols_mutex_(NOT_IN_PRODUCT("IsolateGroup::symbols_mutex_")),
      type_canonicalization_mutex_(
          NOT_IN_PRODUCT("IsolateGroup::type_canonicalization_mutex_")),
      type_arguments_canonicalization_mutex_(NOT_IN_PRODUCT(
          "IsolateGroup::type_arguments_canonicalization_mutex_")),
      subtype_test_cache_mutex_(
          NOT_IN_PRODUCT("IsolateGroup::subtype_test_cache_mutex_")),
      megamorphic_table_mutex_(
          NOT_IN_PRODUCT("IsolateGroup::megamorphic_table_mutex_")),
      type_feedback_mutex_(
          NOT_IN_PRODUCT("IsolateGroup::type_feedback_mutex_")),
      patchable_call_mutex_(
          NOT_IN_PRODUCT("IsolateGroup::patchable_call_mutex_")),
      constant_canonicalization_mutex_(
          NOT_IN_PRODUCT("IsolateGroup::constant_canonicalization_mutex_")),
      kernel_data_lib_cache_mutex_(
          NOT_IN_PRODUCT("IsolateGroup::kernel_data_lib_cache_mutex_")),
      kernel_data_class_cache_mutex_(
          NOT_IN_PRODUCT("IsolateGroup::kernel_data_class_cache_mutex_")),
      kernel_constants_mutex_(
          NOT_IN_PRODUCT("IsolateGroup::kernel_constants_mutex_")),
      field_list_mutex_(NOT_IN_PRODUCT("Isolate::field_list_mutex_")),
      boxed_field_list_(GrowableObjectArray::null()),
      program_lock_(new SafepointRwLock()),
      active_mutators_monitor_(new Monitor()),
      max_active_mutators_(Scavenger::MaxMutatorThreadCount())
#if !defined(PRODUCT)
      ,
      debugger_(new GroupDebugger(this))
#endif
{
  FlagsCopyFrom(api_flags);
  if (!is_vm_isolate) {
    thread_pool_.reset(
        new MutatorThreadPool(this, FLAG_disable_thread_pool_limit
                                        ? 0
                                        : Scavenger::MaxMutatorThreadCount()));
  }
  {
    WriteRwLocker wl(ThreadState::Current(), isolate_groups_rwlock_);
    // Keep isolate IDs less than 2^53 so web clients of the service
    // protocol can process it properly.
    //
    // See https://github.com/dart-lang/sdk/issues/53081.
    id_ = isolate_group_random_->NextJSInt();
  }
  heap_walk_class_table_ = class_table_ =
      new ClassTable(&class_table_allocator_);
  cached_class_table_table_.store(class_table_->table());
}

◆ IsolateGroup() [2/2]

dart::IsolateGroup::IsolateGroup	(	std::shared_ptr< IsolateGroupSource >	source,
		void *	embedder_data,
		Dart_IsolateFlags	api_flags,
		bool	is_vm_isolate
	)

Definition at line 408 of file isolate.cc.

    : IsolateGroup(source,
                   embedder_data,
                   new ObjectStore(),
                   api_flags,
                   is_vm_isolate) {
  if (object_store() != nullptr) {
    object_store()->InitStubs();
  }
}

◆ ~IsolateGroup()

dart::IsolateGroup::~IsolateGroup ( )

Definition at line 422 of file isolate.cc.

                            {
  // Ensure we destroy the heap before the other members.
  heap_ = nullptr;
  ASSERT(marking_stack_ == nullptr);
 
  if (obfuscation_map_ != nullptr) {
    for (intptr_t i = 0; obfuscation_map_[i] != nullptr; i++) {
      delete[] obfuscation_map_[i];
    }
    delete[] obfuscation_map_;
  }
 
  class_table_allocator_.Free(class_table_);
  if (heap_walk_class_table_ != class_table_) {
    class_table_allocator_.Free(heap_walk_class_table_);
  }
 
#if !defined(PRODUCT)
  delete debugger_;
  debugger_ = nullptr;
#endif
}

Member Function Documentation

◆ all_classes_finalized()

bool dart::IsolateGroup::all_classes_finalized ( ) const

inline

Definition at line 706 of file isolate.h.

                                     {
    return AllClassesFinalizedBit::decode(isolate_group_flags_);
  }

◆ api_state()

ApiState * dart::IsolateGroup::api_state ( ) const

inline

Definition at line 693 of file isolate.h.

693{ return api_state_.get(); }

◆ background_compiler()

BackgroundCompiler * dart::IsolateGroup::background_compiler ( ) const

inline

Definition at line 297 of file isolate.h.

                                                  {
#if defined(DART_PRECOMPILED_RUNTIME)
    return nullptr;
#else
    return background_compiler_.get();
#endif
  }

◆ become()

Become * dart::IsolateGroup::become ( ) const

inline

Definition at line 670 of file isolate.h.

670{ return become_; }

◆ cached_class_table_table()

ClassPtr * dart::IsolateGroup::cached_class_table_table ( )

inline

Definition at line 389 of file isolate.h.

                                       {
    return cached_class_table_table_.load();
  }

◆ cached_class_table_table_offset()

static intptr_t dart::IsolateGroup::cached_class_table_table_offset ( )

inlinestatic

Definition at line 395 of file isolate.h.

                                                    {
    COMPILE_ASSERT(sizeof(IsolateGroup::cached_class_table_table_) ==
                   kWordSize);
    return OFFSET_OF(IsolateGroup, cached_class_table_table_);
  }

◆ CallTagHandler()

ObjectPtr dart::IsolateGroup::CallTagHandler	(	Dart_LibraryTag	tag,
		const Object &	arg1,
		const Object &	arg2
	)

Definition at line 1889 of file isolate.cc.

                                                           {
  Thread* thread = Thread::Current();
  Api::Scope api_scope(thread);
  Dart_Handle api_arg1 = Api::NewHandle(thread, arg1.ptr());
  Dart_Handle api_arg2 = Api::NewHandle(thread, arg2.ptr());
  Dart_Handle api_result;
  {
    TransitionVMToNative transition(thread);
    ASSERT(HasTagHandler());
    api_result = library_tag_handler()(tag, api_arg1, api_arg2);
  }
  return Api::UnwrapHandle(api_result);
}

◆ CanReload()

bool dart::IsolateGroup::CanReload ( )

Definition at line 2006 of file isolate.cc.

                             {
  // We only call this method on the mutator thread. Normally the caller is
  // inside of the "reloadSources" service OOB message handler. Though
  // we also use it in the slow path of StackOverflowCheck in the artificial
  // --hot-reload-test-mode like flags.
  //
  // During reload itself we don't process OOB messages and don't execute Dart
  // code, so the caller should implicitly have a guarantee we're not reloading
  // already.
  RELEASE_ASSERT(!Thread::Current()->OwnsReloadSafepoint());
 
  // We only allow reload to take place from the point on where the first
  // isolate within an isolate group has setup it's root library. From that
  // point on it's safe to perform hot-reload.
  auto thread = Thread::Current();
  if (object_store()->root_library() == Library::null()) {
    return false;
  }
 
  // We only care about the current thread's [NoReloadScope]. If we're inside
  // one we cannot reload right now. Though if another isolate's mutator
  // thread is inside such a scope, the multi-isolate reload will simply wait
  // until it's out of that scope again.
  if (thread->no_reload_scope_depth_ != 0) {
    return false;
  }
 
  return !IsolateGroup::IsSystemIsolateGroup(this) &&
         OSThread::Current()->HasStackHeadroom(64 * KB);
}

◆ class_table()

ClassTable * dart::IsolateGroup::class_table ( ) const

inline

Definition at line 491 of file isolate.h.

491{ return class_table_; }

◆ class_table_allocator()

ClassTableAllocator * dart::IsolateGroup::class_table_allocator ( )

inline

Definition at line 380 of file isolate.h.

                                               {
    return &class_table_allocator_;
  }

◆ class_table_offset()

static intptr_t dart::IsolateGroup::class_table_offset ( )

inlinestatic

Definition at line 384 of file isolate.h.

                                       {
    COMPILE_ASSERT(sizeof(IsolateGroup::class_table_) == kWordSize);
    return OFFSET_OF(IsolateGroup, class_table_);
  }

◆ Cleanup()

void dart::IsolateGroup::Cleanup ( )

static

Definition at line 736 of file isolate.cc.

                           {
  delete isolate_group_random_;
  isolate_group_random_ = nullptr;
  delete isolate_groups_rwlock_;
  isolate_groups_rwlock_ = nullptr;
  ASSERT(isolate_groups_->IsEmpty());
  delete isolate_groups_;
  isolate_groups_ = nullptr;
}

◆ CloneClassTableForReload()

void dart::IsolateGroup::CloneClassTableForReload ( )

Definition at line 3771 of file isolate.cc.

                                            {
  RELEASE_ASSERT(class_table_ == heap_walk_class_table_);
  class_table_ = class_table_->Clone();
  set_cached_class_table_table(nullptr);
}

◆ constant_canonicalization_mutex()

Mutex * dart::IsolateGroup::constant_canonicalization_mutex ( )

inline

Definition at line 515 of file isolate.h.

                                           {
    return &constant_canonicalization_mutex_;
  }

◆ ContainsOnlyOneIsolate()

bool dart::IsolateGroup::ContainsOnlyOneIsolate ( )

Definition at line 452 of file isolate.cc.

                                          {
  SafepointReadRwLocker ml(Thread::Current(), isolates_lock_.get());
  // We do allow 0 here as well, because the background compiler might call
  // this method while the mutator thread is in shutdown procedure and
  // unregistered itself already.
  return isolate_count_ == 0 || isolate_count_ == 1;
}

◆ CreateHeap()

void dart::IsolateGroup::CreateHeap	(	bool	is_vm_isolate,
		bool	is_service_or_kernel_isolate
	)

Definition at line 476 of file isolate.cc.

                                                                 {
  Heap::Init(this, is_vm_isolate,
             is_vm_isolate
                 ? 0  // New gen size 0; VM isolate should only allocate in old.
                 : FLAG_new_gen_semi_max_size * MBInWords,
             (is_service_or_kernel_isolate ? kDefaultMaxOldGenHeapSize
                                           : FLAG_old_gen_heap_size) *
                 MBInWords);
 
#define ISOLATE_GROUP_METRIC_CONSTRUCTORS(type, variable, name, unit)          \
  metric_##variable##_.InitInstance(this, name, nullptr, Metric::unit);
  ISOLATE_GROUP_METRIC_LIST(ISOLATE_GROUP_METRIC_CONSTRUCTORS)
#undef ISOLATE_GROUP_METRIC_CONSTRUCTORS
}

◆ Current()

static IsolateGroup * dart::IsolateGroup::Current ( )

inlinestatic

Definition at line 534 of file isolate.h.

                                        {
    Thread* thread = Thread::Current();
    return thread == nullptr ? nullptr : thread->isolate_group();
  }

◆ debugger()

GroupDebugger * dart::IsolateGroup::debugger ( ) const

inline

Definition at line 314 of file isolate.h.

314{ return debugger_; }

◆ DecreaseMutatorCount()

void dart::IsolateGroup::DecreaseMutatorCount	(	Isolate *	mutator,
		bool	is_nested_exit
	)

Definition at line 612 of file isolate.cc.

                                                                             {
  ASSERT(mutator->group() == this);
 
  // If the mutator thread has an active stack and runs on our thread pool we
  // will mark the worker as blocked, thereby possibly spawning a new worker for
  // pending tasks (if there are any).
  if (is_nested_exit) {
    ASSERT(mutator->mutator_thread() != nullptr);
    thread_pool()->MarkCurrentWorkerAsBlocked();
  }
 
  {
    // NOTE: This is performance critical code, we should avoid monitors and use
    // std::atomics in the fast case (where active_mutators <
    // max_active_mutators) and only use monitors in the uncommon case.
    MonitorLocker ml(active_mutators_monitor_.get());
    ASSERT(active_mutators_ <= max_active_mutators_);
    active_mutators_--;
    if (waiting_mutators_ > 0) {
      ml.Notify();
    }
  }
}

◆ deferred_load_handler()

Dart_DeferredLoadHandler dart::IsolateGroup::deferred_load_handler ( ) const

inline

Definition at line 556 of file isolate.h.

                                                         {
    return deferred_load_handler_;
  }

◆ deferred_marking_stack()

MarkingStack * dart::IsolateGroup::deferred_marking_stack ( ) const

inline

Definition at line 571 of file isolate.h.

                                               {
    return deferred_marking_stack_;
  }

◆ DeferredMarkLiveTemporaries()

void dart::IsolateGroup::DeferredMarkLiveTemporaries ( )

Definition at line 2956 of file isolate.cc.

                                               {
  ForEachIsolate(
      [&](Isolate* isolate) { isolate->DeferredMarkLiveTemporaries(); },
      /*at_safepoint=*/true);
}

◆ DeleteReloadContext()

void dart::IsolateGroup::DeleteReloadContext ( )

Definition at line 2095 of file isolate.cc.

                                       {
  GcSafepointOperationScope safepoint_scope(Thread::Current());
  group_reload_context_.reset();
 
  delete program_reload_context_;
  program_reload_context_ = nullptr;
}

◆ DisableIncrementalBarrier()

void dart::IsolateGroup::DisableIncrementalBarrier ( )

Definition at line 2791 of file isolate.cc.

                                             {
  thread_registry()->ReleaseMarkingStacks();
  ASSERT(marking_stack_ != nullptr);
  marking_stack_ = nullptr;
  deferred_marking_stack_ = nullptr;
}

◆ dispatch_table()

DispatchTable * dart::IsolateGroup::dispatch_table ( ) const

inline

Definition at line 363 of file isolate.h.

363{ return dispatch_table_.get(); }

◆ dispatch_table_snapshot()

const uint8_t * dart::IsolateGroup::dispatch_table_snapshot ( ) const

inline

Definition at line 367 of file isolate.h.

                                                 {
    return dispatch_table_snapshot_;
  }

◆ dispatch_table_snapshot_size()

intptr_t dart::IsolateGroup::dispatch_table_snapshot_size ( ) const

inline

Definition at line 373 of file isolate.h.

                                                {
    return dispatch_table_snapshot_size_;
  }

◆ DropOriginalClassTable()

void dart::IsolateGroup::DropOriginalClassTable ( )

Definition at line 3784 of file isolate.cc.

                                          {
  RELEASE_ASSERT(class_table_ != heap_walk_class_table_);
  class_table_allocator_.Free(heap_walk_class_table_);
  heap_walk_class_table_ = class_table_;
  set_cached_class_table_table(class_table_->table());
}

◆ embedder_data()

void * dart::IsolateGroup::embedder_data ( ) const

inline

Definition at line 290 of file isolate.h.

290{ return embedder_data_; }

◆ EnableIncrementalBarrier()

void dart::IsolateGroup::EnableIncrementalBarrier	(	MarkingStack *	marking_stack,
		MarkingStack *	deferred_marking_stack
	)

Definition at line 2781 of file isolate.cc.

                                          {
  ASSERT(marking_stack_ == nullptr);
  marking_stack_ = marking_stack;
  deferred_marking_stack_ = deferred_marking_stack;
  thread_registry()->AcquireMarkingStacks();
  ASSERT(Thread::Current()->is_marking());
}

◆ EnterTemporaryIsolate()

Isolate * dart::IsolateGroup::EnterTemporaryIsolate ( )

Definition at line 835 of file isolate.cc.

                                             {
  Dart_IsolateFlags flags;
  Isolate::FlagsInitialize(&flags);
  Isolate* const isolate = Isolate::InitIsolate("temp", this, flags);
  ASSERT(isolate != nullptr);
  ASSERT(Isolate::Current() == isolate);
  return isolate;
}

◆ ExitTemporaryIsolate()

void dart::IsolateGroup::ExitTemporaryIsolate ( )

static

Definition at line 844 of file isolate.cc.

                                        {
  Thread* thread = Thread::Current();
  ASSERT(thread != nullptr);
  thread->set_execution_state(Thread::kThreadInVM);
  Dart::ShutdownIsolate(thread);
}

◆ FirstIsolate()

Isolate * dart::IsolateGroup::FirstIsolate ( ) const

Definition at line 2825 of file isolate.cc.

                                          {
  SafepointReadRwLocker ml(Thread::Current(), isolates_lock_.get());
  return FirstIsolateLocked();
}

◆ FirstIsolateLocked()

Isolate * dart::IsolateGroup::FirstIsolateLocked ( ) const

Definition at line 2830 of file isolate.cc.

                                                {
  return isolates_.IsEmpty() ? nullptr : isolates_.First();
}

◆ FlagsCopyFrom()

void dart::IsolateGroup::FlagsCopyFrom ( const Dart_IsolateFlags & api_flags )

Definition at line 1586 of file isolate.cc.

                                                                   {
#if defined(DART_PRECOMPILER)
#define FLAG_FOR_PRECOMPILER(action) action
#else
#define FLAG_FOR_PRECOMPILER(action)
#endif
 
#if !defined(PRODUCT)
#define FLAG_FOR_NONPRODUCT(action) action
#else
#define FLAG_FOR_NONPRODUCT(action)
#endif
 
#define FLAG_FOR_PRODUCT(action) action
 
#define SET_FROM_FLAG(when, name, bitname, isolate_flag, flag)                 \
  FLAG_FOR_##when(isolate_group_flags_ = bitname##Bit::update(                 \
                      api_flags.isolate_flag, isolate_group_flags_));
 
  BOOL_ISOLATE_GROUP_FLAG_LIST(SET_FROM_FLAG)
#undef FLAG_FOR_NONPRODUCT
#undef FLAG_FOR_PRECOMPILER
#undef FLAG_FOR_PRODUCT
#undef SET_FROM_FLAG
}

◆ FlagsCopyTo()

void dart::IsolateGroup::FlagsCopyTo ( Dart_IsolateFlags * api_flags )

Definition at line 1575 of file isolate.cc.

                                                           {
  api_flags->version = DART_FLAGS_CURRENT_VERSION;
#define INIT_FROM_FIELD(when, name, bitname, isolate_flag, flag)               \
  api_flags->isolate_flag = name();
  BOOL_ISOLATE_GROUP_FLAG_LIST(INIT_FROM_FIELD)
#undef INIT_FROM_FIELD
  api_flags->is_service_isolate = false;
  api_flags->is_kernel_isolate = false;
  api_flags->null_safety = true;
}

◆ FlagsInitialize()

void dart::IsolateGroup::FlagsInitialize ( Dart_IsolateFlags * api_flags )

static

Definition at line 1564 of file isolate.cc.

                                                               {
  api_flags->version = DART_FLAGS_CURRENT_VERSION;
#define INIT_FROM_FLAG(when, name, bitname, isolate_flag, flag)                \
  api_flags->isolate_flag = flag;
  BOOL_ISOLATE_GROUP_FLAG_LIST(INIT_FROM_FLAG)
#undef INIT_FROM_FLAG
  api_flags->is_service_isolate = false;
  api_flags->is_kernel_isolate = false;
  api_flags->null_safety = true;
}

◆ FlushMarkingStacks()

void dart::IsolateGroup::FlushMarkingStacks ( )

Definition at line 2744 of file isolate.cc.

                                      {
  thread_registry()->FlushMarkingStacks();
}

◆ ForEach()

void dart::IsolateGroup::ForEach ( std::function< void(IsolateGroup *)> action )

static

Definition at line 677 of file isolate.cc.

                                                                  {
  ReadRwLocker wl(Thread::Current(), isolate_groups_rwlock_);
  for (auto isolate_group : *isolate_groups_) {
    action(isolate_group);
  }
}

◆ ForEachIsolate()

void dart::IsolateGroup::ForEachIsolate	(	std::function< void(Isolate *isolate)>	function,
		bool	at_safepoint = `false`
	)

Definition at line 2798 of file isolate.cc.

                       {
  auto thread = Thread::Current();
  if (at_safepoint) {
    ASSERT(thread->OwnsSafepoint() ||
           (thread->task_kind() == Thread::kMutatorTask) ||
           (thread->task_kind() == Thread::kMarkerTask) ||
           (thread->task_kind() == Thread::kCompactorTask) ||
           (thread->task_kind() == Thread::kScavengerTask));
    for (Isolate* isolate : isolates_) {
      function(isolate);
    }
    return;
  }
  if (thread != nullptr && thread->OwnsSafepoint()) {
    for (Isolate* isolate : isolates_) {
      function(isolate);
    }
    return;
  }
  SafepointReadRwLocker ml(thread, isolates_lock_.get());
  for (Isolate* isolate : isolates_) {
    function(isolate);
  }
}

◆ FreeStaticField()

void dart::IsolateGroup::FreeStaticField ( const Field & field )

Definition at line 816 of file isolate.cc.

                                                     {
#if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
  // This can only be called during hot-reload.
  ASSERT(program_reload_context() != nullptr);
#endif
 
  const intptr_t field_id = field.field_id();
  initial_field_table()->Free(field_id);
  ForEachIsolate([&](Isolate* isolate) {
    auto field_table = isolate->field_table();
    // The isolate might've just been created and is now participating in
    // the reload request inside `IsolateGroup::RegisterIsolate()`.
    // At that point it doesn't have the field table setup yet.
    if (field_table->IsReadyToUse()) {
      field_table->Free(field_id);
    }
  });
}

◆ HasApplicationIsolateGroups()

bool dart::IsolateGroup::HasApplicationIsolateGroups ( )

static

Definition at line 708 of file isolate.cc.

                                               {
  ReadRwLocker wl(ThreadState::Current(), isolate_groups_rwlock_);
  for (auto group : *isolate_groups_) {
    if (!IsolateGroup::IsSystemIsolateGroup(group)) {
      return true;
    }
  }
  return false;
}

◆ HasAttemptedReload()

bool dart::IsolateGroup::HasAttemptedReload ( ) const

inline

Definition at line 464 of file isolate.h.

                                  {
    return HasAttemptedReloadBit::decode(isolate_group_flags_);
  }

◆ HasOnlyVMIsolateGroup()

bool dart::IsolateGroup::HasOnlyVMIsolateGroup ( )

static

Definition at line 718 of file isolate.cc.

                                         {
  ReadRwLocker wl(ThreadState::Current(), isolate_groups_rwlock_);
  for (auto group : *isolate_groups_) {
    if (!group->is_vm_isolate()) {
      return false;
    }
  }
  return true;
}

◆ HasTagHandler()

bool dart::IsolateGroup::HasTagHandler ( ) const

inline

Definition at line 546 of file isolate.h.

546{ return library_tag_handler() != nullptr; }

◆ heap()

Heap * dart::IsolateGroup::heap ( ) const

inline

Definition at line 295 of file isolate.h.

295{ return heap_.get(); }

◆ heap_walk_class_table()

ClassTable * dart::IsolateGroup::heap_walk_class_table ( ) const

inline

Definition at line 498 of file isolate.h.

498{ return heap_walk_class_table_; }

◆ id()

uint64_t dart::IsolateGroup::id ( ) const

inline

Definition at line 673 of file isolate.h.

673{ return id_; }

◆ idle_time_handler()

IdleTimeHandler * dart::IsolateGroup::idle_time_handler ( )

inline

Definition at line 317 of file isolate.h.

317{ return &idle_time_handler_; }

◆ IncreaseMutatorCount()

void dart::IsolateGroup::IncreaseMutatorCount	(	Isolate *	mutator,
		bool	is_nested_reenter
	)

Definition at line 584 of file isolate.cc.

                                                                {
  ASSERT(mutator->group() == this);
 
  // If the mutator was temporarily blocked on a worker thread, we have to
  // unblock the worker thread again.
  if (is_nested_reenter) {
    ASSERT(mutator->mutator_thread() != nullptr);
    thread_pool()->MarkCurrentWorkerAsUnBlocked();
  }
 
  // Prevent too many mutators from entering the isolate group to avoid
  // pathological behavior where many threads are fighting for obtaining TLABs.
  {
    // NOTE: This is performance critical code, we should avoid monitors and use
    // std::atomics in the fast case (where active_mutators <
    // max_active_mutators) and only use monitors in the uncommon case.
    MonitorLocker ml(active_mutators_monitor_.get());
    ASSERT(active_mutators_ <= max_active_mutators_);
    while (active_mutators_ == max_active_mutators_) {
      waiting_mutators_++;
      ml.Wait();
      waiting_mutators_--;
    }
    active_mutators_++;
  }
}

◆ Init()

void dart::IsolateGroup::Init ( )

static

Definition at line 728 of file isolate.cc.

                        {
  ASSERT(isolate_groups_rwlock_ == nullptr);
  isolate_groups_rwlock_ = new RwLock();
  ASSERT(isolate_groups_ == nullptr);
  isolate_groups_ = new IntrusiveDList<IsolateGroup>();
  isolate_group_random_ = new Random();
}

◆ initial_field_table()

FieldTable * dart::IsolateGroup::initial_field_table ( ) const

inline

Definition at line 728 of file isolate.h.

728{ return initial_field_table_.get(); }

◆ initial_field_table_shareable()

std::shared_ptr< FieldTable > dart::IsolateGroup::initial_field_table_shareable ( )

inline

Definition at line 729 of file isolate.h.

                                                            {
    return initial_field_table_;
  }

◆ initial_spawn_successful()

bool dart::IsolateGroup::initial_spawn_successful ( )

inline

Definition at line 292 of file isolate.h.

292{ return initial_spawn_successful_; }

◆ initializer_functions_mutex()

Mutex * dart::IsolateGroup::initializer_functions_mutex ( )

inline

Definition at line 529 of file isolate.h.

529{ return &initializer_functions_mutex_; }

◆ is_system_isolate_group()

bool dart::IsolateGroup::is_system_isolate_group ( ) const

inline

Definition at line 412 of file isolate.h.

412{ return is_system_isolate_group_; }

◆ is_vm_isolate()

bool dart::IsolateGroup::is_vm_isolate ( ) const

inline

Definition at line 289 of file isolate.h.

289{ return is_vm_isolate_; }

◆ ISOLATE_GROUP_METRIC_LIST()

dart::IsolateGroup::ISOLATE_GROUP_METRIC_LIST ( ISOLATE_METRIC_ACCESSOR )

◆ IsReloading()

bool dart::IsolateGroup::IsReloading ( ) const

inline

Definition at line 662 of file isolate.h.

                           {
#if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
    return group_reload_context_ != nullptr;
#else
    return false;
#endif
  }

◆ IsSystemIsolateGroup()

bool dart::IsolateGroup::IsSystemIsolateGroup ( const IsolateGroup * group )

static

Definition at line 3559 of file isolate.cc.

                                                                 {
  return group->source()->flags.is_system_isolate;
}

◆ kernel_constants_mutex()

Mutex * dart::IsolateGroup::kernel_constants_mutex ( )

inline

Definition at line 522 of file isolate.h.

522{ return &kernel_constants_mutex_; }

◆ kernel_data_class_cache_mutex()

Mutex * dart::IsolateGroup::kernel_data_class_cache_mutex ( )

inline

Definition at line 519 of file isolate.h.

                                         {
    return &kernel_data_class_cache_mutex_;
  }

◆ kernel_data_lib_cache_mutex()

Mutex * dart::IsolateGroup::kernel_data_lib_cache_mutex ( )

inline

Definition at line 518 of file isolate.h.

518{ return &kernel_data_lib_cache_mutex_; }

◆ last_allocationprofile_accumulator_reset_timestamp()

int64_t dart::IsolateGroup::last_allocationprofile_accumulator_reset_timestamp ( ) const

inline

Definition at line 350 of file isolate.h.

                                                                     {
    return last_allocationprofile_accumulator_reset_timestamp_;
  }

◆ last_allocationprofile_gc_timestamp()

int64_t dart::IsolateGroup::last_allocationprofile_gc_timestamp ( ) const

inline

Definition at line 358 of file isolate.h.

                                                      {
    return last_allocationprofile_gc_timestamp_;
  }

◆ last_reload_timestamp()

int64_t dart::IsolateGroup::last_reload_timestamp ( ) const

inline

Definition at line 647 of file isolate.h.

647{ return last_reload_timestamp_; }

◆ library_tag_handler()

Dart_LibraryTagHandler dart::IsolateGroup::library_tag_handler ( ) const

inline

Definition at line 550 of file isolate.h.

                                                     {
    return library_tag_handler_;
  }

◆ marking_stack()

MarkingStack * dart::IsolateGroup::marking_stack ( ) const

inline

Definition at line 570 of file isolate.h.

570{ return marking_stack_; }

◆ MaybeIncreaseReloadEveryNStackOverflowChecks()

void dart::IsolateGroup::MaybeIncreaseReloadEveryNStackOverflowChecks ( )

Definition at line 2496 of file isolate.cc.

                                                                {
  if (FLAG_reload_every_back_off) {
    if (reload_every_n_stack_overflow_checks_ < 5000) {
      reload_every_n_stack_overflow_checks_ += 99;
    } else {
      const auto old_value = reload_every_n_stack_overflow_checks_;
      reload_every_n_stack_overflow_checks_ = old_value * old_value;
    }
    // Cap the value.
    if (reload_every_n_stack_overflow_checks_ > 1000000) {
      reload_every_n_stack_overflow_checks_ = 1000000;
    }
  }
}

◆ megamorphic_table_mutex()

Mutex * dart::IsolateGroup::megamorphic_table_mutex ( )

inline

Definition at line 512 of file isolate.h.

512{ return &megamorphic_table_mutex_; }

◆ MutatorCount()

intptr_t dart::IsolateGroup::MutatorCount ( ) const

inline

Definition at line 541 of file isolate.h.

                                {
    MonitorLocker ml(active_mutators_monitor_.get());
    return active_mutators_;
  }

◆ obfuscation_map()

const char ** dart::IsolateGroup::obfuscation_map ( ) const

inline

Definition at line 408 of file isolate.h.

408{ return obfuscation_map_; }

◆ object_store()

ObjectStore * dart::IsolateGroup::object_store ( ) const

inline

Definition at line 505 of file isolate.h.

505{ return object_store_.get(); }

◆ object_store_offset()

static intptr_t dart::IsolateGroup::object_store_offset ( )

inlinestatic

Definition at line 402 of file isolate.h.

                                        {
    COMPILE_ASSERT(sizeof(IsolateGroup::object_store_) == kWordSize);
    return OFFSET_OF(IsolateGroup, object_store_);
  }

◆ optimization_counter_threshold()

intptr_t dart::IsolateGroup::optimization_counter_threshold ( ) const

inline

Definition at line 305 of file isolate.h.

                                                  {
    if (IsSystemIsolateGroup(this)) {
      return kDefaultOptimizationCounterThreshold;
    }
    return FLAG_optimization_counter_threshold;
  }

◆ patchable_call_mutex()

Mutex * dart::IsolateGroup::patchable_call_mutex ( )

inline

Definition at line 514 of file isolate.h.

514{ return &patchable_call_mutex_; }

◆ PrintJSON()

void dart::IsolateGroup::PrintJSON	(	JSONStream *	stream,
		bool	ref = `true`
	)

Definition at line 637 of file isolate.cc.

                                                         {
  JSONObject jsobj(stream);
  PrintToJSONObject(&jsobj, ref);
}

◆ PrintMemoryUsageJSON()

void dart::IsolateGroup::PrintMemoryUsageJSON ( JSONStream * stream )

Definition at line 662 of file isolate.cc.

                                                          {
  int64_t used = heap()->TotalUsedInWords();
  int64_t capacity = heap()->TotalCapacityInWords();
  int64_t external_used = heap()->TotalExternalInWords();
 
  JSONObject jsobj(stream);
  // This is the same "MemoryUsage" that the isolate-specific "getMemoryUsage"
  // rpc method returns.
  jsobj.AddProperty("type", "MemoryUsage");
  jsobj.AddProperty64("heapUsage", used * kWordSize);
  jsobj.AddProperty64("heapCapacity", capacity * kWordSize);
  jsobj.AddProperty64("externalUsage", external_used * kWordSize);
}

◆ PrintToJSONObject()

void dart::IsolateGroup::PrintToJSONObject	(	JSONObject *	jsobj,
		bool	ref
	)

Definition at line 642 of file isolate.cc.

                                                                {
  jsobj->AddProperty("type", (ref ? "@IsolateGroup" : "IsolateGroup"));
  jsobj->AddServiceId(ISOLATE_GROUP_SERVICE_ID_FORMAT_STRING, id());
 
  jsobj->AddProperty("name", source()->script_uri);
  jsobj->AddPropertyF("number", "%" Pu64 "", id());
  jsobj->AddProperty("isSystemIsolateGroup", is_system_isolate_group());
  if (ref) {
    return;
  }
 
  {
    JSONArray isolate_array(jsobj, "isolates");
    for (auto it = isolates_.Begin(); it != isolates_.End(); ++it) {
      Isolate* isolate = *it;
      isolate_array.AddValue(isolate, /*ref=*/true);
    }
  }
}

◆ program_lock()

SafepointRwLock * dart::IsolateGroup::program_lock ( )

inline

Definition at line 532 of file isolate.h.

532{ return program_lock_.get(); }

◆ program_reload_context()

ProgramReloadContext * dart::IsolateGroup::program_reload_context ( )

inline

Definition at line 652 of file isolate.h.

                                                 {
    return program_reload_context_;
  }

◆ random()

Random * dart::IsolateGroup::random ( )

inline

Definition at line 410 of file isolate.h.

410{ return &random_; }

◆ RegisterClass()

void dart::IsolateGroup::RegisterClass ( const Class & cls )

Definition at line 763 of file isolate.cc.

                                                 {
#if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
  if (IsReloading()) {
    program_reload_context()->RegisterClass(cls);
    return;
  }
#endif  // !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
  if (cls.IsTopLevel()) {
    class_table()->RegisterTopLevel(cls);
  } else {
    class_table()->Register(cls);
  }
}

◆ RegisterIsolate()

void dart::IsolateGroup::RegisterIsolate ( Isolate * isolate )

Definition at line 445 of file isolate.cc.

                                                   {
  SafepointWriteRwLocker ml(Thread::Current(), isolates_lock_.get());
  ASSERT(isolates_lock_->IsCurrentThreadWriter());
  isolates_.Append(isolate);
  isolate_count_++;
}

◆ RegisterIsolateGroup()

void dart::IsolateGroup::RegisterIsolateGroup ( IsolateGroup * isolate_group )

static

Definition at line 698 of file isolate.cc.

                                                                   {
  WriteRwLocker wl(ThreadState::Current(), isolate_groups_rwlock_);
  isolate_groups_->Append(isolate_group);
}

◆ RegisterStaticField()

void dart::IsolateGroup::RegisterStaticField	(	const Field &	field,
		const Object &	initial_value
	)

Definition at line 783 of file isolate.cc.

                                                                    {
  ASSERT(program_lock()->IsCurrentThreadWriter());
 
  ASSERT(field.is_static());
  const bool need_to_grow_backing_store =
      initial_field_table()->Register(field);
  const intptr_t field_id = field.field_id();
  initial_field_table()->SetAt(field_id, initial_value.ptr());
 
  SafepointReadRwLocker ml(Thread::Current(), isolates_lock_.get());
  if (need_to_grow_backing_store) {
    // We have to stop other isolates from accessing their field state, since
    // we'll have to grow the backing store.
    GcSafepointOperationScope scope(Thread::Current());
    for (auto isolate : isolates_) {
      auto field_table = isolate->field_table();
      if (field_table->IsReadyToUse()) {
        field_table->Register(field, field_id);
        field_table->SetAt(field_id, initial_value.ptr());
      }
    }
  } else {
    for (auto isolate : isolates_) {
      auto field_table = isolate->field_table();
      if (field_table->IsReadyToUse()) {
        field_table->Register(field, field_id);
        field_table->SetAt(field_id, initial_value.ptr());
      }
    }
  }
}

◆ RehashConstants()

void dart::IsolateGroup::RehashConstants ( Become * become )

Definition at line 851 of file isolate.cc.

                                                 {
  // Even though no individual constant contains a cycle, there can be "cycles"
  // between the canonical tables if some const instances of A have fields that
  // are const instance of B and vice versa. So set all the old tables to the
  // side and clear all the tables attached to the classes before rehashing
  // instead of resetting and rehash one class at a time.
 
  Thread* thread = Thread::Current();
  StackZone stack_zone(thread);
  Zone* zone = stack_zone.GetZone();
 
  intptr_t num_cids = class_table()->NumCids();
  Array** old_constant_tables = zone->Alloc<Array*>(num_cids);
  for (intptr_t i = 0; i < num_cids; i++) {
    old_constant_tables[i] = nullptr;
  }
 
  Class& cls = Class::Handle(zone);
  for (intptr_t cid = kInstanceCid; cid < num_cids; cid++) {
    if (!class_table()->IsValidIndex(cid) ||
        !class_table()->HasValidClassAt(cid)) {
      continue;
    }
    if ((cid == kTypeArgumentsCid) || IsStringClassId(cid)) {
      // TypeArguments and Symbols have special tables for canonical objects
      // that aren't based on address.
      continue;
    }
    if ((cid == kMintCid) || (cid == kDoubleCid)) {
      // Constants stored as a plain list or in a hashset with a stable
      // hashcode, which only depends on the actual value of the constant.
      continue;
    }
 
    cls = class_table()->At(cid);
    if (cls.constants() == Array::null()) continue;
    old_constant_tables[cid] = &Array::Handle(zone, cls.constants());
    cls.set_constants(Object::null_array());
  }
 
  // Clear invalid hashes.
  heap()->ResetCanonicalHashTable();
 
  Instance& constant = Instance::Handle(zone);
  Field& field = Field::Handle(zone);
  String& name = String::Handle(zone);
  Array& new_values = Array::Handle(zone);
  Instance& old_value = Instance::Handle(zone);
  Instance& new_value = Instance::Handle(zone);
  Instance& deleted = Instance::Handle(zone);
 
  if (become != nullptr) {
    for (intptr_t cid = kInstanceCid; cid < num_cids; cid++) {
      Array* old_constants = old_constant_tables[cid];
      if (old_constants == nullptr) continue;
 
      cls = class_table()->At(cid);
      CanonicalInstancesSet set(zone, old_constants->ptr());
      CanonicalInstancesSet::Iterator it(&set);
      while (it.MoveNext()) {
        constant ^= set.GetKey(it.Current());
        ASSERT(!constant.IsNull());
        ASSERT(!constant.InVMIsolateHeap());
        constant.ClearCanonical();
      }
      set.Release();
    }
  }
 
  for (intptr_t cid = kInstanceCid; cid < num_cids; cid++) {
    Array* old_constants = old_constant_tables[cid];
    if (old_constants == nullptr) continue;
 
    cls = class_table()->At(cid);
    CanonicalInstancesSet set(zone, old_constants->ptr());
    CanonicalInstancesSet::Iterator it(&set);
 
    if (cls.is_enum_class() && (become != nullptr)) {
      field = cls.LookupStaticField(Symbols::_DeletedEnumSentinel());
      deleted ^= field.StaticConstFieldValue();
      if (deleted.IsNull()) {
        deleted = Instance::New(cls, Heap::kOld);
        field = object_store()->enum_name_field();
        name = cls.ScrubbedName();
        name = Symbols::FromConcat(thread, Symbols::_DeletedEnumPrefix(), name);
        deleted.SetField(field, name);
        field = object_store()->enum_index_field();
        new_value = Smi::New(-1);
        deleted.SetField(field, new_value);
        field = cls.LookupStaticField(Symbols::_DeletedEnumSentinel());
        // The static const field contains `Object::null()` instead of
        // `Object::sentinel()` - so it's not considered an initializing store.
        field.SetStaticConstFieldValue(deleted,
                                       /*assert_initializing_store*/ false);
      }
 
      field = cls.LookupField(Symbols::Values());
      new_values ^= field.StaticConstFieldValue();
 
      field = object_store()->enum_name_field();
      while (it.MoveNext()) {
        old_value ^= set.GetKey(it.Current());
        ASSERT(old_value.GetClassId() == cid);
        bool found = false;
        for (intptr_t j = 0; j < new_values.Length(); j++) {
          new_value ^= new_values.At(j);
          ASSERT(new_value.GetClassId() == cid);
          if (old_value.GetField(field) == new_value.GetField(field)) {
            found = true;
            break;
          }
        }
        if (!found) {
          new_value = deleted.ptr();
        }
 
        if (old_value.ptr() != new_value.ptr()) {
          become->Add(old_value, new_value);
        }
        if (new_value.IsCanonical()) {
          cls.InsertCanonicalConstant(zone, new_value);
        }
      }
    } else {
      while (it.MoveNext()) {
        old_value ^= set.GetKey(it.Current());
        ASSERT(!old_value.IsNull());
 
        if (become == nullptr) {
          ASSERT(old_value.IsCanonical());
          cls.InsertCanonicalConstant(zone, old_value);
        } else {
          new_value = old_value.Canonicalize(thread);
          if (old_value.ptr() != new_value.ptr()) {
            become->Add(old_value, new_value);
          }
        }
      }
    }
    set.Release();
  }
 
  // Save memory.
  heap()->ResetCanonicalHashTable();
}

◆ ReleaseStoreBuffers()

void dart::IsolateGroup::ReleaseStoreBuffers ( )

Definition at line 2740 of file isolate.cc.

                                       {
  thread_registry()->ReleaseStoreBuffers();
}

◆ reload_context()

IsolateGroupReloadContext * dart::IsolateGroup::reload_context ( )

inline

Definition at line 649 of file isolate.h.

                                              {
    return group_reload_context_.get();
  }

◆ reload_every_n_stack_overflow_checks()

intptr_t dart::IsolateGroup::reload_every_n_stack_overflow_checks ( ) const

inline

Definition at line 472 of file isolate.h.

                                                        {
    return reload_every_n_stack_overflow_checks_;
  }

◆ ReloadKernel()

bool dart::IsolateGroup::ReloadKernel	(	JSONStream *	js,
		bool	force_reload,
		const uint8_t *	kernel_buffer = `nullptr`,
		intptr_t	kernel_buffer_size = `0`,
		bool	dont_delete_reload_context = `false`
	)

Definition at line 2066 of file isolate.cc.

                                                                 {
  ASSERT(!IsReloading());
 
  // Ensure all isolates inside the isolate group are paused at a place where we
  // can safely do a reload.
  RELOAD_OPERATION_SCOPE(Thread::Current());
 
  auto class_table = IsolateGroup::Current()->class_table();
  std::shared_ptr<IsolateGroupReloadContext> group_reload_context(
      new IsolateGroupReloadContext(this, class_table, js));
  group_reload_context_ = group_reload_context;
 
  SetHasAttemptedReload(true);
  program_reload_context_ =
      new ProgramReloadContext(group_reload_context_, this);
  const bool success = group_reload_context_->Reload(
      force_reload,
      /*root_script_url=*/nullptr,
      /*packages_url=*/nullptr, kernel_buffer, kernel_buffer_size);
  if (!dont_delete_reload_context) {
    DeleteReloadContext();
  }
  return success;
}

◆ ReloadSources()

bool dart::IsolateGroup::ReloadSources	(	JSONStream *	js,
		bool	force_reload,
		const char *	root_script_url = `nullptr`,
		const char *	packages_url = `nullptr`,
		bool	dont_delete_reload_context = `false`
	)

Definition at line 2037 of file isolate.cc.

                                                                  {
  ASSERT(!IsReloading());
 
  // Ensure all isolates inside the isolate group are paused at a place where we
  // can safely do a reload.
  RELOAD_OPERATION_SCOPE(Thread::Current());
 
  auto class_table = IsolateGroup::Current()->class_table();
  std::shared_ptr<IsolateGroupReloadContext> group_reload_context(
      new IsolateGroupReloadContext(this, class_table, js));
  group_reload_context_ = group_reload_context;
 
  SetHasAttemptedReload(true);
  program_reload_context_ =
      new ProgramReloadContext(group_reload_context_, this);
  const bool success =
      group_reload_context_->Reload(force_reload, root_script_url, packages_url,
                                    /*kernel_buffer=*/nullptr,
                                    /*kernel_buffer_size=*/0);
  if (!dont_delete_reload_context) {
    DeleteReloadContext();
  }
  return success;
}

◆ remapping_cids()

bool dart::IsolateGroup::remapping_cids ( ) const

inline

Definition at line 714 of file isolate.h.

                              {
    return RemappingCidsBit::decode(isolate_group_flags_);
  }

◆ RememberLiveTemporaries()

void dart::IsolateGroup::RememberLiveTemporaries ( )

Definition at line 2962 of file isolate.cc.

                                           {
  ForEachIsolate([&](Isolate* isolate) { isolate->RememberLiveTemporaries(); },
                 /*at_safepoint=*/true);
}

◆ RestoreOriginalClassTable()

void dart::IsolateGroup::RestoreOriginalClassTable ( )

Definition at line 3777 of file isolate.cc.

                                             {
  RELEASE_ASSERT(class_table_ != heap_walk_class_table_);
  class_table_allocator_.Free(class_table_);
  class_table_ = heap_walk_class_table_;
  set_cached_class_table_table(class_table_->table());
}

◆ RunWithIsolateGroup()

void dart::IsolateGroup::RunWithIsolateGroup	(	uint64_t	id,
		std::function< void(IsolateGroup *)>	action,
		std::function< void()>	not_found
	)

static

Definition at line 684 of file isolate.cc.

                                   {
  ReadRwLocker wl(Thread::Current(), isolate_groups_rwlock_);
  for (auto isolate_group : *isolate_groups_) {
    if (isolate_group->id() == id) {
      action(isolate_group);
      return;
    }
  }
  not_found();
}

◆ RunWithLockedGroup()

void dart::IsolateGroup::RunWithLockedGroup ( std::function< void()> fun )

Definition at line 460 of file isolate.cc.

                                                             {
  SafepointWriteRwLocker ml(Thread::Current(), isolates_lock_.get());
  fun();
}

◆ RunWithStoppedMutators() [1/2]

template<typename T >

void dart::IsolateGroup::RunWithStoppedMutators	(	T	function,
		bool	use_force_growth = `false`
	)

inline

Definition at line 614 of file isolate.h.

                                                                         {
    LambdaCallable<T> callable(function);
    RunWithStoppedMutatorsCallable(&callable, &callable, use_force_growth);
  }

◆ RunWithStoppedMutators() [2/2]

template<typename T , typename S >

void dart::IsolateGroup::RunWithStoppedMutators	(	T	single_current_mutator,
		S	otherwise,
		bool	use_force_growth_in_otherwise = `false`
	)

inline

Definition at line 604 of file isolate.h.

                                                                          {
    LambdaCallable<T> single_callable(single_current_mutator);
    LambdaCallable<S> otherwise_callable(otherwise);
    RunWithStoppedMutatorsCallable(&single_callable, &otherwise_callable,
                                   use_force_growth_in_otherwise);
  }

◆ RunWithStoppedMutatorsCallable()

void dart::IsolateGroup::RunWithStoppedMutatorsCallable	(	Callable *	single_current_mutator,
		Callable *	otherwise,
		bool	use_force_growth_in_otherwise = `false`
	)

Definition at line 2834 of file isolate.cc.

                                        {
  auto thread = Thread::Current();
  StoppedMutatorsScope stopped_mutators_scope(thread);
 
  if (thread->OwnsSafepoint()) {
    RELEASE_ASSERT(thread->OwnsSafepoint());
    single_current_mutator->Call();
    return;
  }
 
  {
    SafepointReadRwLocker ml(thread, isolates_lock_.get());
    if (thread->IsDartMutatorThread() && ContainsOnlyOneIsolate()) {
      single_current_mutator->Call();
      return;
    }
  }
 
  // We use the more strict safepoint operation scope here (which ensures that
  // all other threads, including auxiliary threads are at a safepoint), even
  // though we only need to ensure that the mutator threads are stopped.
  if (use_force_growth_in_otherwise) {
    ForceGrowthSafepointOperationScope safepoint_scope(
        thread, SafepointLevel::kGCAndDeopt);
    otherwise->Call();
  } else {
    DeoptSafepointOperationScope safepoint_scope(thread);
    otherwise->Call();
  }
}

◆ safepoint_handler()

SafepointHandler * dart::IsolateGroup::safepoint_handler ( )

inline

Definition at line 333 of file isolate.h.

333{ return safepoint_handler_.get(); }

◆ saved_unlinked_calls()

ArrayPtr dart::IsolateGroup::saved_unlinked_calls ( ) const

inline

Definition at line 725 of file isolate.h.

725{ return saved_unlinked_calls_; }

◆ ScheduleInterrupts()

void dart::IsolateGroup::ScheduleInterrupts ( uword interrupt_bits )

Definition at line 1924 of file isolate.cc.

                                                          {
  SafepointReadRwLocker ml(Thread::Current(), isolates_lock_.get());
  for (Isolate* isolate : isolates_) {
    isolate->ScheduleInterrupts(interrupt_bits);
  }
}

◆ set_all_classes_finalized()

void dart::IsolateGroup::set_all_classes_finalized ( bool value )

inline

Definition at line 709 of file isolate.h.

                                             {
    isolate_group_flags_ =
        AllClassesFinalizedBit::update(value, isolate_group_flags_);
  }

◆ set_asserts()

void dart::IsolateGroup::set_asserts ( bool value )

inline

Definition at line 452 of file isolate.h.

                               {
    isolate_group_flags_ =
        EnableAssertsBit::update(value, isolate_group_flags_);
  }

◆ set_become()

void dart::IsolateGroup::set_become ( Become * become )

inline

Definition at line 671 of file isolate.h.

671{ become_ = become; }

◆ set_branch_coverage()

void dart::IsolateGroup::set_branch_coverage ( bool value )

inline

Definition at line 457 of file isolate.h.

                                       {
    isolate_group_flags_ =
        BranchCoverageBit::update(value, isolate_group_flags_);
  }

◆ set_cached_class_table_table()

void dart::IsolateGroup::set_cached_class_table_table ( ClassPtr * cached_class_table_table )

inline

Definition at line 392 of file isolate.h.

                                                                        {
    cached_class_table_table_.store(cached_class_table_table);
  }

◆ set_deferred_load_handler()

void dart::IsolateGroup::set_deferred_load_handler ( Dart_DeferredLoadHandler handler )

inline

Definition at line 559 of file isolate.h.

                                                                   {
    deferred_load_handler_ = handler;
  }

◆ set_dispatch_table()

void dart::IsolateGroup::set_dispatch_table ( DispatchTable * table )

inline

Definition at line 364 of file isolate.h.

                                                {
    dispatch_table_.reset(table);
  }

◆ set_dispatch_table_snapshot()

void dart::IsolateGroup::set_dispatch_table_snapshot ( const uint8_t * snapshot )

inline

Definition at line 370 of file isolate.h.

                                                            {
    dispatch_table_snapshot_ = snapshot;
  }

◆ set_dispatch_table_snapshot_size()

void dart::IsolateGroup::set_dispatch_table_snapshot_size ( intptr_t size )

inline

Definition at line 376 of file isolate.h.

                                                       {
    dispatch_table_snapshot_size_ = size;
  }

◆ set_initial_field_table()

void dart::IsolateGroup::set_initial_field_table ( std::shared_ptr< FieldTable > field_table )

inline

Definition at line 732 of file isolate.h.

                                                                      {
    initial_field_table_ = field_table;
  }

◆ set_initial_spawn_successful()

void dart::IsolateGroup::set_initial_spawn_successful ( )

inline

Definition at line 293 of file isolate.h.

293{ initial_spawn_successful_ = true; }

◆ set_last_reload_timestamp()

void dart::IsolateGroup::set_last_reload_timestamp ( int64_t value )

inline

Definition at line 644 of file isolate.h.

                                                {
    last_reload_timestamp_ = value;
  }

◆ set_library_tag_handler()

void dart::IsolateGroup::set_library_tag_handler ( Dart_LibraryTagHandler handler )

inline

Definition at line 553 of file isolate.h.

                                                               {
    library_tag_handler_ = handler;
  }

◆ set_obfuscation_map()

void dart::IsolateGroup::set_obfuscation_map ( const char ** map )

inline

Definition at line 407 of file isolate.h.

407{ obfuscation_map_ = map; }

skvx::map

SI auto map(std::index_sequence< I... >, Fn &&fn, const Args &... args) -> skvx::Vec< sizeof...(I), decltype(fn(args[0]...))>

Definition SkVx.h:680

◆ set_object_store()

void dart::IsolateGroup::set_object_store ( ObjectStore * object_store )

Definition at line 1036 of file isolate.cc.

                                                             {
  object_store_.reset(object_store);
}

◆ set_remapping_cids()

void dart::IsolateGroup::set_remapping_cids ( bool value )

inline

Definition at line 717 of file isolate.h.

                                      {
    isolate_group_flags_ =
        RemappingCidsBit::update(value, isolate_group_flags_);
  }

◆ set_saved_unlinked_calls()

void dart::IsolateGroup::set_saved_unlinked_calls ( const Array & saved_unlinked_calls )

Definition at line 580 of file isolate.cc.

                                                                             {
  saved_unlinked_calls_ = saved_unlinked_calls.ptr();
}

◆ set_should_load_vmservice()

void dart::IsolateGroup::set_should_load_vmservice ( bool value )

inline

Definition at line 447 of file isolate.h.

                                             {
    isolate_group_flags_ =
        ShouldLoadVmServiceBit::update(value, isolate_group_flags_);
  }

◆ set_use_osr()

void dart::IsolateGroup::set_use_osr ( bool use_osr )

inline

Definition at line 483 of file isolate.h.

                                 {
    isolate_group_flags_ = UseOsrBit::update(use_osr, isolate_group_flags_);
  }

◆ SetHasAttemptedReload()

void dart::IsolateGroup::SetHasAttemptedReload ( bool value )

inline

Definition at line 467 of file isolate.h.

                                         {
    isolate_group_flags_ =
        HasAttemptedReloadBit::update(value, isolate_group_flags_);
  }

◆ SetupImagePage()

void dart::IsolateGroup::SetupImagePage	(	const uint8_t *	snapshot_buffer,
		bool	is_executable
	)

Definition at line 1917 of file isolate.cc.

                                                      {
  Image image(image_buffer);
  heap()->SetupImagePage(image.object_start(), image.object_size(),
                         is_executable);
}

◆ shareable_source()

std::shared_ptr< IsolateGroupSource > dart::IsolateGroup::shareable_source ( ) const

inline

Definition at line 286 of file isolate.h.

                                                             {
    return source_;
  }

◆ should_load_vmservice()

bool dart::IsolateGroup::should_load_vmservice ( ) const

inline

Definition at line 444 of file isolate.h.

                                     {
    return ShouldLoadVmServiceBit::decode(isolate_group_flags_);
  }

◆ Shutdown()

void dart::IsolateGroup::Shutdown ( )

Definition at line 492 of file isolate.cc.

                            {
  char* name = nullptr;
  // We retrieve the flag value once to avoid the compiler complaining about the
  // possibly uninitialized value of name, as the compiler is unaware that when
  // the flag variable is non-const, it is set once during VM initialization and
  // never changed after, and that modification never runs concurrently with
  // this method.
  const bool trace_shutdown = FLAG_trace_shutdown;
 
  if (trace_shutdown) {
    name = Utils::StrDup(source()->name);
    OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Shutdown starting for group %s\n",
                 Dart::UptimeMillis(), name);
  }
  // Ensure to join all threads before waiting for pending GC tasks (the thread
  // pool can trigger idle notification, which can start new GC tasks).
  //
  // (The vm-isolate doesn't have a thread pool.)
  if (!is_vm_isolate_) {
    ASSERT(thread_pool_ != nullptr);
    thread_pool_->Shutdown();
    thread_pool_.reset();
  }
 
  // Needs to happen before starting to destroy the heap so helper tasks like
  // the SampleBlockProcessor don't try to enter the group during this
  // tear-down.
  UnregisterIsolateGroup(this);
 
  // Wait for any pending GC tasks.
  if (heap_ != nullptr) {
    // Wait for any concurrent GC tasks to finish before shutting down.
    // TODO(rmacnak): Interrupt tasks for faster shutdown.
    PageSpace* old_space = heap_->old_space();
    MonitorLocker ml(old_space->tasks_lock());
    while (old_space->tasks() > 0) {
      ml.Wait();
    }
    // Needs to happen before ~PageSpace so TLS and the thread registry are
    // still valid.
    old_space->AbandonMarkingForShutdown();
  }
 
  // If the creation of the isolate group (or the first isolate within the
  // isolate group) failed, we do not invoke the cleanup callback (the
  // embedder is responsible for handling the creation error).
  if (initial_spawn_successful_ && !is_vm_isolate_) {
    auto group_shutdown_callback = Isolate::GroupCleanupCallback();
    if (group_shutdown_callback != nullptr) {
      group_shutdown_callback(embedder_data());
    }
  }
 
  delete this;
 
  // After this isolate group has died we might need to notify a pending
  // `Dart_Cleanup()` call.
  {
    if (trace_shutdown) {
      OS::PrintErr("[+%" Pd64
                   "ms] SHUTDOWN: Notifying "
                   "isolate group shutdown (%s)\n",
                   Dart::UptimeMillis(), name);
    }
    MonitorLocker ml(Isolate::isolate_creation_monitor_);
    if (!Isolate::creation_enabled_ &&
        !IsolateGroup::HasApplicationIsolateGroups()) {
      ml.Notify();
    }
    if (trace_shutdown) {
      OS::PrintErr("[+%" Pd64
                   "ms] SHUTDOWN: Done Notifying "
                   "isolate group shutdown (%s)\n",
                   Dart::UptimeMillis(), name);
    }
  }
  if (trace_shutdown) {
    OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Done shutdown for group %s\n",
                 Dart::UptimeMillis(), name);
    free(name);
  }
}

◆ source()

IsolateGroupSource * dart::IsolateGroup::source ( ) const

inline

Definition at line 285 of file isolate.h.

285{ return source_.get(); }

◆ store_buffer()

StoreBuffer * dart::IsolateGroup::store_buffer ( ) const

inline

Definition at line 504 of file isolate.h.

504{ return store_buffer_.get(); }

◆ subtype_test_cache_mutex()

Mutex * dart::IsolateGroup::subtype_test_cache_mutex ( )

inline

Definition at line 511 of file isolate.h.

511{ return &subtype_test_cache_mutex_; }

◆ symbols_mutex()

Mutex * dart::IsolateGroup::symbols_mutex ( )

inline

Definition at line 506 of file isolate.h.

506{ return &symbols_mutex_; }

◆ thread_pool()

MutatorThreadPool * dart::IsolateGroup::thread_pool ( )

inline

Definition at line 736 of file isolate.h.

736{ return thread_pool_.get(); }

◆ thread_registry()

ThreadRegistry * dart::IsolateGroup::thread_registry ( ) const

inline

Definition at line 332 of file isolate.h.

332{ return thread_registry_.get(); }

◆ type_arguments_canonicalization_mutex()

Mutex * dart::IsolateGroup::type_arguments_canonicalization_mutex ( )

inline

Definition at line 508 of file isolate.h.

                                                 {
    return &type_arguments_canonicalization_mutex_;
  }

◆ type_canonicalization_mutex()

Mutex * dart::IsolateGroup::type_canonicalization_mutex ( )

inline

Definition at line 507 of file isolate.h.

507{ return &type_canonicalization_mutex_; }

◆ type_feedback_mutex()

Mutex * dart::IsolateGroup::type_feedback_mutex ( )

inline

Definition at line 513 of file isolate.h.

513{ return &type_feedback_mutex_; }

◆ UnregisterIsolate()

void dart::IsolateGroup::UnregisterIsolate ( Isolate * isolate )

Definition at line 465 of file isolate.cc.

                                                     {
  SafepointWriteRwLocker ml(Thread::Current(), isolates_lock_.get());
  isolates_.Remove(isolate);
}

◆ UnregisterIsolateDecrementCount()

bool dart::IsolateGroup::UnregisterIsolateDecrementCount ( )

Definition at line 470 of file isolate.cc.

                                                   {
  SafepointWriteRwLocker ml(Thread::Current(), isolates_lock_.get());
  isolate_count_--;
  return isolate_count_ == 0;
}

◆ UnregisterIsolateGroup()

void dart::IsolateGroup::UnregisterIsolateGroup ( IsolateGroup * isolate_group )

static

Definition at line 703 of file isolate.cc.

                                                                     {
  WriteRwLocker wl(ThreadState::Current(), isolate_groups_rwlock_);
  isolate_groups_->Remove(isolate_group);
}

◆ UpdateLastAllocationProfileAccumulatorResetTimestamp()

void dart::IsolateGroup::UpdateLastAllocationProfileAccumulatorResetTimestamp ( )

inline

Definition at line 345 of file isolate.h.

                                                              {
    last_allocationprofile_accumulator_reset_timestamp_ =
        OS::GetCurrentTimeMillis();
  }

◆ UpdateLastAllocationProfileGCTimestamp()

void dart::IsolateGroup::UpdateLastAllocationProfileGCTimestamp ( )

inline

Definition at line 354 of file isolate.h.

                                                {
    last_allocationprofile_gc_timestamp_ = OS::GetCurrentTimeMillis();
  }

◆ UptimeMicros()

int64_t dart::IsolateGroup::UptimeMicros ( ) const

Definition at line 1946 of file isolate.cc.

                                         {
  return OS::GetCurrentMonotonicMicros() - start_time_micros_;
}

◆ VisitObjectIdRingPointers()

void dart::IsolateGroup::VisitObjectIdRingPointers ( ObjectPointerVisitor * visitor )

Definition at line 2941 of file isolate.cc.

                                                                          {
#if !defined(PRODUCT)
  for (Isolate* isolate : isolates_) {
    ObjectIdRing* ring = isolate->object_id_ring();
    if (ring != nullptr) {
      ring->VisitPointers(visitor);
    }
  }
#endif  // !defined(PRODUCT)
}

◆ VisitObjectPointers()

void dart::IsolateGroup::VisitObjectPointers	(	ObjectPointerVisitor *	visitor,
		ValidationPolicy	validate_frames
	)

Definition at line 2868 of file isolate.cc.

                                                                         {
  VisitSharedPointers(visitor);
  for (Isolate* isolate : isolates_) {
    isolate->VisitObjectPointers(visitor, validate_frames);
  }
  VisitStackPointers(visitor, validate_frames);
}

◆ VisitSharedPointers()

void dart::IsolateGroup::VisitSharedPointers ( ObjectPointerVisitor * visitor )

Definition at line 2877 of file isolate.cc.

                                                                    {
  // Visit objects in the class table.
  class_table()->VisitObjectPointers(visitor);
  if (heap_walk_class_table() != class_table()) {
    heap_walk_class_table()->VisitObjectPointers(visitor);
  }
  api_state()->VisitObjectPointersUnlocked(visitor);
  // Visit objects in the object store.
  if (object_store() != nullptr) {
    object_store()->VisitObjectPointers(visitor);
  }
  visitor->VisitPointer(reinterpret_cast<ObjectPtr*>(&saved_unlinked_calls_));
  initial_field_table()->VisitObjectPointers(visitor);
 
  // Visit the boxed_field_list_.
  // 'boxed_field_list_' access via mutator and background compilation threads
  // is guarded with a monitor. This means that we can visit it only
  // when at safepoint or the field_list_mutex_ lock has been taken.
  visitor->VisitPointer(reinterpret_cast<ObjectPtr*>(&boxed_field_list_));
 
  NOT_IN_PRECOMPILED(background_compiler()->VisitPointers(visitor));
 
#if !defined(PRODUCT)
  if (debugger() != nullptr) {
    debugger()->VisitObjectPointers(visitor);
  }
#endif
 
#if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
  // Visit objects that are being used for isolate reload.
  if (program_reload_context() != nullptr) {
    program_reload_context()->VisitObjectPointers(visitor);
    program_reload_context()->group_reload_context()->VisitObjectPointers(
        visitor);
  }
#endif  // !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
 
  if (source()->loaded_blobs_ != nullptr) {
    visitor->VisitPointer(
        reinterpret_cast<ObjectPtr*>(&(source()->loaded_blobs_)));
  }
 
  if (become() != nullptr) {
    become()->VisitObjectPointers(visitor);
  }
}

◆ VisitStackPointers()

void dart::IsolateGroup::VisitStackPointers	(	ObjectPointerVisitor *	visitor,
		ValidationPolicy	validate_frames
	)

Definition at line 2924 of file isolate.cc.

                                                                        {
  visitor->set_gc_root_type("stack");
 
  // Visit objects in all threads (e.g. Dart stack, handles in zones), except
  // for the mutator threads themselves.
  thread_registry()->VisitObjectPointers(this, visitor, validate_frames);
 
  for (Isolate* isolate : isolates_) {
    // Visit mutator thread, even if the isolate isn't entered/scheduled
    // (there might be live API handles to visit).
    isolate->VisitStackPointers(visitor, validate_frames);
  }
 
  visitor->clear_gc_root_type();
}

◆ VisitWeakPersistentHandles()

void dart::IsolateGroup::VisitWeakPersistentHandles ( HandleVisitor * visitor )

Definition at line 2952 of file isolate.cc.

                                                                    {
  api_state()->VisitWeakHandlesUnlocked(visitor);
}

Friends And Related Symbol Documentation

◆ Dart

friend class Dart

friend

Definition at line 746 of file isolate.h.

◆ Heap

friend class Heap

friend

Definition at line 747 of file isolate.h.

◆ Isolate

friend class Isolate

friend

Definition at line 750 of file isolate.h.

◆ StackFrame

friend class StackFrame

friend

Definition at line 748 of file isolate.h.

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

third_party/dart-lang/sdk/runtime/vm/isolate.h
third_party/dart-lang/sdk/runtime/vm/isolate.cc

Public Member Functions

Static Public Member Functions

Friends

Detailed Description

Constructor & Destructor Documentation

◆ IsolateGroup() [1/2]

◆ IsolateGroup() [2/2]

◆ ~IsolateGroup()

Member Function Documentation

◆ all_classes_finalized()

◆ api_state()

◆ background_compiler()

◆ become()

◆ cached_class_table_table()

◆ cached_class_table_table_offset()

◆ CallTagHandler()

◆ CanReload()

◆ class_table()

◆ class_table_allocator()

◆ class_table_offset()

◆ Cleanup()

◆ CloneClassTableForReload()

◆ constant_canonicalization_mutex()

◆ ContainsOnlyOneIsolate()

◆ CreateHeap()

◆ Current()

◆ debugger()

◆ DecreaseMutatorCount()

◆ deferred_load_handler()

◆ deferred_marking_stack()

◆ DeferredMarkLiveTemporaries()

◆ DeleteReloadContext()

◆ DisableIncrementalBarrier()

◆ dispatch_table()

◆ dispatch_table_snapshot()

◆ dispatch_table_snapshot_size()

◆ DropOriginalClassTable()

◆ embedder_data()

◆ EnableIncrementalBarrier()

◆ EnterTemporaryIsolate()

◆ ExitTemporaryIsolate()

◆ FirstIsolate()

◆ FirstIsolateLocked()

◆ FlagsCopyFrom()

◆ FlagsCopyTo()

◆ FlagsInitialize()

◆ FlushMarkingStacks()

◆ ForEach()

◆ ForEachIsolate()

◆ FreeStaticField()

◆ HasApplicationIsolateGroups()

◆ HasAttemptedReload()

◆ HasOnlyVMIsolateGroup()

◆ HasTagHandler()

◆ heap()

◆ heap_walk_class_table()

◆ id()

◆ idle_time_handler()

◆ IncreaseMutatorCount()

◆ Init()

◆ initial_field_table()

◆ initial_field_table_shareable()

◆ initial_spawn_successful()

◆ initializer_functions_mutex()

◆ is_system_isolate_group()

◆ is_vm_isolate()

◆ ISOLATE_GROUP_METRIC_LIST()

◆ IsReloading()

◆ IsSystemIsolateGroup()

◆ kernel_constants_mutex()

◆ kernel_data_class_cache_mutex()

◆ kernel_data_lib_cache_mutex()

◆ last_allocationprofile_accumulator_reset_timestamp()

◆ last_allocationprofile_gc_timestamp()

◆ last_reload_timestamp()

◆ library_tag_handler()

◆ marking_stack()

◆ MaybeIncreaseReloadEveryNStackOverflowChecks()

◆ megamorphic_table_mutex()

◆ MutatorCount()