dart::SpawnIsolateTask Class Reference

Inheritance diagram for dart::SpawnIsolateTask:

Public Member Functions
	SpawnIsolateTask (Isolate *parent_isolate, std::unique_ptr< IsolateSpawnState > state)
	~SpawnIsolateTask () override
void	Run () override
void	RunHeavyweight (const char *name)
void	RunLightweight (const char *name)
Public Member Functions inherited from dart::ThreadPool::Task
virtual	~Task ()
virtual void	Run ()=0
Public Member Functions inherited from dart::IntrusiveDListEntry< Task >
	IntrusiveDListEntry ()
	~IntrusiveDListEntry ()

Additional Inherited Members
Protected Member Functions inherited from dart::ThreadPool::Task
	Task ()

Detailed Description

Definition at line 558 of file isolate.cc.

Constructor & Destructor Documentation

SpawnIsolateTask()

dart::SpawnIsolateTask::SpawnIsolateTask ( Isolate *  parent_isolate, std::unique_ptr< IsolateSpawnState >  state  )

inline

Definition at line 560 of file isolate.cc.

      : parent_isolate_(parent_isolate), state_(std::move(state)) {
    parent_isolate->IncrementSpawnCount();
  }

~SpawnIsolateTask()

dart::SpawnIsolateTask::~SpawnIsolateTask ( )

inlineoverride

Definition at line 566 of file isolate.cc.

                               {
    if (parent_isolate_ != nullptr) {
      parent_isolate_->DecrementSpawnCount();
    }
  }

Member Function Documentation

Run()

void dart::SpawnIsolateTask::Run ( )

inlineoverridevirtual

Implements dart::ThreadPool::Task.

Definition at line 572 of file isolate.cc.

                      {
    const char* name = state_->debug_name();
    ASSERT(name != nullptr);
 
    auto group = state_->isolate_group();
    if (group == nullptr) {
      RunHeavyweight(name);
    } else {
      RunLightweight(name);
    }
  }

RunHeavyweight()

void dart::SpawnIsolateTask::RunHeavyweight ( const char *  name )

inline

Definition at line 584 of file isolate.cc.

                                        {
    // The create isolate group callback is mandatory.  If not provided we
    // cannot spawn isolates.
    auto create_group_callback = Isolate::CreateGroupCallback();
    if (create_group_callback == nullptr) {
      FailedSpawn("Isolate spawn is not supported by this Dart embedder\n");
      return;
    }
 
    char* error = nullptr;
 
    // Make a copy of the state's isolate flags and hand it to the callback.
    Dart_IsolateFlags api_flags = *(state_->isolate_flags());
 
    // Inherit the system isolate property to work around issues with
    // --pause-isolates-on-start and --pause-isolates-on-exit impacting macro
    // generation isolates which are spawned by the kernel-service
    // (see https://github.com/dart-lang/sdk/issues/54729 for details).
    //
    // This flag isn't inherited in the case that the main isolate is marked as
    // a system isolate in the standalone VM using the
    // --mark-main-isolate-as-system-isolate flag as it's currently used to
    // hide test runner implementation details and spawns isolates that should
    // be debuggable as non-system isolates.
    //
    // TODO(bkonyi): revisit this decision, see
    // https://github.com/dart-lang/sdk/issues/54736 for the tracking issue.
    const bool is_parent_main_isolate =
        strcmp(parent_isolate_->name(), "main") == 0;
    api_flags.is_system_isolate =
        api_flags.is_system_isolate && !is_parent_main_isolate;
    Dart_Isolate isolate =
        (create_group_callback)(state_->script_url(), name, nullptr,
                                state_->package_config(), &api_flags,
                                parent_isolate_->init_callback_data(), &error);
    parent_isolate_->DecrementSpawnCount();
    parent_isolate_ = nullptr;
 
    if (isolate == nullptr) {
      FailedSpawn(error, /*has_current_isolate=*/false);
      free(error);
      return;
    }
    Dart_EnterIsolate(isolate);
    Run(reinterpret_cast<Isolate*>(isolate));
  }

RunLightweight()

void dart::SpawnIsolateTask::RunLightweight ( const char *  name )

inline

Definition at line 631 of file isolate.cc.

                                        {
    // The create isolate initialize callback is mandatory.
    auto initialize_callback = Isolate::InitializeCallback();
    if (initialize_callback == nullptr) {
      FailedSpawn(
          "Lightweight isolate spawn is not supported by this Dart embedder\n",
          /*has_current_isolate=*/false);
      return;
    }
 
    char* error = nullptr;
 
    auto group = state_->isolate_group();
    Isolate* isolate = CreateWithinExistingIsolateGroup(group, name, &error);
    parent_isolate_->DecrementSpawnCount();
    parent_isolate_ = nullptr;
 
    if (isolate == nullptr) {
      FailedSpawn(error, /*has_current_isolate=*/false);
      free(error);
      return;
    }
 
    void* child_isolate_data = nullptr;
    const bool success = initialize_callback(&child_isolate_data, &error);
    if (!success) {
      FailedSpawn(error);
      Dart_ShutdownIsolate();
      free(error);
      return;
    }
 
    isolate->set_init_callback_data(child_isolate_data);
    Run(isolate);
  }

---

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

• third_party/dart-lang/sdk/runtime/lib/isolate.cc