DEV/flutter_flutter
1
0
Fork 0
mirror of https://github.com/flutter/flutter.git synced 2026-02-20 02:29:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

Started initializing the gpu disable syncswitch based on the app state. (flutter/engine#24503)

Browse Source
This commit is contained in:
gaaclarke 2021-02-24 22:24:29 -08:00 committed by GitHub
parent aa8cd80b56
commit 8d44387269
6 changed files with 90 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
engine/src/flutter/shell/common/shell.cc
View File

@ -139,7 +139,8 @@ std::unique_ptr<Shell> Shell::Create(
TaskRunners task_runners,
Settings settings,
const Shell::CreateCallback<PlatformView>& on_create_platform_view,
const Shell::CreateCallback<Rasterizer>& on_create_rasterizer) {
const Shell::CreateCallback<Rasterizer>& on_create_rasterizer,
bool is_gpu_disabled) {
// This must come first as it initializes tracing.
PerformInitializationTasks(settings);
@ -165,7 +166,7 @@ std::unique_ptr<Shell> Shell::Create(
std::move(isolate_snapshot), //
std::move(on_create_platform_view), //
std::move(on_create_rasterizer), //
CreateEngine);
CreateEngine, is_gpu_disabled);
}
std::unique_ptr<Shell> Shell::CreateShellOnPlatformThread(
@ -176,7 +177,8 @@ std::unique_ptr<Shell> Shell::CreateShellOnPlatformThread(
fml::RefPtr<const DartSnapshot> isolate_snapshot,
const Shell::CreateCallback<PlatformView>& on_create_platform_view,
const Shell::CreateCallback<Rasterizer>& on_create_rasterizer,
const Shell::EngineCreateCallback& on_create_engine) {
const Shell::EngineCreateCallback& on_create_engine,
bool is_gpu_disabled) {
if (!task_runners.IsValid()) {
FML_LOG(ERROR) << "Task runners to run the shell were invalid.";
return nullptr;
@ -186,7 +188,8 @@ std::unique_ptr<Shell> Shell::CreateShellOnPlatformThread(
new Shell(std::move(vm), task_runners, settings,
std::make_shared<VolatilePathTracker>(
task_runners.GetUITaskRunner(),
!settings.skia_deterministic_rendering_on_cpu)));
!settings.skia_deterministic_rendering_on_cpu),
is_gpu_disabled));
// Create the rasterizer on the raster thread.
std::promise<std::unique_ptr<Rasterizer>> rasterizer_promise;
@ -315,7 +318,8 @@ std::unique_ptr<Shell> Shell::CreateWithSnapshot(
fml::RefPtr<const DartSnapshot> isolate_snapshot,
const Shell::CreateCallback<PlatformView>& on_create_platform_view,
const Shell::CreateCallback<Rasterizer>& on_create_rasterizer,
const Shell::EngineCreateCallback& on_create_engine) {
const Shell::EngineCreateCallback& on_create_engine,
bool is_gpu_disabled) {
// This must come first as it initializes tracing.
PerformInitializationTasks(settings);
@ -341,7 +345,8 @@ std::unique_ptr<Shell> Shell::CreateWithSnapshot(
isolate_snapshot = std::move(isolate_snapshot), //
on_create_platform_view = std::move(on_create_platform_view), //
on_create_rasterizer = std::move(on_create_rasterizer), //
on_create_engine = std::move(on_create_engine)]() mutable {
on_create_engine = std::move(on_create_engine),
is_gpu_disabled]() mutable {
shell = CreateShellOnPlatformThread(
std::move(vm), //
std::move(task_runners), //
@ -350,7 +355,7 @@ std::unique_ptr<Shell> Shell::CreateWithSnapshot(
std::move(isolate_snapshot), //
std::move(on_create_platform_view), //
std::move(on_create_rasterizer), //
std::move(on_create_engine));
std::move(on_create_engine), is_gpu_disabled);
latch.Signal();
}));
latch.Wait();
@ -360,11 +365,12 @@ std::unique_ptr<Shell> Shell::CreateWithSnapshot(
Shell::Shell(DartVMRef vm,
TaskRunners task_runners,
Settings settings,
std::shared_ptr<VolatilePathTracker> volatile_path_tracker)
std::shared_ptr<VolatilePathTracker> volatile_path_tracker,
bool is_gpu_disabled)
: task_runners_(std::move(task_runners)),
settings_(std::move(settings)),
vm_(std::move(vm)),
is_gpu_disabled_sync_switch_(new fml::SyncSwitch()),
is_gpu_disabled_sync_switch_(new fml::SyncSwitch(is_gpu_disabled)),
volatile_path_tracker_(std::move(volatile_path_tracker)),
weak_factory_gpu_(nullptr),
weak_factory_(this) {
@ -481,25 +487,34 @@ std::unique_ptr<Shell> Shell::Spawn(
const CreateCallback<PlatformView>& on_create_platform_view,
const CreateCallback<Rasterizer>& on_create_rasterizer) const {
FML_DCHECK(task_runners_.IsValid());
std::unique_ptr<Shell> result(CreateWithSnapshot(
PlatformData{}, task_runners_, GetSettings(), vm_,
vm_->GetVMData()->GetIsolateSnapshot(), on_create_platform_view,
on_create_rasterizer,
[engine = this->engine_.get()](
Engine::Delegate& delegate,
const PointerDataDispatcherMaker& dispatcher_maker, DartVM& vm,
fml::RefPtr<const DartSnapshot> isolate_snapshot,
TaskRunners task_runners, const PlatformData& platform_data,
Settings settings, std::unique_ptr<Animator> animator,
fml::WeakPtr<IOManager> io_manager,
fml::RefPtr<SkiaUnrefQueue> unref_queue,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
std::shared_ptr<VolatilePathTracker> volatile_path_tracker) {
return engine->Spawn(/*delegate=*/delegate,
/*dispatcher_maker=*/dispatcher_maker,
/*settings=*/settings,
/*animator=*/std::move(animator));
}));
auto shell_maker = [&](bool is_gpu_disabled) {
std::unique_ptr<Shell> result(CreateWithSnapshot(
PlatformData{}, task_runners_, GetSettings(), vm_,
vm_->GetVMData()->GetIsolateSnapshot(), on_create_platform_view,
on_create_rasterizer,
[engine = this->engine_.get()](
Engine::Delegate& delegate,
const PointerDataDispatcherMaker& dispatcher_maker, DartVM& vm,
fml::RefPtr<const DartSnapshot> isolate_snapshot,
TaskRunners task_runners, const PlatformData& platform_data,
Settings settings, std::unique_ptr<Animator> animator,
fml::WeakPtr<IOManager> io_manager,
fml::RefPtr<SkiaUnrefQueue> unref_queue,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
std::shared_ptr<VolatilePathTracker> volatile_path_tracker) {
return engine->Spawn(/*delegate=*/delegate,
/*dispatcher_maker=*/dispatcher_maker,
/*settings=*/settings,
/*animator=*/std::move(animator));
},
is_gpu_disabled));
return result;
};
std::unique_ptr<Shell> result;
GetIsGpuDisabledSyncSwitch()->Execute(
fml::SyncSwitch::Handlers()
.SetIfFalse([&] { result = shell_maker(false); })
.SetIfTrue([&] { result = shell_maker(true); }));
result->shared_resource_context_ = io_manager_->GetSharedResourceContext();
result->RunEngine(std::move(run_configuration));

14
engine/src/flutter/shell/common/shell.h
View File

@ -134,6 +134,8 @@ class Shell final : public PlatformView::Delegate,
/// valid rasterizer. This will be called
/// on the render task runner before this
/// method returns.
/// @param[in] is_gpu_disabled The default value for the switch that
/// turns off the GPU.
///
/// @return A full initialized shell if the settings and callbacks are
/// valid. The root isolate has been created but not yet launched.
@ -148,7 +150,8 @@ class Shell final : public PlatformView::Delegate,
TaskRunners task_runners,
Settings settings,
const CreateCallback<PlatformView>& on_create_platform_view,
const CreateCallback<Rasterizer>& on_create_rasterizer);
const CreateCallback<Rasterizer>& on_create_rasterizer,
bool is_gpu_disabled = false);
//----------------------------------------------------------------------------
/// @brief Destroys the shell. This is a synchronous operation and
@ -413,7 +416,8 @@ class Shell final : public PlatformView::Delegate,
Shell(DartVMRef vm,
TaskRunners task_runners,
Settings settings,
std::shared_ptr<VolatilePathTracker> volatile_path_tracker);
std::shared_ptr<VolatilePathTracker> volatile_path_tracker,
bool is_gpu_disabled);
static std::unique_ptr<Shell> CreateShellOnPlatformThread(
DartVMRef vm,
@ -423,7 +427,8 @@ class Shell final : public PlatformView::Delegate,
fml::RefPtr<const DartSnapshot> isolate_snapshot,
const Shell::CreateCallback<PlatformView>& on_create_platform_view,
const Shell::CreateCallback<Rasterizer>& on_create_rasterizer,
const EngineCreateCallback& on_create_engine);
const EngineCreateCallback& on_create_engine,
bool is_gpu_disabled);
static std::unique_ptr<Shell> CreateWithSnapshot(
const PlatformData& platform_data,
TaskRunners task_runners,
@ -432,7 +437,8 @@ class Shell final : public PlatformView::Delegate,
fml::RefPtr<const DartSnapshot> isolate_snapshot,
const CreateCallback<PlatformView>& on_create_platform_view,
const CreateCallback<Rasterizer>& on_create_rasterizer,
const EngineCreateCallback& on_create_engine);
const EngineCreateCallback& on_create_engine,
bool is_gpu_disabled);
bool Setup(std::unique_ptr<PlatformView> platform_view,
std::unique_ptr<Engine> engine,

6
engine/src/flutter/shell/common/shell_test.cc
View File

@ -314,7 +314,8 @@ std::unique_ptr<Shell> ShellTest::CreateShell(
TaskRunners task_runners,
bool simulate_vsync,
std::shared_ptr<ShellTestExternalViewEmbedder>
shell_test_external_view_embedder) {
shell_test_external_view_embedder,
bool is_gpu_disabled) {
const auto vsync_clock = std::make_shared<ShellTestVsyncClock>();
CreateVsyncWaiter create_vsync_waiter = [&]() {
if (simulate_vsync) {
@ -335,7 +336,8 @@ std::unique_ptr<Shell> ShellTest::CreateShell(
ShellTestPlatformView::BackendType::kDefaultBackend,
shell_test_external_view_embedder);
},
[](Shell& shell) { return std::make_unique<Rasterizer>(shell); });
[](Shell& shell) { return std::make_unique<Rasterizer>(shell); },
is_gpu_disabled);
}
void ShellTest::DestroyShell(std::unique_ptr<Shell> shell) {
DestroyShell(std::move(shell), GetTaskRunnersForFixture());

3
engine/src/flutter/shell/common/shell_test.h
View File

@ -39,7 +39,8 @@ class ShellTest : public FixtureTest {
TaskRunners task_runners,
bool simulate_vsync = false,
std::shared_ptr<ShellTestExternalViewEmbedder>
shell_test_external_view_embedder = nullptr);
shell_test_external_view_embedder = nullptr,
bool is_gpu_disabled = false);
void DestroyShell(std::unique_ptr<Shell> shell);
void DestroyShell(std::unique_ptr<Shell> shell, TaskRunners task_runners);
TaskRunners GetTaskRunnersForFixture();

23
engine/src/flutter/shell/common/shell_unittests.cc
View File

@ -321,6 +321,29 @@ TEST_F(ShellTest,
ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}
TEST_F(ShellTest, InitializeWithDisabledGpu) {
ASSERT_FALSE(DartVMRef::IsInstanceRunning());
Settings settings = CreateSettingsForFixture();
ThreadHost thread_host("io.flutter.test." + GetCurrentTestName() + ".",
ThreadHost::Type::Platform);
auto task_runner = thread_host.platform_thread->GetTaskRunner();
TaskRunners task_runners("test", task_runner, task_runner, task_runner,
task_runner);
auto shell = CreateShell(
std::move(settings), std::move(task_runners), /*simulate_vsync=*/false,
/*shell_test_external_view_embedder=*/nullptr, /*is_gpu_disabled=*/true);
ASSERT_TRUE(DartVMRef::IsInstanceRunning());
ASSERT_TRUE(ValidateShell(shell.get()));
bool is_disabled = false;
shell->GetIsGpuDisabledSyncSwitch()->Execute(
fml::SyncSwitch::Handlers().SetIfTrue([&] { is_disabled = true; }));
ASSERT_TRUE(is_disabled);
DestroyShell(std::move(shell), std::move(task_runners));
ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}
TEST_F(ShellTest, InitializeWithGPUAndPlatformThreadsTheSame) {
ASSERT_FALSE(DartVMRef::IsInstanceRunning());
Settings settings = CreateSettingsForFixture();

15
engine/src/flutter/shell/platform/darwin/ios/framework/Source/FlutterEngine.mm
View File

@ -612,13 +612,14 @@ static void SetEntryPoint(flutter::Settings* settings, NSString* entrypoint, NSS
);
// Create the shell. This is a blocking operation.
std::unique_ptr<flutter::Shell> shell =
flutter::Shell::Create(std::move(platformData), // window data
std::move(task_runners), // task runners
std::move(settings), // settings
on_create_platform_view, // platform view creation
on_create_rasterizer // rasterzier creation
);
std::unique_ptr<flutter::Shell> shell = flutter::Shell::Create(
std::move(platformData), // window data
std::move(task_runners), // task runners
std::move(settings), // settings
on_create_platform_view, // platform view creation
on_create_rasterizer, // rasterzier creation
/*is_gpu_disabled=*/[UIApplication sharedApplication].applicationState !=
UIApplicationStateActive);
if (shell == nullptr) {
FML_LOG(ERROR) << "Could not start a shell FlutterEngine with entrypoint: "