Skip to content
This repository was archived by the owner on Feb 25, 2025. It is now read-only.

Commit 816caac

Browse files
gaaclarkegaaclarke
committed
Did the plumbing refactor that allows us to call Dart_CreateIsolateInGroup when applicable.
1 parent ca156c5 commit 816caac

File tree

10 files changed

+350
-53
lines changed

10 files changed

+350
-53
lines changed

‎runtime/dart_isolate.cc‎

Lines changed: 72 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -73,6 +73,29 @@ Dart_IsolateFlags DartIsolate::Flags::Get() const {
7373
return flags_;
7474
}
7575

76+
std::weak_ptr<DartIsolate> DartIsolate::SpawnIsolate(
77+
const Settings& settings,
78+
std::unique_ptr<PlatformConfiguration> platform_configuration,
79+
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
80+
fml::WeakPtr<HintFreedDelegate> hint_freed_delegate,
81+
std::string advisory_script_uri,
82+
std::string advisory_script_entrypoint,
83+
Flags flags,
84+
const fml::closure& isolate_create_callback,
85+
const fml::closure& isolate_shutdown_callback,
86+
std::optional<std::string> dart_entrypoint,
87+
std::optional<std::string> dart_entrypoint_library,
88+
std::unique_ptr<IsolateConfiguration> isolate_configration) const {
89+
return CreateRunningRootIsolate(
90+
settings, GetIsolateGroupData().GetIsolateSnapshot(), GetTaskRunners(),
91+
std::move(platform_configuration), snapshot_delegate, hint_freed_delegate,
92+
GetIOManager(), GetSkiaUnrefQueue(), GetImageDecoder(),
93+
advisory_script_uri, advisory_script_entrypoint, flags,
94+
isolate_create_callback, isolate_shutdown_callback, dart_entrypoint,
95+
dart_entrypoint_library, std::move(isolate_configration),
96+
GetVolatilePathTracker(), this);
97+
}
98+
7699
std::weak_ptr<DartIsolate> DartIsolate::CreateRunningRootIsolate(
77100
const Settings& settings,
78101
fml::RefPtr<const DartSnapshot> isolate_snapshot,
@@ -91,7 +114,8 @@ std::weak_ptr<DartIsolate> DartIsolate::CreateRunningRootIsolate(
91114
std::optional<std::string> dart_entrypoint,
92115
std::optional<std::string> dart_entrypoint_library,
93116
std::unique_ptr<IsolateConfiguration> isolate_configration,
94-
std::shared_ptr<VolatilePathTracker> volatile_path_tracker) {
117+
std::shared_ptr<VolatilePathTracker> volatile_path_tracker,
118+
const DartIsolate* spawning_isolate) {
95119
if (!isolate_snapshot) {
96120
FML_LOG(ERROR) << "Invalid isolate snapshot.";
97121
return {};
@@ -135,7 +159,8 @@ std::weak_ptr<DartIsolate> DartIsolate::CreateRunningRootIsolate(
135159
});
136160

137161
if (isolate->GetPhase() != DartIsolate::Phase::LibrariesSetup) {
138-
FML_LOG(ERROR) << "Root isolate was created in an incorrect phase.";
162+
FML_LOG(ERROR) << "Root isolate was created in an incorrect phase: "
163+
<< static_cast<int>(isolate->GetPhase());
139164
return {};
140165
}
141166

@@ -190,7 +215,8 @@ std::weak_ptr<DartIsolate> DartIsolate::CreateRootIsolate(
190215
Flags flags,
191216
const fml::closure& isolate_create_callback,
192217
const fml::closure& isolate_shutdown_callback,
193-
std::shared_ptr<VolatilePathTracker> volatile_path_tracker) {
218+
std::shared_ptr<VolatilePathTracker> volatile_path_tracker,
219+
const DartIsolate* spawning_isolate) {
194220
TRACE_EVENT0("flutter", "DartIsolate::CreateRootIsolate");
195221

196222
// The child isolate preparer is null but will be set when the isolate is
@@ -223,13 +249,28 @@ std::weak_ptr<DartIsolate> DartIsolate::CreateRootIsolate(
223249
)));
224250

225251
DartErrorString error;
252+
Dart_Isolate vm_isolate = nullptr;
226253
auto isolate_flags = flags.Get();
227-
Dart_Isolate vm_isolate = CreateDartIsolateGroup(
254+
/// TODO(b/72025) This will be where we call Dart_CreateIsolateInGroup if
255+
/// spawning_isolate != nullptr.
256+
vm_isolate = CreateDartIsolateGroup(
228257
std::move(isolate_group_data), std::move(isolate_data), &isolate_flags,
229-
error.error());
258+
error.error(),
259+
[](std::shared_ptr<DartIsolateGroupData>* isolate_group_data,
260+
std::shared_ptr<DartIsolate>* isolate_data, Dart_IsolateFlags* flags,
261+
char** error) {
262+
return Dart_CreateIsolateGroup(
263+
(*isolate_group_data)->GetAdvisoryScriptURI().c_str(),
264+
(*isolate_group_data)->GetAdvisoryScriptEntrypoint().c_str(),
265+
(*isolate_group_data)->GetIsolateSnapshot()->GetDataMapping(),
266+
(*isolate_group_data)
267+
->GetIsolateSnapshot()
268+
->GetInstructionsMapping(),
269+
flags, isolate_group_data, isolate_data, error);
270+
});
230271

231272
if (error) {
232-
FML_LOG(ERROR) << "CreateDartIsolateGroup failed: " << error.str();
273+
FML_LOG(ERROR) << "CreateRootIsolate failed: " << error.str();
233274
}
234275

235276
if (vm_isolate == nullptr) {
@@ -809,6 +850,11 @@ DartIsolateGroupData& DartIsolate::GetIsolateGroupData() {
809850
return **isolate_group_data;
810851
}
811852

853+
const DartIsolateGroupData& DartIsolate::GetIsolateGroupData() const {
854+
DartIsolate* non_const_this = const_cast<DartIsolate*>(this);
855+
return non_const_this->GetIsolateGroupData();
856+
}
857+
812858
// |Dart_IsolateGroupCreateCallback|
813859
Dart_Isolate DartIsolate::DartIsolateGroupCreateCallback(
814860
const char* advisory_script_uri,
@@ -871,7 +917,19 @@ Dart_Isolate DartIsolate::DartIsolateGroupCreateCallback(
871917
nullptr))); // volatile path tracker
872918

873919
Dart_Isolate vm_isolate = CreateDartIsolateGroup(
874-
std::move(isolate_group_data), std::move(isolate_data), flags, error);
920+
std::move(isolate_group_data), std::move(isolate_data), flags, error,
921+
[](std::shared_ptr<DartIsolateGroupData>* isolate_group_data,
922+
std::shared_ptr<DartIsolate>* isolate_data, Dart_IsolateFlags* flags,
923+
char** error) {
924+
return Dart_CreateIsolateGroup(
925+
(*isolate_group_data)->GetAdvisoryScriptURI().c_str(),
926+
(*isolate_group_data)->GetAdvisoryScriptEntrypoint().c_str(),
927+
(*isolate_group_data)->GetIsolateSnapshot()->GetDataMapping(),
928+
(*isolate_group_data)
929+
->GetIsolateSnapshot()
930+
->GetInstructionsMapping(),
931+
flags, isolate_group_data, isolate_data, error);
932+
});
875933

