Updates in flutter/testing for the shell refactor (Patch 11). #4839
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This changes is part of a large patch for easier review. Try the whole patch in one go by checking out https://github.com/chinmaygarde/flutter_engine/tree/shell directly. This patch contains the following changes: * Create a test fixture that creates its own thread with a message loop.
|
lgtm |
chinmaygarde
added a commit
to chinmaygarde/flutter_engine
that referenced
this pull request
Apr 4, 2018
The Flutter Engine currently works by initializing a singleton shell
instance. This shell has to be created on the platform thread. The shell
is responsible for creating the 3 main threads used by Flutter (UI, IO,
GPU) as well as initializing the Dart VM. The shell, references to task
runners of the main threads as well as all snapshots used for VM
initialization are stored in singleton objects. The Flutter shell only
creates the threads, rasterizers, contexts, etc. to fully support a
single Flutter application. Current support for multiple Flutter
applications is achieved by making multiple applications share the same
resources (via the platform views mechanism).
This scheme has the following limitations:
* The shell is a singleton and there is no way to tear it down. Once you
run a Flutter application in a process, all resources managed by it
will remain referenced till process termination.
* The threads on which the shell performs its operations are all
singletons. These threads are never torn down and multiple Flutter
applications (if present) have to compete with one another on these
threads.
* Resources referenced by the Dart VM are leaked because the VM isn't
shutdown even when there are no more Flutter views.
* The shell as a target does not compile on Fuchsia. The Fuchsia content
handler uses specific dependencies of the shell to rebuild all the
shell dependencies on its own. This leads to differences in frame
scheduling, VM setup, service protocol endpoint setup, tracing, etc..
Fuchsia is very much a second class citizen in this world.
* Since threads and message loops are managed by the engine, the engine
has to know about threading and platform message loop interop on each
supported platform.
Specific updates in this patch:
* The shell is no longer a singleton and the embedder holds the unique
reference to the shell.
* Shell setup and teardown is deterministic.
* Threads are no longer managed by the shell. Instead, the shell is
given a task runner configuration by the embedder.
* Since the shell does not own its threads, the embedder can control
threads and the message loops operating on these threads. The shell is
only given references to the task runners that execute tasks on these
threads.
* The shell only needs task runner references. These references can be
to the same task runner. So, if the embedder thinks that a particular
Flutter application would not need all the threads, it can pass
references to the same task runner. This effectively makes Flutter
application run in single threaded mode. There are some places in the
shell that make synchronous calls, these sites have been updated to
ensure that they don’t deadlock.
* The test runner and the headless Dart code runner are now Flutter
applications that are effectively single threaded (since they don’t
have rendering concerns of big-boy Flutter application).
* The embedder has to guarantee that the threads and outlive the shell.
It is easy for the embedder to make that guarantee because shell
termination is deterministic.
* The embedder can create as many shell as it wants. Typically it
creates a shell per Flutter application with its own task runner
configuration. Most embedders obtain these task runners from threads
dedicated to the shell. But, it is entirely possible that the embedder
can obtain these task runners from a thread pool.
* There can only be one Dart VM in the process. The numerous shell
interact with one another to manage the VM lifecycle. Once the last
shell goes away, the VM does as well and hence all resources
associated with the VM are collected.
* The shell as a target can now compile and run on Fuchsia. The current
content handler has been removed from the Flutter engine source tree
and a new implementation has been written that uses the new shell
target.
* Isolate management has been significantly overhauled. There are no
owning references to Dart isolates within the shell. The VM owns the
only strong reference to the Dart isolate. The isolate that has window
bindings is now called the root isolate. Child isolates can now be
created from the root isolate and their bindings and thread
configurations are now inherited from the root isolate.
* Terminating the shell terminates its root isolates as well as all the
isolates spawned by this isolate. This is necessary be shell shutdown
is deterministic and the embedder is free to collect the threads on
which the isolates execute their tasks (and listen for mircrotasks
flushes on).
* Launching the root isolate is now significantly overhauled. The shell
side (non-owning) reference to an isolate is now a little state
machine and illegal state transitions should be impossible (barring
construction issues). This is the only way to manage Dart isolates in
the shell (the shell does not use the C API is dart_api.h anymore).
* Once an isolate is launched, it must be prepared (and hence move to
the ready phase) by associating a snapshot with the same. This
snapshot can either be a precompiled snapshot, kernel snapshot, script
snapshot or source file. Depending on the kind of data specified as a
snapshot as well as the capabilities of the VM running in the process,
isolate preparation can fail preparation with the right message.
* Asset management has been significantly overhauled. All asset
resolution goes through an abstract asset resolver interface. An asset
manager implements this interface and manages one or more child asset
resolvers. These asset resolvers typically resolve assets from
directories, ZIP files (legacy FLX assets if provided), APK bundles,
FDIO namespaces, etc…
* Each launch of the shell requires a separate and fully configured
asset resolver. This is necessary because launching isolates for the
engine may require resolving snapshots as assets from the asset
resolver. Asset resolvers can be shared by multiple launch instances
in multiple shells and need to be thread safe.
* References to the command line object have been removed from the
shell. Instead, the shell only takes a settings object that may be
configured from the command line. This makes it easy for embedders and
platforms that don’t have a command line (Fuchsia) to configure the
shell. Consequently, there is only one spot where the various switches
are read from the command line (by the embedder and not the shell) to
form the settings object.
* All platform now respect the log tag (this was done only by Android
till now) and each shell instance have its own log tag. This makes
logs from multiple Flutter application in the same process (mainly
Fuchsia) more easily decipherable.
* The per shell IO task runner now has a new component that is
unfortunately named the IOManager. This component manages the IO
GrContext (used for asynchronous texture uploads) that cooperates with
the GrContext on the GPU task runner associated with the shell. The
IOManager is also responsible for flushing tasks that collect Skia
objects that reference GPU resources during deterministic shell
shutdown.
* The embedder now has to be careful to only enable Blink on a single
instance of the shell. Launching the legacy text layout and rendering
engine multiple times is will trip assertions. The entirety of this
runtime has been separated out into a separate object and can be
removed in one go when the migration to libtxt is complete.
* There is a new test target for the various C++ objects that the shell
uses to interact with the Dart VM (the shell no longer use the C API
in dart_api.h). This allows engine developers to test VM/Isolate
initialization and teardown without having the setup a full shell
instance.
* There is a new test target for the testing a single shell instances
without having to configure and launch an entire VM and associated
root isolate.
* Mac, Linux & Windows used to have different target that created the
flutter_tester referenced by the tool. This has now been converted
into a single target that compiles on all platforms.
* WeakPointers vended by the fml::WeakPtrFactory(notice the difference
between the same class in the fxl namespace) add threading checks on
each use. This is enabled by getting rid of the “re-origination”
feature of the WeakPtrFactory in the fxl namespace. The side effect of
this is that all non-thread safe components have to be created, used
and destroyed on the same thread. Numerous thread safety issues were
caught by this extra assertion and have now been fixed.
* Glossary of components that are only safe on a specific thread (and
have the fml variants of the WeakPtrFactory):
* Platform Thread: Shell
* UI Thread: Engine, RuntimeDelegate, DartIsolate, Animator
* GPU Thread: Rasterizer, Surface
* IO Thread: IOManager
This patch was reviewed in smaller chunks in the following pull
requests. All comments from the pulls requests has been incorporated
into this patch:
* flutter/assets: flutter#4829
* flutter/common: flutter#4830
* flutter/content_handler: flutter#4831
* flutter/flow: flutter#4832
* flutter/fml: flutter#4833
* flutter/lib/snapshot: flutter#4834
* flutter/lib/ui: flutter#4835
* flutter/runtime: flutter#4836
* flutter/shell: flutter#4837
* flutter/synchronization: flutter#4838
* flutter/testing: flutter#4839
chinmaygarde
added a commit
to chinmaygarde/flutter_engine
that referenced
this pull request
Apr 9, 2018
The Flutter Engine currently works by initializing a singleton shell
instance. This shell has to be created on the platform thread. The shell
is responsible for creating the 3 main threads used by Flutter (UI, IO,
GPU) as well as initializing the Dart VM. The shell, references to task
runners of the main threads as well as all snapshots used for VM
initialization are stored in singleton objects. The Flutter shell only
creates the threads, rasterizers, contexts, etc. to fully support a
single Flutter application. Current support for multiple Flutter
applications is achieved by making multiple applications share the same
resources (via the platform views mechanism).
This scheme has the following limitations:
* The shell is a singleton and there is no way to tear it down. Once you
run a Flutter application in a process, all resources managed by it
will remain referenced till process termination.
* The threads on which the shell performs its operations are all
singletons. These threads are never torn down and multiple Flutter
applications (if present) have to compete with one another on these
threads.
* Resources referenced by the Dart VM are leaked because the VM isn't
shutdown even when there are no more Flutter views.
* The shell as a target does not compile on Fuchsia. The Fuchsia content
handler uses specific dependencies of the shell to rebuild all the
shell dependencies on its own. This leads to differences in frame
scheduling, VM setup, service protocol endpoint setup, tracing, etc..
Fuchsia is very much a second class citizen in this world.
* Since threads and message loops are managed by the engine, the engine
has to know about threading and platform message loop interop on each
supported platform.
Specific updates in this patch:
* The shell is no longer a singleton and the embedder holds the unique
reference to the shell.
* Shell setup and teardown is deterministic.
* Threads are no longer managed by the shell. Instead, the shell is
given a task runner configuration by the embedder.
* Since the shell does not own its threads, the embedder can control
threads and the message loops operating on these threads. The shell is
only given references to the task runners that execute tasks on these
threads.
* The shell only needs task runner references. These references can be
to the same task runner. So, if the embedder thinks that a particular
Flutter application would not need all the threads, it can pass
references to the same task runner. This effectively makes Flutter
application run in single threaded mode. There are some places in the
shell that make synchronous calls, these sites have been updated to
ensure that they don’t deadlock.
* The test runner and the headless Dart code runner are now Flutter
applications that are effectively single threaded (since they don’t
have rendering concerns of big-boy Flutter application).
* The embedder has to guarantee that the threads and outlive the shell.
It is easy for the embedder to make that guarantee because shell
termination is deterministic.
* The embedder can create as many shell as it wants. Typically it
creates a shell per Flutter application with its own task runner
configuration. Most embedders obtain these task runners from threads
dedicated to the shell. But, it is entirely possible that the embedder
can obtain these task runners from a thread pool.
* There can only be one Dart VM in the process. The numerous shell
interact with one another to manage the VM lifecycle. Once the last
shell goes away, the VM does as well and hence all resources
associated with the VM are collected.
* The shell as a target can now compile and run on Fuchsia. The current
content handler has been removed from the Flutter engine source tree
and a new implementation has been written that uses the new shell
target.
* Isolate management has been significantly overhauled. There are no
owning references to Dart isolates within the shell. The VM owns the
only strong reference to the Dart isolate. The isolate that has window
bindings is now called the root isolate. Child isolates can now be
created from the root isolate and their bindings and thread
configurations are now inherited from the root isolate.
* Terminating the shell terminates its root isolates as well as all the
isolates spawned by this isolate. This is necessary be shell shutdown
is deterministic and the embedder is free to collect the threads on
which the isolates execute their tasks (and listen for mircrotasks
flushes on).
* Launching the root isolate is now significantly overhauled. The shell
side (non-owning) reference to an isolate is now a little state
machine and illegal state transitions should be impossible (barring
construction issues). This is the only way to manage Dart isolates in
the shell (the shell does not use the C API is dart_api.h anymore).
* Once an isolate is launched, it must be prepared (and hence move to
the ready phase) by associating a snapshot with the same. This
snapshot can either be a precompiled snapshot, kernel snapshot, script
snapshot or source file. Depending on the kind of data specified as a
snapshot as well as the capabilities of the VM running in the process,
isolate preparation can fail preparation with the right message.
* Asset management has been significantly overhauled. All asset
resolution goes through an abstract asset resolver interface. An asset
manager implements this interface and manages one or more child asset
resolvers. These asset resolvers typically resolve assets from
directories, ZIP files (legacy FLX assets if provided), APK bundles,
FDIO namespaces, etc…
* Each launch of the shell requires a separate and fully configured
asset resolver. This is necessary because launching isolates for the
engine may require resolving snapshots as assets from the asset
resolver. Asset resolvers can be shared by multiple launch instances
in multiple shells and need to be thread safe.
* References to the command line object have been removed from the
shell. Instead, the shell only takes a settings object that may be
configured from the command line. This makes it easy for embedders and
platforms that don’t have a command line (Fuchsia) to configure the
shell. Consequently, there is only one spot where the various switches
are read from the command line (by the embedder and not the shell) to
form the settings object.
* All platform now respect the log tag (this was done only by Android
till now) and each shell instance have its own log tag. This makes
logs from multiple Flutter application in the same process (mainly
Fuchsia) more easily decipherable.
* The per shell IO task runner now has a new component that is
unfortunately named the IOManager. This component manages the IO
GrContext (used for asynchronous texture uploads) that cooperates with
the GrContext on the GPU task runner associated with the shell. The
IOManager is also responsible for flushing tasks that collect Skia
objects that reference GPU resources during deterministic shell
shutdown.
* The embedder now has to be careful to only enable Blink on a single
instance of the shell. Launching the legacy text layout and rendering
engine multiple times is will trip assertions. The entirety of this
runtime has been separated out into a separate object and can be
removed in one go when the migration to libtxt is complete.
* There is a new test target for the various C++ objects that the shell
uses to interact with the Dart VM (the shell no longer use the C API
in dart_api.h). This allows engine developers to test VM/Isolate
initialization and teardown without having the setup a full shell
instance.
* There is a new test target for the testing a single shell instances
without having to configure and launch an entire VM and associated
root isolate.
* Mac, Linux & Windows used to have different target that created the
flutter_tester referenced by the tool. This has now been converted
into a single target that compiles on all platforms.
* WeakPointers vended by the fml::WeakPtrFactory(notice the difference
between the same class in the fxl namespace) add threading checks on
each use. This is enabled by getting rid of the “re-origination”
feature of the WeakPtrFactory in the fxl namespace. The side effect of
this is that all non-thread safe components have to be created, used
and destroyed on the same thread. Numerous thread safety issues were
caught by this extra assertion and have now been fixed.
* Glossary of components that are only safe on a specific thread (and
have the fml variants of the WeakPtrFactory):
* Platform Thread: Shell
* UI Thread: Engine, RuntimeDelegate, DartIsolate, Animator
* GPU Thread: Rasterizer, Surface
* IO Thread: IOManager
This patch was reviewed in smaller chunks in the following pull
requests. All comments from the pulls requests has been incorporated
into this patch:
* flutter/assets: flutter#4829
* flutter/common: flutter#4830
* flutter/content_handler: flutter#4831
* flutter/flow: flutter#4832
* flutter/fml: flutter#4833
* flutter/lib/snapshot: flutter#4834
* flutter/lib/ui: flutter#4835
* flutter/runtime: flutter#4836
* flutter/shell: flutter#4837
* flutter/synchronization: flutter#4838
* flutter/testing: flutter#4839
chinmaygarde
added a commit
to chinmaygarde/flutter_engine
that referenced
this pull request
Apr 9, 2018
The Flutter Engine currently works by initializing a singleton shell
instance. This shell has to be created on the platform thread. The shell
is responsible for creating the 3 main threads used by Flutter (UI, IO,
GPU) as well as initializing the Dart VM. The shell, references to task
runners of the main threads as well as all snapshots used for VM
initialization are stored in singleton objects. The Flutter shell only
creates the threads, rasterizers, contexts, etc. to fully support a
single Flutter application. Current support for multiple Flutter
applications is achieved by making multiple applications share the same
resources (via the platform views mechanism).
This scheme has the following limitations:
* The shell is a singleton and there is no way to tear it down. Once you
run a Flutter application in a process, all resources managed by it
will remain referenced till process termination.
* The threads on which the shell performs its operations are all
singletons. These threads are never torn down and multiple Flutter
applications (if present) have to compete with one another on these
threads.
* Resources referenced by the Dart VM are leaked because the VM isn't
shutdown even when there are no more Flutter views.
* The shell as a target does not compile on Fuchsia. The Fuchsia content
handler uses specific dependencies of the shell to rebuild all the
shell dependencies on its own. This leads to differences in frame
scheduling, VM setup, service protocol endpoint setup, tracing, etc..
Fuchsia is very much a second class citizen in this world.
* Since threads and message loops are managed by the engine, the engine
has to know about threading and platform message loop interop on each
supported platform.
Specific updates in this patch:
* The shell is no longer a singleton and the embedder holds the unique
reference to the shell.
* Shell setup and teardown is deterministic.
* Threads are no longer managed by the shell. Instead, the shell is
given a task runner configuration by the embedder.
* Since the shell does not own its threads, the embedder can control
threads and the message loops operating on these threads. The shell is
only given references to the task runners that execute tasks on these
threads.
* The shell only needs task runner references. These references can be
to the same task runner. So, if the embedder thinks that a particular
Flutter application would not need all the threads, it can pass
references to the same task runner. This effectively makes Flutter
application run in single threaded mode. There are some places in the
shell that make synchronous calls, these sites have been updated to
ensure that they don’t deadlock.
* The test runner and the headless Dart code runner are now Flutter
applications that are effectively single threaded (since they don’t
have rendering concerns of big-boy Flutter application).
* The embedder has to guarantee that the threads and outlive the shell.
It is easy for the embedder to make that guarantee because shell
termination is deterministic.
* The embedder can create as many shell as it wants. Typically it
creates a shell per Flutter application with its own task runner
configuration. Most embedders obtain these task runners from threads
dedicated to the shell. But, it is entirely possible that the embedder
can obtain these task runners from a thread pool.
* There can only be one Dart VM in the process. The numerous shell
interact with one another to manage the VM lifecycle. Once the last
shell goes away, the VM does as well and hence all resources
associated with the VM are collected.
* The shell as a target can now compile and run on Fuchsia. The current
content handler has been removed from the Flutter engine source tree
and a new implementation has been written that uses the new shell
target.
* Isolate management has been significantly overhauled. There are no
owning references to Dart isolates within the shell. The VM owns the
only strong reference to the Dart isolate. The isolate that has window
bindings is now called the root isolate. Child isolates can now be
created from the root isolate and their bindings and thread
configurations are now inherited from the root isolate.
* Terminating the shell terminates its root isolates as well as all the
isolates spawned by this isolate. This is necessary be shell shutdown
is deterministic and the embedder is free to collect the threads on
which the isolates execute their tasks (and listen for mircrotasks
flushes on).
* Launching the root isolate is now significantly overhauled. The shell
side (non-owning) reference to an isolate is now a little state
machine and illegal state transitions should be impossible (barring
construction issues). This is the only way to manage Dart isolates in
the shell (the shell does not use the C API is dart_api.h anymore).
* Once an isolate is launched, it must be prepared (and hence move to
the ready phase) by associating a snapshot with the same. This
snapshot can either be a precompiled snapshot, kernel snapshot, script
snapshot or source file. Depending on the kind of data specified as a
snapshot as well as the capabilities of the VM running in the process,
isolate preparation can fail preparation with the right message.
* Asset management has been significantly overhauled. All asset
resolution goes through an abstract asset resolver interface. An asset
manager implements this interface and manages one or more child asset
resolvers. These asset resolvers typically resolve assets from
directories, ZIP files (legacy FLX assets if provided), APK bundles,
FDIO namespaces, etc…
* Each launch of the shell requires a separate and fully configured
asset resolver. This is necessary because launching isolates for the
engine may require resolving snapshots as assets from the asset
resolver. Asset resolvers can be shared by multiple launch instances
in multiple shells and need to be thread safe.
* References to the command line object have been removed from the
shell. Instead, the shell only takes a settings object that may be
configured from the command line. This makes it easy for embedders and
platforms that don’t have a command line (Fuchsia) to configure the
shell. Consequently, there is only one spot where the various switches
are read from the command line (by the embedder and not the shell) to
form the settings object.
* All platform now respect the log tag (this was done only by Android
till now) and each shell instance have its own log tag. This makes
logs from multiple Flutter application in the same process (mainly
Fuchsia) more easily decipherable.
* The per shell IO task runner now has a new component that is
unfortunately named the IOManager. This component manages the IO
GrContext (used for asynchronous texture uploads) that cooperates with
the GrContext on the GPU task runner associated with the shell. The
IOManager is also responsible for flushing tasks that collect Skia
objects that reference GPU resources during deterministic shell
shutdown.
* The embedder now has to be careful to only enable Blink on a single
instance of the shell. Launching the legacy text layout and rendering
engine multiple times is will trip assertions. The entirety of this
runtime has been separated out into a separate object and can be
removed in one go when the migration to libtxt is complete.
* There is a new test target for the various C++ objects that the shell
uses to interact with the Dart VM (the shell no longer use the C API
in dart_api.h). This allows engine developers to test VM/Isolate
initialization and teardown without having the setup a full shell
instance.
* There is a new test target for the testing a single shell instances
without having to configure and launch an entire VM and associated
root isolate.
* Mac, Linux & Windows used to have different target that created the
flutter_tester referenced by the tool. This has now been converted
into a single target that compiles on all platforms.
* WeakPointers vended by the fml::WeakPtrFactory(notice the difference
between the same class in the fxl namespace) add threading checks on
each use. This is enabled by getting rid of the “re-origination”
feature of the WeakPtrFactory in the fxl namespace. The side effect of
this is that all non-thread safe components have to be created, used
and destroyed on the same thread. Numerous thread safety issues were
caught by this extra assertion and have now been fixed.
* Glossary of components that are only safe on a specific thread (and
have the fml variants of the WeakPtrFactory):
* Platform Thread: Shell
* UI Thread: Engine, RuntimeDelegate, DartIsolate, Animator
* GPU Thread: Rasterizer, Surface
* IO Thread: IOManager
This patch was reviewed in smaller chunks in the following pull
requests. All comments from the pulls requests has been incorporated
into this patch:
* flutter/assets: flutter#4829
* flutter/common: flutter#4830
* flutter/content_handler: flutter#4831
* flutter/flow: flutter#4832
* flutter/fml: flutter#4833
* flutter/lib/snapshot: flutter#4834
* flutter/lib/ui: flutter#4835
* flutter/runtime: flutter#4836
* flutter/shell: flutter#4837
* flutter/synchronization: flutter#4838
* flutter/testing: flutter#4839
chinmaygarde
added a commit
to chinmaygarde/flutter_engine
that referenced
this pull request
Apr 10, 2018
The Flutter Engine currently works by initializing a singleton shell
instance. This shell has to be created on the platform thread. The shell
is responsible for creating the 3 main threads used by Flutter (UI, IO,
GPU) as well as initializing the Dart VM. The shell, references to task
runners of the main threads as well as all snapshots used for VM
initialization are stored in singleton objects. The Flutter shell only
creates the threads, rasterizers, contexts, etc. to fully support a
single Flutter application. Current support for multiple Flutter
applications is achieved by making multiple applications share the same
resources (via the platform views mechanism).
This scheme has the following limitations:
* The shell is a singleton and there is no way to tear it down. Once you
run a Flutter application in a process, all resources managed by it
will remain referenced till process termination.
* The threads on which the shell performs its operations are all
singletons. These threads are never torn down and multiple Flutter
applications (if present) have to compete with one another on these
threads.
* Resources referenced by the Dart VM are leaked because the VM isn't
shutdown even when there are no more Flutter views.
* The shell as a target does not compile on Fuchsia. The Fuchsia content
handler uses specific dependencies of the shell to rebuild all the
shell dependencies on its own. This leads to differences in frame
scheduling, VM setup, service protocol endpoint setup, tracing, etc..
Fuchsia is very much a second class citizen in this world.
* Since threads and message loops are managed by the engine, the engine
has to know about threading and platform message loop interop on each
supported platform.
Specific updates in this patch:
* The shell is no longer a singleton and the embedder holds the unique
reference to the shell.
* Shell setup and teardown is deterministic.
* Threads are no longer managed by the shell. Instead, the shell is
given a task runner configuration by the embedder.
* Since the shell does not own its threads, the embedder can control
threads and the message loops operating on these threads. The shell is
only given references to the task runners that execute tasks on these
threads.
* The shell only needs task runner references. These references can be
to the same task runner. So, if the embedder thinks that a particular
Flutter application would not need all the threads, it can pass
references to the same task runner. This effectively makes Flutter
application run in single threaded mode. There are some places in the
shell that make synchronous calls, these sites have been updated to
ensure that they don’t deadlock.
* The test runner and the headless Dart code runner are now Flutter
applications that are effectively single threaded (since they don’t
have rendering concerns of big-boy Flutter application).
* The embedder has to guarantee that the threads and outlive the shell.
It is easy for the embedder to make that guarantee because shell
termination is deterministic.
* The embedder can create as many shell as it wants. Typically it
creates a shell per Flutter application with its own task runner
configuration. Most embedders obtain these task runners from threads
dedicated to the shell. But, it is entirely possible that the embedder
can obtain these task runners from a thread pool.
* There can only be one Dart VM in the process. The numerous shell
interact with one another to manage the VM lifecycle. Once the last
shell goes away, the VM does as well and hence all resources
associated with the VM are collected.
* The shell as a target can now compile and run on Fuchsia. The current
content handler has been removed from the Flutter engine source tree
and a new implementation has been written that uses the new shell
target.
* Isolate management has been significantly overhauled. There are no
owning references to Dart isolates within the shell. The VM owns the
only strong reference to the Dart isolate. The isolate that has window
bindings is now called the root isolate. Child isolates can now be
created from the root isolate and their bindings and thread
configurations are now inherited from the root isolate.
* Terminating the shell terminates its root isolates as well as all the
isolates spawned by this isolate. This is necessary be shell shutdown
is deterministic and the embedder is free to collect the threads on
which the isolates execute their tasks (and listen for mircrotasks
flushes on).
* Launching the root isolate is now significantly overhauled. The shell
side (non-owning) reference to an isolate is now a little state
machine and illegal state transitions should be impossible (barring
construction issues). This is the only way to manage Dart isolates in
the shell (the shell does not use the C API is dart_api.h anymore).
* Once an isolate is launched, it must be prepared (and hence move to
the ready phase) by associating a snapshot with the same. This
snapshot can either be a precompiled snapshot, kernel snapshot, script
snapshot or source file. Depending on the kind of data specified as a
snapshot as well as the capabilities of the VM running in the process,
isolate preparation can fail preparation with the right message.
* Asset management has been significantly overhauled. All asset
resolution goes through an abstract asset resolver interface. An asset
manager implements this interface and manages one or more child asset
resolvers. These asset resolvers typically resolve assets from
directories, ZIP files (legacy FLX assets if provided), APK bundles,
FDIO namespaces, etc…
* Each launch of the shell requires a separate and fully configured
asset resolver. This is necessary because launching isolates for the
engine may require resolving snapshots as assets from the asset
resolver. Asset resolvers can be shared by multiple launch instances
in multiple shells and need to be thread safe.
* References to the command line object have been removed from the
shell. Instead, the shell only takes a settings object that may be
configured from the command line. This makes it easy for embedders and
platforms that don’t have a command line (Fuchsia) to configure the
shell. Consequently, there is only one spot where the various switches
are read from the command line (by the embedder and not the shell) to
form the settings object.
* All platform now respect the log tag (this was done only by Android
till now) and each shell instance have its own log tag. This makes
logs from multiple Flutter application in the same process (mainly
Fuchsia) more easily decipherable.
* The per shell IO task runner now has a new component that is
unfortunately named the IOManager. This component manages the IO
GrContext (used for asynchronous texture uploads) that cooperates with
the GrContext on the GPU task runner associated with the shell. The
IOManager is also responsible for flushing tasks that collect Skia
objects that reference GPU resources during deterministic shell
shutdown.
* The embedder now has to be careful to only enable Blink on a single
instance of the shell. Launching the legacy text layout and rendering
engine multiple times is will trip assertions. The entirety of this
runtime has been separated out into a separate object and can be
removed in one go when the migration to libtxt is complete.
* There is a new test target for the various C++ objects that the shell
uses to interact with the Dart VM (the shell no longer use the C API
in dart_api.h). This allows engine developers to test VM/Isolate
initialization and teardown without having the setup a full shell
instance.
* There is a new test target for the testing a single shell instances
without having to configure and launch an entire VM and associated
root isolate.
* Mac, Linux & Windows used to have different target that created the
flutter_tester referenced by the tool. This has now been converted
into a single target that compiles on all platforms.
* WeakPointers vended by the fml::WeakPtrFactory(notice the difference
between the same class in the fxl namespace) add threading checks on
each use. This is enabled by getting rid of the “re-origination”
feature of the WeakPtrFactory in the fxl namespace. The side effect of
this is that all non-thread safe components have to be created, used
and destroyed on the same thread. Numerous thread safety issues were
caught by this extra assertion and have now been fixed.
* Glossary of components that are only safe on a specific thread (and
have the fml variants of the WeakPtrFactory):
* Platform Thread: Shell
* UI Thread: Engine, RuntimeDelegate, DartIsolate, Animator
* GPU Thread: Rasterizer, Surface
* IO Thread: IOManager
This patch was reviewed in smaller chunks in the following pull
requests. All comments from the pulls requests has been incorporated
into this patch:
* flutter/assets: flutter#4829
* flutter/common: flutter#4830
* flutter/content_handler: flutter#4831
* flutter/flow: flutter#4832
* flutter/fml: flutter#4833
* flutter/lib/snapshot: flutter#4834
* flutter/lib/ui: flutter#4835
* flutter/runtime: flutter#4836
* flutter/shell: flutter#4837
* flutter/synchronization: flutter#4838
* flutter/testing: flutter#4839
chinmaygarde
added a commit
that referenced
this pull request
Apr 10, 2018
* Support multiple shells in a single process.
The Flutter Engine currently works by initializing a singleton shell
instance. This shell has to be created on the platform thread. The shell
is responsible for creating the 3 main threads used by Flutter (UI, IO,
GPU) as well as initializing the Dart VM. The shell, references to task
runners of the main threads as well as all snapshots used for VM
initialization are stored in singleton objects. The Flutter shell only
creates the threads, rasterizers, contexts, etc. to fully support a
single Flutter application. Current support for multiple Flutter
applications is achieved by making multiple applications share the same
resources (via the platform views mechanism).
This scheme has the following limitations:
* The shell is a singleton and there is no way to tear it down. Once you
run a Flutter application in a process, all resources managed by it
will remain referenced till process termination.
* The threads on which the shell performs its operations are all
singletons. These threads are never torn down and multiple Flutter
applications (if present) have to compete with one another on these
threads.
* Resources referenced by the Dart VM are leaked because the VM isn't
shutdown even when there are no more Flutter views.
* The shell as a target does not compile on Fuchsia. The Fuchsia content
handler uses specific dependencies of the shell to rebuild all the
shell dependencies on its own. This leads to differences in frame
scheduling, VM setup, service protocol endpoint setup, tracing, etc..
Fuchsia is very much a second class citizen in this world.
* Since threads and message loops are managed by the engine, the engine
has to know about threading and platform message loop interop on each
supported platform.
Specific updates in this patch:
* The shell is no longer a singleton and the embedder holds the unique
reference to the shell.
* Shell setup and teardown is deterministic.
* Threads are no longer managed by the shell. Instead, the shell is
given a task runner configuration by the embedder.
* Since the shell does not own its threads, the embedder can control
threads and the message loops operating on these threads. The shell is
only given references to the task runners that execute tasks on these
threads.
* The shell only needs task runner references. These references can be
to the same task runner. So, if the embedder thinks that a particular
Flutter application would not need all the threads, it can pass
references to the same task runner. This effectively makes Flutter
application run in single threaded mode. There are some places in the
shell that make synchronous calls, these sites have been updated to
ensure that they don’t deadlock.
* The test runner and the headless Dart code runner are now Flutter
applications that are effectively single threaded (since they don’t
have rendering concerns of big-boy Flutter application).
* The embedder has to guarantee that the threads and outlive the shell.
It is easy for the embedder to make that guarantee because shell
termination is deterministic.
* The embedder can create as many shell as it wants. Typically it
creates a shell per Flutter application with its own task runner
configuration. Most embedders obtain these task runners from threads
dedicated to the shell. But, it is entirely possible that the embedder
can obtain these task runners from a thread pool.
* There can only be one Dart VM in the process. The numerous shell
interact with one another to manage the VM lifecycle. Once the last
shell goes away, the VM does as well and hence all resources
associated with the VM are collected.
* The shell as a target can now compile and run on Fuchsia. The current
content handler has been removed from the Flutter engine source tree
and a new implementation has been written that uses the new shell
target.
* Isolate management has been significantly overhauled. There are no
owning references to Dart isolates within the shell. The VM owns the
only strong reference to the Dart isolate. The isolate that has window
bindings is now called the root isolate. Child isolates can now be
created from the root isolate and their bindings and thread
configurations are now inherited from the root isolate.
* Terminating the shell terminates its root isolates as well as all the
isolates spawned by this isolate. This is necessary be shell shutdown
is deterministic and the embedder is free to collect the threads on
which the isolates execute their tasks (and listen for mircrotasks
flushes on).
* Launching the root isolate is now significantly overhauled. The shell
side (non-owning) reference to an isolate is now a little state
machine and illegal state transitions should be impossible (barring
construction issues). This is the only way to manage Dart isolates in
the shell (the shell does not use the C API is dart_api.h anymore).
* Once an isolate is launched, it must be prepared (and hence move to
the ready phase) by associating a snapshot with the same. This
snapshot can either be a precompiled snapshot, kernel snapshot, script
snapshot or source file. Depending on the kind of data specified as a
snapshot as well as the capabilities of the VM running in the process,
isolate preparation can fail preparation with the right message.
* Asset management has been significantly overhauled. All asset
resolution goes through an abstract asset resolver interface. An asset
manager implements this interface and manages one or more child asset
resolvers. These asset resolvers typically resolve assets from
directories, ZIP files (legacy FLX assets if provided), APK bundles,
FDIO namespaces, etc…
* Each launch of the shell requires a separate and fully configured
asset resolver. This is necessary because launching isolates for the
engine may require resolving snapshots as assets from the asset
resolver. Asset resolvers can be shared by multiple launch instances
in multiple shells and need to be thread safe.
* References to the command line object have been removed from the
shell. Instead, the shell only takes a settings object that may be
configured from the command line. This makes it easy for embedders and
platforms that don’t have a command line (Fuchsia) to configure the
shell. Consequently, there is only one spot where the various switches
are read from the command line (by the embedder and not the shell) to
form the settings object.
* All platform now respect the log tag (this was done only by Android
till now) and each shell instance have its own log tag. This makes
logs from multiple Flutter application in the same process (mainly
Fuchsia) more easily decipherable.
* The per shell IO task runner now has a new component that is
unfortunately named the IOManager. This component manages the IO
GrContext (used for asynchronous texture uploads) that cooperates with
the GrContext on the GPU task runner associated with the shell. The
IOManager is also responsible for flushing tasks that collect Skia
objects that reference GPU resources during deterministic shell
shutdown.
* The embedder now has to be careful to only enable Blink on a single
instance of the shell. Launching the legacy text layout and rendering
engine multiple times is will trip assertions. The entirety of this
runtime has been separated out into a separate object and can be
removed in one go when the migration to libtxt is complete.
* There is a new test target for the various C++ objects that the shell
uses to interact with the Dart VM (the shell no longer use the C API
in dart_api.h). This allows engine developers to test VM/Isolate
initialization and teardown without having the setup a full shell
instance.
* There is a new test target for the testing a single shell instances
without having to configure and launch an entire VM and associated
root isolate.
* Mac, Linux & Windows used to have different target that created the
flutter_tester referenced by the tool. This has now been converted
into a single target that compiles on all platforms.
* WeakPointers vended by the fml::WeakPtrFactory(notice the difference
between the same class in the fxl namespace) add threading checks on
each use. This is enabled by getting rid of the “re-origination”
feature of the WeakPtrFactory in the fxl namespace. The side effect of
this is that all non-thread safe components have to be created, used
and destroyed on the same thread. Numerous thread safety issues were
caught by this extra assertion and have now been fixed.
* Glossary of components that are only safe on a specific thread (and
have the fml variants of the WeakPtrFactory):
* Platform Thread: Shell
* UI Thread: Engine, RuntimeDelegate, DartIsolate, Animator
* GPU Thread: Rasterizer, Surface
* IO Thread: IOManager
This patch was reviewed in smaller chunks in the following pull
requests. All comments from the pulls requests has been incorporated
into this patch:
* flutter/assets: #4829
* flutter/common: #4830
* flutter/content_handler: #4831
* flutter/flow: #4832
* flutter/fml: #4833
* flutter/lib/snapshot: #4834
* flutter/lib/ui: #4835
* flutter/runtime: #4836
* flutter/shell: #4837
* flutter/synchronization: #4838
* flutter/testing: #4839
|
Landed in #4932. |
chinmaygarde
added a commit
to chinmaygarde/flutter_engine
that referenced
this pull request
Apr 10, 2018
The Flutter Engine currently works by initializing a singleton shell
instance. This shell has to be created on the platform thread. The shell
is responsible for creating the 3 main threads used by Flutter (UI, IO,
GPU) as well as initializing the Dart VM. The shell, references to task
runners of the main threads as well as all snapshots used for VM
initialization are stored in singleton objects. The Flutter shell only
creates the threads, rasterizers, contexts, etc. to fully support a
single Flutter application. Current support for multiple Flutter
applications is achieved by making multiple applications share the same
resources (via the platform views mechanism).
This scheme has the following limitations:
* The shell is a singleton and there is no way to tear it down. Once you
run a Flutter application in a process, all resources managed by it
will remain referenced till process termination.
* The threads on which the shell performs its operations are all
singletons. These threads are never torn down and multiple Flutter
applications (if present) have to compete with one another on these
threads.
* Resources referenced by the Dart VM are leaked because the VM isn't
shutdown even when there are no more Flutter views.
* The shell as a target does not compile on Fuchsia. The Fuchsia content
handler uses specific dependencies of the shell to rebuild all the
shell dependencies on its own. This leads to differences in frame
scheduling, VM setup, service protocol endpoint setup, tracing, etc..
Fuchsia is very much a second class citizen in this world.
* Since threads and message loops are managed by the engine, the engine
has to know about threading and platform message loop interop on each
supported platform.
Specific updates in this patch:
* The shell is no longer a singleton and the embedder holds the unique
reference to the shell.
* Shell setup and teardown is deterministic.
* Threads are no longer managed by the shell. Instead, the shell is
given a task runner configuration by the embedder.
* Since the shell does not own its threads, the embedder can control
threads and the message loops operating on these threads. The shell is
only given references to the task runners that execute tasks on these
threads.
* The shell only needs task runner references. These references can be
to the same task runner. So, if the embedder thinks that a particular
Flutter application would not need all the threads, it can pass
references to the same task runner. This effectively makes Flutter
application run in single threaded mode. There are some places in the
shell that make synchronous calls, these sites have been updated to
ensure that they don’t deadlock.
* The test runner and the headless Dart code runner are now Flutter
applications that are effectively single threaded (since they don’t
have rendering concerns of big-boy Flutter application).
* The embedder has to guarantee that the threads and outlive the shell.
It is easy for the embedder to make that guarantee because shell
termination is deterministic.
* The embedder can create as many shell as it wants. Typically it
creates a shell per Flutter application with its own task runner
configuration. Most embedders obtain these task runners from threads
dedicated to the shell. But, it is entirely possible that the embedder
can obtain these task runners from a thread pool.
* There can only be one Dart VM in the process. The numerous shell
interact with one another to manage the VM lifecycle. Once the last
shell goes away, the VM does as well and hence all resources
associated with the VM are collected.
* The shell as a target can now compile and run on Fuchsia. The current
content handler has been removed from the Flutter engine source tree
and a new implementation has been written that uses the new shell
target.
* Isolate management has been significantly overhauled. There are no
owning references to Dart isolates within the shell. The VM owns the
only strong reference to the Dart isolate. The isolate that has window
bindings is now called the root isolate. Child isolates can now be
created from the root isolate and their bindings and thread
configurations are now inherited from the root isolate.
* Terminating the shell terminates its root isolates as well as all the
isolates spawned by this isolate. This is necessary be shell shutdown
is deterministic and the embedder is free to collect the threads on
which the isolates execute their tasks (and listen for mircrotasks
flushes on).
* Launching the root isolate is now significantly overhauled. The shell
side (non-owning) reference to an isolate is now a little state
machine and illegal state transitions should be impossible (barring
construction issues). This is the only way to manage Dart isolates in
the shell (the shell does not use the C API is dart_api.h anymore).
* Once an isolate is launched, it must be prepared (and hence move to
the ready phase) by associating a snapshot with the same. This
snapshot can either be a precompiled snapshot, kernel snapshot, script
snapshot or source file. Depending on the kind of data specified as a
snapshot as well as the capabilities of the VM running in the process,
isolate preparation can fail preparation with the right message.
* Asset management has been significantly overhauled. All asset
resolution goes through an abstract asset resolver interface. An asset
manager implements this interface and manages one or more child asset
resolvers. These asset resolvers typically resolve assets from
directories, ZIP files (legacy FLX assets if provided), APK bundles,
FDIO namespaces, etc…
* Each launch of the shell requires a separate and fully configured
asset resolver. This is necessary because launching isolates for the
engine may require resolving snapshots as assets from the asset
resolver. Asset resolvers can be shared by multiple launch instances
in multiple shells and need to be thread safe.
* References to the command line object have been removed from the
shell. Instead, the shell only takes a settings object that may be
configured from the command line. This makes it easy for embedders and
platforms that don’t have a command line (Fuchsia) to configure the
shell. Consequently, there is only one spot where the various switches
are read from the command line (by the embedder and not the shell) to
form the settings object.
* All platform now respect the log tag (this was done only by Android
till now) and each shell instance have its own log tag. This makes
logs from multiple Flutter application in the same process (mainly
Fuchsia) more easily decipherable.
* The per shell IO task runner now has a new component that is
unfortunately named the IOManager. This component manages the IO
GrContext (used for asynchronous texture uploads) that cooperates with
the GrContext on the GPU task runner associated with the shell. The
IOManager is also responsible for flushing tasks that collect Skia
objects that reference GPU resources during deterministic shell
shutdown.
* The embedder now has to be careful to only enable Blink on a single
instance of the shell. Launching the legacy text layout and rendering
engine multiple times is will trip assertions. The entirety of this
runtime has been separated out into a separate object and can be
removed in one go when the migration to libtxt is complete.
* There is a new test target for the various C++ objects that the shell
uses to interact with the Dart VM (the shell no longer use the C API
in dart_api.h). This allows engine developers to test VM/Isolate
initialization and teardown without having the setup a full shell
instance.
* There is a new test target for the testing a single shell instances
without having to configure and launch an entire VM and associated
root isolate.
* Mac, Linux & Windows used to have different target that created the
flutter_tester referenced by the tool. This has now been converted
into a single target that compiles on all platforms.
* WeakPointers vended by the fml::WeakPtrFactory(notice the difference
between the same class in the fxl namespace) add threading checks on
each use. This is enabled by getting rid of the “re-origination”
feature of the WeakPtrFactory in the fxl namespace. The side effect of
this is that all non-thread safe components have to be created, used
and destroyed on the same thread. Numerous thread safety issues were
caught by this extra assertion and have now been fixed.
* Glossary of components that are only safe on a specific thread (and
have the fml variants of the WeakPtrFactory):
* Platform Thread: Shell
* UI Thread: Engine, RuntimeDelegate, DartIsolate, Animator
* GPU Thread: Rasterizer, Surface
* IO Thread: IOManager
This patch was reviewed in smaller chunks in the following pull
requests. All comments from the pulls requests has been incorporated
into this patch:
* flutter/assets: flutter#4829
* flutter/common: flutter#4830
* flutter/content_handler: flutter#4831
* flutter/flow: flutter#4832
* flutter/fml: flutter#4833
* flutter/lib/snapshot: flutter#4834
* flutter/lib/ui: flutter#4835
* flutter/runtime: flutter#4836
* flutter/shell: flutter#4837
* flutter/synchronization: flutter#4838
* flutter/testing: flutter#4839
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This changes is part of a large patch for easier review. Try the whole patch in one go by checking out https://github.com/chinmaygarde/flutter_engine/tree/shell directly. This patch contains the following changes: