Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Support multiple shells in a single process. #4932

Merged
merged 2 commits into from Apr 10, 2018

Conversation

Projects
None yet
5 participants
@chinmaygarde
Copy link
Member

commented 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:

@googlebot googlebot added the cla: yes label Apr 4, 2018

@rmacnak-google

This comment has been minimized.

Copy link
Contributor

commented Apr 4, 2018

Dart LGTM

@jason-simmons

This comment has been minimized.

Copy link
Contributor

commented Apr 4, 2018

LGTM!

@chinmaygarde

This comment has been minimized.

Copy link
Member Author

commented Apr 4, 2018

I don't understand why the license script is still mad.

@Hixie

This comment has been minimized.

Copy link
Contributor

commented Apr 5, 2018

Horrah!

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

@chinmaygarde chinmaygarde force-pushed the chinmaygarde:shell branch from 001150b to 5d75e81 Apr 10, 2018

@chinmaygarde

This comment has been minimized.

Copy link
Member Author

commented Apr 10, 2018

I have verified all target I can think of. This is good to land now.

@Hixie

This comment has been minimized.

Copy link
Contributor

commented Apr 10, 2018

You'll have to rerun the license script because we've landed some stuff since you ran it.

But once that's done... land away!

@chinmaygarde chinmaygarde merged commit 6baff4c into flutter:master Apr 10, 2018

2 checks passed

cla/google All necessary CLAs are signed
continuous-integration/travis-ci/pr The Travis CI build passed
Details

chinmaygarde added a commit that referenced this pull request Apr 10, 2018

chinmaygarde added a commit that referenced this pull request Apr 10, 2018

chinmaygarde added a commit to chinmaygarde/flutter_engine that referenced this pull request Apr 11, 2018

chinmaygarde added a commit to chinmaygarde/flutter_engine that referenced this pull request Apr 11, 2018

chinmaygarde added a commit that referenced this pull request Apr 11, 2018

mraleph added a commit that referenced this pull request Apr 12, 2018

mraleph added a commit that referenced this pull request Apr 12, 2018

chinmaygarde added a commit to chinmaygarde/flutter_engine that referenced this pull request Apr 13, 2018

chinmaygarde added a commit that referenced this pull request Apr 13, 2018

Re-land "Support multiple shells in a single process. (#4932)" (#4998)
* Re-land "Support multiple shells in a single process. (#4932)"

This reverts commit 723c7d0.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.