#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)

void	set_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 old_marking_stack, MarkingStack new_marking_stack, MarkingStack *deferred_marking_stack)

void	DisableIncrementalBarrier ()

MarkingStack *	old_marking_stack () const

MarkingStack *	new_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	has_dynamically_extendable_classes () const

void	set_has_dynamically_extendable_classes (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)

FieldTable *	shared_initial_field_table () const

std::shared_ptr< FieldTable >	shared_initial_field_table_shareable ()

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

FieldTable *	shared_field_table () const

std::shared_ptr< FieldTable >	shared_field_table_shareable ()

void	set_shared_field_table (Thread T, FieldTable shared_field_table)

MutatorThreadPool *	thread_pool ()

void	RegisterClass (const Class &cls)

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

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

void	FreeStaticField (const Field &field)

Isolate *	EnterTemporaryIsolate ()

void	SetNativeAssetsCallbacks (NativeAssetsApi *native_assets_api)

NativeAssetsApi *	native_assets_api ()

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 268 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)),
      shared_initial_field_table_(new FieldTable(/*isolate=*/nullptr,
                                                 /*isolate_group=*/nullptr)),
      shared_field_table_(new FieldTable(/*isolate=*/nullptr, this)),
#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());
  memset(&native_assets_api_, 0, sizeof(NativeAssetsApi));
}

◆ 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 412 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 426 of file isolate.cc.

                            {
  // Ensure we destroy the heap before the other members.
  heap_ = nullptr;
  ASSERT(old_marking_stack_ == nullptr);
  ASSERT(new_marking_stack_ == nullptr);
  ASSERT(deferred_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 713 of file isolate.h.

                                     {
    return AllClassesFinalizedBit::decode(isolate_group_flags_);
  }

◆ api_state()

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

inline

Definition at line 700 of file isolate.h.

700{ return api_state_.get(); }

◆ background_compiler()

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

inline

Definition at line 298 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 677 of file isolate.h.

677{ return become_; }

◆ cached_class_table_table()

ClassPtr * dart::IsolateGroup::cached_class_table_table ( )

inline

Definition at line 390 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 396 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 1925 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 2042 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 496 of file isolate.h.

496{ return class_table_; }

◆ class_table_allocator()

ClassTableAllocator * dart::IsolateGroup::class_table_allocator ( )

inline

Definition at line 381 of file isolate.h.

                                               {
    return &class_table_allocator_;
  }

◆ class_table_offset()

static intptr_t dart::IsolateGroup::class_table_offset ( )

inlinestatic

Definition at line 385 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 742 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 3817 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 520 of file isolate.h.

                                           {
    return &constant_canonicalization_mutex_;
  }

◆ ContainsOnlyOneIsolate()

bool dart::IsolateGroup::ContainsOnlyOneIsolate ( )

Definition at line 458 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 482 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 539 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 315 of file isolate.h.

315{ return debugger_; }

◆ DecreaseMutatorCount()

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

Definition at line 618 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 561 of file isolate.h.

                                                         {
    return deferred_load_handler_;
  }

◆ deferred_marking_stack()

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

inline

Definition at line 578 of file isolate.h.

                                               {
    return deferred_marking_stack_;
  }

◆ DeferredMarkLiveTemporaries()

void dart::IsolateGroup::DeferredMarkLiveTemporaries ( )

Definition at line 3002 of file isolate.cc.

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

◆ DeleteReloadContext()

void dart::IsolateGroup::DeleteReloadContext ( )

Definition at line 2131 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 2831 of file isolate.cc.

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

◆ dispatch_table()

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

inline

Definition at line 364 of file isolate.h.

364{ return dispatch_table_.get(); }

◆ dispatch_table_snapshot()

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

inline

Definition at line 368 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 374 of file isolate.h.

                                                {
    return dispatch_table_snapshot_size_;
  }

◆ DropOriginalClassTable()

void dart::IsolateGroup::DropOriginalClassTable ( )

Definition at line 3830 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 291 of file isolate.h.

291{ return embedder_data_; }

◆ EnableIncrementalBarrier()

void dart::IsolateGroup::EnableIncrementalBarrier	(	MarkingStack *	old_marking_stack,
		MarkingStack *	new_marking_stack,
		MarkingStack *	deferred_marking_stack
	)

Definition at line 2817 of file isolate.cc.

                                          {
  ASSERT(old_marking_stack_ == nullptr);
  old_marking_stack_ = old_marking_stack;
  ASSERT(new_marking_stack_ == nullptr);
  new_marking_stack_ = new_marking_stack;
  ASSERT(deferred_marking_stack_ == nullptr);
  deferred_marking_stack_ = deferred_marking_stack;
  thread_registry()->AcquireMarkingStacks();
  ASSERT(Thread::Current()->is_marking());
}

◆ EnterTemporaryIsolate()

Isolate * dart::IsolateGroup::EnterTemporaryIsolate ( )

Definition at line 871 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 880 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 2869 of file isolate.cc.

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

◆ FirstIsolateLocked()

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

Definition at line 2874 of file isolate.cc.

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

◆ FlagsCopyFrom()

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

Definition at line 1622 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 1611 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 1600 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 2780 of file isolate.cc.

                                      {
  thread_registry()->FlushMarkingStacks();
}

◆ ForEach()

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

static

Definition at line 683 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 2841 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) ||
           (thread->task_kind() == Thread::kIncrementalCompactorTask));
    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 848 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();
  if (field.is_shared()) {
    shared_field_table()->Free(field_id);
  } else {
    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);
      }
    });
  }
}