876934
if (*error) {
877935
FML_LOG(ERROR) << "CreateDartIsolateGroup failed: " << error;
@@ -933,16 +991,16 @@ Dart_Isolate DartIsolate::CreateDartIsolateGroup(
933991
std::unique_ptr<std::shared_ptr<DartIsolateGroupData>> isolate_group_data,
934992
std::unique_ptr<std::shared_ptr<DartIsolate>> isolate_data,
935993
Dart_IsolateFlags* flags,
936-
char** error) {
994+
char** error,
995+
std::function<Dart_Isolate(std::shared_ptr<DartIsolateGroupData>*,
996+
std::shared_ptr<DartIsolate>*,
997+
Dart_IsolateFlags*,
998+
char**)> make_isolate) {
937999
TRACE_EVENT0("flutter", "DartIsolate::CreateDartIsolateGroup");
9381000

9391001
// Create the Dart VM isolate and give it the embedder object as the baton.
940-
Dart_Isolate isolate = Dart_CreateIsolateGroup(
941-
(*isolate_group_data)->GetAdvisoryScriptURI().c_str(),
942-
(*isolate_group_data)->GetAdvisoryScriptEntrypoint().c_str(),
943-
(*isolate_group_data)->GetIsolateSnapshot()->GetDataMapping(),
944-
(*isolate_group_data)->GetIsolateSnapshot()->GetInstructionsMapping(),
945-
flags, isolate_group_data.get(), isolate_data.get(), error);
1002+
Dart_Isolate isolate =
1003+
make_isolate(isolate_group_data.get(), isolate_data.get(), flags, error);
9461004

9471005
if (isolate == nullptr) {
9481006
return nullptr;

‎runtime/dart_isolate.h‎

Lines changed: 32 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,6 @@
1919
#include "flutter/lib/ui/io_manager.h"
2020
#include "flutter/lib/ui/snapshot_delegate.h"
2121
#include "flutter/lib/ui/ui_dart_state.h"
22-
#include "flutter/lib/ui/volatile_path_tracker.h"
2322
#include "flutter/lib/ui/window/platform_configuration.h"
2423
#include "flutter/runtime/dart_snapshot.h"
2524
#include "third_party/dart/runtime/include/dart_api.h"
@@ -232,7 +231,29 @@ class DartIsolate : public UIDartState {
232231
std::optional<std::string> dart_entrypoint,
233232
std::optional<std::string> dart_entrypoint_library,
234233
std::unique_ptr<IsolateConfiguration> isolate_configration,
235-
std::shared_ptr<VolatilePathTracker> volatile_path_tracker);
234+
std::shared_ptr<VolatilePathTracker> volatile_path_tracker,
235+
const DartIsolate* spawning_isolate = nullptr);
236+
237+
//----------------------------------------------------------------------------
238+
/// @brief Creates a running DartIsolate who shares as many resources as
239+
/// possible with the caller DartIsolate. This allows them to
240+
/// occupy less memory together.
241+
/// @attention Only certain setups can take advantage of the most savings
242+
/// currently, release builds currently.
243+
/// @return A running DartIsolate.
244+
std::weak_ptr<DartIsolate> SpawnIsolate(
245+
const Settings& settings,
246+
std::unique_ptr<PlatformConfiguration> platform_configuration,
247+
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
248+
fml::WeakPtr<HintFreedDelegate> hint_freed_delegate,
249+
std::string advisory_script_uri,
250+
std::string advisory_script_entrypoint,
251+
Flags flags,
252+
const fml::closure& isolate_create_callback,
253+
const fml::closure& isolate_shutdown_callback,
254+
std::optional<std::string> dart_entrypoint,
255+
std::optional<std::string> dart_entrypoint_library,
256+
std::unique_ptr<IsolateConfiguration> isolate_configration) const;
236257

237258
// |UIDartState|
238259
~DartIsolate() override;
@@ -433,7 +454,8 @@ class DartIsolate : public UIDartState {
433454
Flags flags,
434455
const fml::closure& isolate_create_callback,
435456
const fml::closure& isolate_shutdown_callback,
436-
std::shared_ptr<VolatilePathTracker> volatile_path_tracker);
457+
std::shared_ptr<VolatilePathTracker> volatile_path_tracker,
458+
const DartIsolate* spawning_isolate = nullptr);
437459

438460
DartIsolate(const Settings& settings,
439461
TaskRunners task_runners,
@@ -463,6 +485,8 @@ class DartIsolate : public UIDartState {
463485

464486
DartIsolateGroupData& GetIsolateGroupData();
465487

488+
const DartIsolateGroupData& GetIsolateGroupData() const;
489+
466490
// |Dart_IsolateGroupCreateCallback|
467491
static Dart_Isolate DartIsolateGroupCreateCallback(
468492
const char* advisory_script_uri,
@@ -487,7 +511,11 @@ class DartIsolate : public UIDartState {
487511
std::unique_ptr<std::shared_ptr<DartIsolateGroupData>> isolate_group_data,
488512
std::unique_ptr<std::shared_ptr<DartIsolate>> isolate_data,
489513
Dart_IsolateFlags* flags,
490-
char** error);
514+
char** error,
515+
std::function<Dart_Isolate(std::shared_ptr<DartIsolateGroupData>*,
516+
std::shared_ptr<DartIsolate>*,
517+
Dart_IsolateFlags*,
518+
char**)> make_isolate);
491519

492520
static bool InitializeIsolate(std::shared_ptr<DartIsolate> embedder_isolate,
493521
Dart_Isolate isolate,

‎runtime/dart_vm_lifecycle.h‎

Lines changed: 12 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -31,6 +31,8 @@ class DartVMRef {
3131
fml::RefPtr<DartSnapshot> vm_snapshot = nullptr,
3232
fml::RefPtr<DartSnapshot> isolate_snapshot = nullptr);
3333

34+
DartVMRef(const DartVMRef&) = default;
35+
3436
DartVMRef(DartVMRef&&);
3537

3638
~DartVMRef();
@@ -53,11 +55,21 @@ class DartVMRef {
5355
return vm_.get();
5456
}
5557

58+
const DartVM* get() const {
59+
FML_DCHECK(vm_);
60+
return vm_.get();
61+
}
62+
5663
DartVM* operator->() {
5764
FML_DCHECK(vm_);
5865
return vm_.get();
5966
}
6067

68+
const DartVM* operator->() const {
69+
FML_DCHECK(vm_);
70+
return vm_.get();
71+
}
72+
6173
DartVM* operator&() {
6274
FML_DCHECK(vm_);
6375
return vm_.get();
@@ -72,8 +84,6 @@ class DartVMRef {
7284

7385
// Only used by Dart Isolate to register itself with the VM.
7486
static DartVM* GetRunningVM();
75-
76-
FML_DISALLOW_COPY_AND_ASSIGN(DartVMRef);
7787
};
7888

7989
} // namespace flutter

‎runtime/runtime_controller.cc‎

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -57,6 +57,25 @@ RuntimeController::RuntimeController(
5757
persistent_isolate_data_(std::move(p_persistent_isolate_data)),
5858
volatile_path_tracker_(std::move(p_volatile_path_tracker)) {}
5959

60+
std::unique_ptr<RuntimeController> RuntimeController::Spawn(
61+
RuntimeDelegate& client,
62+
std::string advisory_script_uri,
63+
std::string advisory_script_entrypoint,
64+
const std::function<void(int64_t)>& idle_notification_callback,
65+
const fml::closure& isolate_create_callback,
66+
const fml::closure& isolate_shutdown_callback,
67+
std::shared_ptr<const fml::Mapping> persistent_isolate_data) const {
68+
auto result = std::make_unique<RuntimeController>(
69+
client, vm_, isolate_snapshot_, task_runners_, snapshot_delegate_,
70+
hint_freed_delegate_, io_manager_, unref_queue_, image_decoder_,
71+
advisory_script_uri, advisory_script_entrypoint,
72+
idle_notification_callback, platform_data_, isolate_create_callback,
73+
isolate_shutdown_callback, persistent_isolate_data,
74+
volatile_path_tracker_);
75+
result->spawning_isolate_ = root_isolate_;
76+
return result;
77+
}
78+
6079
RuntimeController::~RuntimeController() {
6180
FML_DCHECK(Dart_CurrentIsolate() == nullptr);
6281
std::shared_ptr<DartIsolate> root_isolate = root_isolate_.lock();

‎runtime/runtime_controller.h‎

Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -133,6 +133,22 @@ class RuntimeController : public PlatformConfigurationClient {
133133
std::shared_ptr<const fml::Mapping> persistent_isolate_data,
134134
std::shared_ptr<VolatilePathTracker> volatile_path_tracker);
135135

136+
//----------------------------------------------------------------------------
137+
/// @brief Create a RuntimeController that shares as many resources as
138+
/// possible with the calling RuntimeController such that together
139+
/// they occupy less memory.
140+
/// @return A RuntimeController with a running isolate.
141+
/// @see RuntimeController::RuntimeController
142+
///
143+
std::unique_ptr<RuntimeController> Spawn(
144+
RuntimeDelegate& client,
145+
std::string advisory_script_uri,
146+
std::string advisory_script_entrypoint,
147+
const std::function<void(int64_t)>& idle_notification_callback,
148+
const fml::closure& isolate_create_callback,
149+
const fml::closure& isolate_shutdown_callback,
150+
std::shared_ptr<const fml::Mapping> persistent_isolate_data) const;
151+
136152
// |PlatformConfigurationClient|
137153
~RuntimeController() override;
138154

@@ -542,6 +558,23 @@ class RuntimeController : public PlatformConfigurationClient {
542558

543559
// |PlatformConfigurationClient|
544560
void RequestDartDeferredLibrary(intptr_t loading_unit_id) override;
561+
const fml::WeakPtr<IOManager>& GetIOManager() const { return io_manager_; }
562+
563+
DartVM* GetDartVM() const { return vm_; }
564+
565+
const fml::RefPtr<const DartSnapshot>& GetIsolateSnapshot() const {
566+
return isolate_snapshot_;
567+
}
568+
569+
const PlatformData& GetPlatformData() const { return platform_data_; }
570+
571+
const fml::RefPtr<SkiaUnrefQueue>& GetSkiaUnrefQueue() const {
572+
return unref_queue_;
573+
}
574+
575+
const fml::WeakPtr<SnapshotDelegate>& GetSnapshotDelegate() const {
576+
return snapshot_delegate_;
577+
}
545578

546579
protected:
547580
/// Constructor for Mocks.
@@ -576,6 +609,7 @@ class RuntimeController : public PlatformConfigurationClient {
576609
std::function<void(int64_t)> idle_notification_callback_;
577610
PlatformData platform_data_;
578611
std::weak_ptr<DartIsolate> root_isolate_;
612+
std::weak_ptr<DartIsolate> spawning_isolate_;
579613
std::optional<uint32_t> root_isolate_return_code_;
580614
const fml::closure isolate_create_callback_;
581615
const fml::closure isolate_shutdown_callback_;

‎shell/common/engine.cc‎

Lines changed: 27 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -97,6 +97,33 @@ Engine::Engine(Delegate& delegate,
9797
);
9898
}
9999

100+
std::unique_ptr<Engine> Engine::Spawn(
101+
Delegate& delegate,
102+
const PointerDataDispatcherMaker& dispatcher_maker,
103+
Settings settings,
104+
std::unique_ptr<Animator> animator) const {
105+
auto result = std::make_unique<Engine>(
106+
/*delegate=*/delegate,
107+
/*dispatcher_maker=*/dispatcher_maker,
108+
/*image_decoder_task_runner=*/
109+
runtime_controller_->GetDartVM()->GetConcurrentWorkerTaskRunner(),
110+
/*task_runners=*/task_runners_,
111+
/*settings=*/settings,
112+
/*animator=*/std::move(animator),
113+
/*io_manager=*/runtime_controller_->GetIOManager(),
114+
/*runtime_controller=*/nullptr);
115+
result->runtime_controller_ = runtime_controller_->Spawn(
116+
*result, // runtime delegate
117+
settings_.advisory_script_uri, // advisory script uri
118+
settings_.advisory_script_entrypoint, // advisory script entrypoint
119+
settings_.idle_notification_callback, // idle notification callback
120+
settings_.isolate_create_callback, // isolate create callback
121+
settings_.isolate_shutdown_callback, // isolate shutdown callback
122+
settings_.persistent_isolate_data // persistent isolate data
123+
);
124+
return result;
125+
}
126+
100127
Engine::~Engine() = default;
101128

102129
fml::WeakPtr<Engine> Engine::GetWeakPtr() const {

‎shell/common/engine.h‎

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -354,6 +354,19 @@ class Engine final : public RuntimeDelegate,
354354
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
355355
std::shared_ptr<VolatilePathTracker> volatile_path_tracker);
356356

357+
//----------------------------------------------------------------------------
358+
/// @brief Create a Engine that shares as many resources as
359+
/// possible with the calling Engine such that together
360+
/// they occupy less memory.
361+
/// @return A Engine with a running isolate.
362+
/// @see Engine::Engine
363+
///
364+
std::unique_ptr<Engine> Spawn(
365+
Delegate& delegate,
366+
const PointerDataDispatcherMaker& dispatcher_maker,
367+
Settings settings,
368+
std::unique_ptr<Animator> animator) const;
369+
357370
//----------------------------------------------------------------------------
358371
/// @brief Destroys the engine engine. Called by the shell on the UI task
359372
/// runner. The running root isolate is terminated and will no

0 commit comments

Comments
 (0)