◆ has_dynamically_extendable_classes()

bool dart::IsolateGroup::has_dynamically_extendable_classes ( ) const

inline

Definition at line 720 of file isolate.h.

                                                  {
    return HasDynamicallyExtendableClassesBit::decode(isolate_group_flags_);
  }

◆ HasApplicationIsolateGroups()

bool dart::IsolateGroup::HasApplicationIsolateGroups ( )

static

Definition at line 714 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 469 of file isolate.h.

                                  {
    return HasAttemptedReloadBit::decode(isolate_group_flags_);
  }

◆ HasOnlyVMIsolateGroup()

bool dart::IsolateGroup::HasOnlyVMIsolateGroup ( )

static

Definition at line 724 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 551 of file isolate.h.

551{ return library_tag_handler() != nullptr; }

◆ heap()

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

inline

Definition at line 296 of file isolate.h.

296{ return heap_.get(); }

◆ heap_walk_class_table()

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

inline

Definition at line 503 of file isolate.h.

503{ return heap_walk_class_table_; }

◆ id()

uint64_t dart::IsolateGroup::id ( ) const

inline

Definition at line 680 of file isolate.h.

680{ return id_; }

◆ idle_time_handler()

IdleTimeHandler * dart::IsolateGroup::idle_time_handler ( )

inline

Definition at line 318 of file isolate.h.

318{ return &idle_time_handler_; }

◆ IncreaseMutatorCount()

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

Definition at line 590 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 734 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 742 of file isolate.h.

742{ return initial_field_table_.get(); }

◆ initial_field_table_shareable()

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

inline

Definition at line 743 of file isolate.h.

                                                            {
    return initial_field_table_;
  }

◆ initial_spawn_successful()

bool dart::IsolateGroup::initial_spawn_successful ( )

inline

Definition at line 293 of file isolate.h.

293{ return initial_spawn_successful_; }

◆ initializer_functions_mutex()

Mutex * dart::IsolateGroup::initializer_functions_mutex ( )

inline

Definition at line 534 of file isolate.h.

534{ return &initializer_functions_mutex_; }

◆ is_system_isolate_group()

bool dart::IsolateGroup::is_system_isolate_group ( ) const

inline

Definition at line 413 of file isolate.h.

413{ return is_system_isolate_group_; }

◆ is_vm_isolate()

bool dart::IsolateGroup::is_vm_isolate ( ) const

inline

Definition at line 290 of file isolate.h.

290{ 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 669 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 3605 of file isolate.cc.

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

◆ kernel_constants_mutex()

Mutex * dart::IsolateGroup::kernel_constants_mutex ( )

inline

Definition at line 527 of file isolate.h.

527{ return &kernel_constants_mutex_; }

◆ kernel_data_class_cache_mutex()

Mutex * dart::IsolateGroup::kernel_data_class_cache_mutex ( )

inline

Definition at line 524 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 523 of file isolate.h.

523{ 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 351 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 359 of file isolate.h.

                                                      {
    return last_allocationprofile_gc_timestamp_;
  }

◆ last_reload_timestamp()

int64_t dart::IsolateGroup::last_reload_timestamp ( ) const

inline

Definition at line 654 of file isolate.h.

654{ return last_reload_timestamp_; }

◆ library_tag_handler()

Dart_LibraryTagHandler dart::IsolateGroup::library_tag_handler ( ) const

inline

Definition at line 555 of file isolate.h.

                                                     {
    return library_tag_handler_;
  }

◆ MaybeIncreaseReloadEveryNStackOverflowChecks()

void dart::IsolateGroup::MaybeIncreaseReloadEveryNStackOverflowChecks ( )

Definition at line 2532 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 517 of file isolate.h.

517{ return &megamorphic_table_mutex_; }

◆ MutatorCount()

intptr_t dart::IsolateGroup::MutatorCount ( ) const

inline

Definition at line 546 of file isolate.h.

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

◆ native_assets_api()

NativeAssetsApi * dart::IsolateGroup::native_assets_api ( )

inline

Definition at line 783 of file isolate.h.

783{ return &native_assets_api_; }

◆ new_marking_stack()

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

inline

Definition at line 577 of file isolate.h.

577{ return new_marking_stack_; }

◆ obfuscation_map()

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

inline

Definition at line 409 of file isolate.h.

409{ return obfuscation_map_; }

◆ object_store()

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

inline

Definition at line 510 of file isolate.h.

510{ return object_store_.get(); }

◆ object_store_offset()

static intptr_t dart::IsolateGroup::object_store_offset ( )

inlinestatic

Definition at line 403 of file isolate.h.

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

◆ old_marking_stack()

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

inline

Definition at line 576 of file isolate.h.

576{ return old_marking_stack_; }

◆ optimization_counter_threshold()

intptr_t dart::IsolateGroup::optimization_counter_threshold ( ) const

inline

Definition at line 306 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 519 of file isolate.h.

519{ return &patchable_call_mutex_; }

◆ PrintJSON()

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

Definition at line 643 of file isolate.cc.

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

◆ PrintMemoryUsageJSON()

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

Definition at line 668 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 648 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 537 of file isolate.h.

537{ return program_lock_.get(); }

◆ program_reload_context()

ProgramReloadContext * dart::IsolateGroup::program_reload_context ( )

inline

Definition at line 659 of file isolate.h.

                                                 {
    return program_reload_context_;
  }

◆ random()

Random * dart::IsolateGroup::random ( )

inline

Definition at line 411 of file isolate.h.

411{ return &random_; }

◆ RegisterClass()

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

Definition at line 769 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 451 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 704 of file isolate.cc.

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

◆ RegisterSharedStaticField()

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

Definition at line 789 of file isolate.cc.

                                                                          {
  const bool need_to_grow_backing_store =
      shared_initial_field_table()->Register(field);
  const intptr_t field_id = field.field_id();
  shared_initial_field_table()->SetAt(field_id, initial_value.ptr());
 
  if (need_to_grow_backing_store) {
    // We have to stop other isolates from accessing shared isolate group
    // field state, since we'll have to grow the backing store.
    GcSafepointOperationScope scope(Thread::Current());
    const bool need_to_grow_other_backing_store =
        shared_field_table()->Register(field, field_id);
    ASSERT(need_to_grow_other_backing_store);
  } else {
    const bool need_to_grow_other_backing_store =
        shared_field_table()->Register(field, field_id);
    ASSERT(!need_to_grow_other_backing_store);
  }
  shared_field_table()->SetAt(field_id, initial_value.ptr());
}

◆ RegisterStaticField()

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

Definition at line 811 of file isolate.cc.

                                                                    {
  ASSERT(program_lock()->IsCurrentThreadWriter());
 
  ASSERT(field.is_static());
  if (field.is_shared()) {
    RegisterSharedStaticField(field, initial_value);
    return;
  }
  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 887 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 2776 of file isolate.cc.

                                       {
  thread_registry()->ReleaseStoreBuffers();
}

◆ reload_context()

IsolateGroupReloadContext * dart::IsolateGroup::reload_context ( )

inline

Definition at line 656 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 477 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 2102 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 2073 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 728 of file isolate.h.

                              {
    return RemappingCidsBit::decode(isolate_group_flags_);
  }

◆ RememberLiveTemporaries()

void dart::IsolateGroup::RememberLiveTemporaries ( )

Definition at line 3008 of file isolate.cc.

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

◆ RestoreOriginalClassTable()

void dart::IsolateGroup::RestoreOriginalClassTable ( )

Definition at line 3823 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 690 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 466 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 621 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 611 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 2878 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 334 of file isolate.h.

334{ return safepoint_handler_.get(); }

◆ saved_unlinked_calls()

ArrayPtr dart::IsolateGroup::saved_unlinked_calls ( ) const

inline

Definition at line 739 of file isolate.h.

739{ return saved_unlinked_calls_; }

◆ ScheduleInterrupts()

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

Definition at line 1960 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 716 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 453 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 678 of file isolate.h.

678{ become_ = become; }

◆ set_branch_coverage()

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

inline

Definition at line 458 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 393 of file isolate.h.

                                                                        {
    cached_class_table_table_.store(cached_class_table_table);
  }

◆ set_coverage()

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

inline

Definition at line 463 of file isolate.h.

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

◆ set_deferred_load_handler()

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

inline

Definition at line 564 of file isolate.h.

                                                                   {
    deferred_load_handler_ = handler;
  }

◆ set_dispatch_table()

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

inline

Definition at line 365 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 371 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 377 of file isolate.h.

                                                       {
    dispatch_table_snapshot_size_ = size;
  }

◆ set_has_dynamically_extendable_classes()

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

inline

Definition at line 723 of file isolate.h.

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

◆ set_initial_field_table()

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

inline

Definition at line 746 of file isolate.h.

                                                                      {
    initial_field_table_ = field_table;
  }

◆ set_initial_spawn_successful()

void dart::IsolateGroup::set_initial_spawn_successful ( )

inline

Definition at line 294 of file isolate.h.

294{ initial_spawn_successful_ = true; }

◆ set_last_reload_timestamp()

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

inline

Definition at line 651 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 558 of file isolate.h.

                                                               {
    library_tag_handler_ = handler;
  }

◆ set_obfuscation_map()

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

inline

Definition at line 408 of file isolate.h.

408{ 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 1072 of file isolate.cc.

                                                             {
  object_store_.reset(object_store);
}

◆ set_remapping_cids()

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

inline

Definition at line 731 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 586 of file isolate.cc.

                                                                             {
  saved_unlinked_calls_ = saved_unlinked_calls.ptr();
}

◆ set_shared_field_table()

void dart::IsolateGroup::set_shared_field_table	(	Thread *	T,
		FieldTable *	shared_field_table
	)

inline

Definition at line 764 of file isolate.h.

                                                                         {
    shared_field_table_.reset(shared_field_table);
    T->shared_field_table_values_ = shared_field_table->table();
  }

◆ set_shared_initial_field_table()

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

inline

Definition at line 756 of file isolate.h.

                                                                             {
    shared_initial_field_table_ = field_table;
  }

◆ set_should_load_vmservice()

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

inline

Definition at line 448 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 488 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 472 of file isolate.h.

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

◆ SetNativeAssetsCallbacks()

void dart::IsolateGroup::SetNativeAssetsCallbacks ( NativeAssetsApi * native_assets_api )

inline

Definition at line 780 of file isolate.h.

                                                                    {
    native_assets_api_ = *native_assets_api;
  }

◆ SetupImagePage()

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

Definition at line 1953 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 287 of file isolate.h.

                                                             {
    return source_;
  }

◆ shared_field_table()

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

inline

Definition at line 760 of file isolate.h.

760{ return shared_field_table_.get(); }

◆ shared_field_table_shareable()

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

inline

Definition at line 761 of file isolate.h.

                                                           {
    return shared_field_table_;
  }

◆ shared_initial_field_table()

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

inline

Definition at line 750 of file isolate.h.

                                                 {
    return shared_initial_field_table_.get();
  }

◆ shared_initial_field_table_shareable()

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

inline

Definition at line 753 of file isolate.h.

                                                                   {
    return shared_initial_field_table_;
  }

◆ should_load_vmservice()

bool dart::IsolateGroup::should_load_vmservice ( ) const

inline

Definition at line 445 of file isolate.h.

                                     {
    return ShouldLoadVmServiceBit::decode(isolate_group_flags_);
  }

◆ Shutdown()

void dart::IsolateGroup::Shutdown ( )

Definition at line 498 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 286 of file isolate.h.

286{ return source_.get(); }

◆ store_buffer()

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

inline

Definition at line 509 of file isolate.h.

509{ return store_buffer_.get(); }

◆ subtype_test_cache_mutex()

Mutex * dart::IsolateGroup::subtype_test_cache_mutex ( )

inline

Definition at line 516 of file isolate.h.

516{ return &subtype_test_cache_mutex_; }

◆ symbols_mutex()

Mutex * dart::IsolateGroup::symbols_mutex ( )

inline

Definition at line 511 of file isolate.h.

511{ return &symbols_mutex_; }

◆ thread_pool()

MutatorThreadPool * dart::IsolateGroup::thread_pool ( )

inline

Definition at line 769 of file isolate.h.

769{ return thread_pool_.get(); }

◆ thread_registry()

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

inline

Definition at line 333 of file isolate.h.

333{ return thread_registry_.get(); }

◆ type_arguments_canonicalization_mutex()

Mutex * dart::IsolateGroup::type_arguments_canonicalization_mutex ( )

inline

Definition at line 513 of file isolate.h.

                                                 {
    return &type_arguments_canonicalization_mutex_;
  }

◆ type_canonicalization_mutex()

Mutex * dart::IsolateGroup::type_canonicalization_mutex ( )

inline

Definition at line 512 of file isolate.h.

512{ return &type_canonicalization_mutex_; }

◆ type_feedback_mutex()

Mutex * dart::IsolateGroup::type_feedback_mutex ( )

inline

Definition at line 518 of file isolate.h.

518{ return &type_feedback_mutex_; }

◆ UnregisterIsolate()

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

Definition at line 471 of file isolate.cc.

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

◆ UnregisterIsolateDecrementCount()

bool dart::IsolateGroup::UnregisterIsolateDecrementCount ( )

Definition at line 476 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 709 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 346 of file isolate.h.

                                                              {
    last_allocationprofile_accumulator_reset_timestamp_ =
        OS::GetCurrentTimeMillis();
  }

◆ UpdateLastAllocationProfileGCTimestamp()

void dart::IsolateGroup::UpdateLastAllocationProfileGCTimestamp ( )

inline

Definition at line 355 of file isolate.h.

                                                {
    last_allocationprofile_gc_timestamp_ = OS::GetCurrentTimeMillis();
  }

◆ UptimeMicros()

int64_t dart::IsolateGroup::UptimeMicros ( ) const

Definition at line 1982 of file isolate.cc.

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

◆ VisitObjectIdRingPointers()

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

Definition at line 2987 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 2912 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 2921 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);
  shared_initial_field_table()->VisitObjectPointers(visitor);
  shared_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 2970 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 2998 of file isolate.cc.

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

Friends And Related Function Documentation

◆ Dart

friend class Dart

friend

Definition at line 786 of file isolate.h.

◆ Heap

friend class Heap

friend

Definition at line 787 of file isolate.h.

◆ Isolate

friend class Isolate

friend

Definition at line 790 of file isolate.h.

◆ StackFrame

friend class StackFrame

friend

Definition at line 788 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()

◆ has_dynamically_extendable_classes()

◆ 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()

◆ MaybeIncreaseReloadEveryNStackOverflowChecks()

◆ megamorphic_table_mutex()

◆ MutatorCount()