blob: 4903987a29788e1091b1e17d275472c64110ebc6 [file] [log] [blame] [edit]
// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef FLUTTER_RUNTIME_DART_VM_H_
#define FLUTTER_RUNTIME_DART_VM_H_
#include <memory>
#include <string>
#include "flutter/common/settings.h"
#include "flutter/fml/build_config.h"
#include "flutter/fml/closure.h"
#include "flutter/fml/macros.h"
#include "flutter/fml/memory/ref_counted.h"
#include "flutter/fml/memory/ref_ptr.h"
#include "flutter/fml/memory/weak_ptr.h"
#include "flutter/fml/message_loop.h"
#include "flutter/lib/ui/isolate_name_server/isolate_name_server.h"
#include "flutter/runtime/dart_isolate.h"
#include "flutter/runtime/dart_snapshot.h"
#include "flutter/runtime/dart_vm_data.h"
#include "flutter/runtime/service_protocol.h"
#include "flutter/runtime/skia_concurrent_executor.h"
#include "third_party/dart/runtime/include/dart_api.h"
namespace flutter {
//------------------------------------------------------------------------------
/// @brief Describes a running instance of the Dart VM. There may only be
/// one running instance of the Dart VM in the process at any given
/// time. The Dart VM may be created and destroyed on any thread.
/// Typically, the first Flutter shell instance running in the
/// process bootstraps the Dart VM in the process as it starts up.
/// This cost is borne on the platform task runner of that first
/// Flutter shell. When the last Flutter shell instance is
/// destroyed, the VM is destroyed as well if all shell instances
/// were launched with the `Settings::leak_vm` flag set to false. If
/// there is any shell launch in the process with `leak_vm` set to
/// true, the VM is never shut down in the process. When the VM is
/// shutdown, the cost of the shutdown is borne on the platform task
/// runner of the last shell instance to be shut down.
///
/// Due to threading considerations, callers may never create an
/// instance of the DartVM directly. All constructors to the DartVM
/// are private. Instead, all callers that need a running VM
/// reference need to access it via the `DartVMRef::Create` call.
/// This call returns a strong reference to the running VM if one
/// exists in the process already. If a running VM instance is not
/// available in the process, a new instance is created and a strong
/// reference returned to the callers. The DartVMRef::Create call
/// ensures that there are no data races during the creation or
/// shutdown of a Dart VM (since a VM may be created and destroyed
/// on any thread). Due to this behavior, all callers needing a
/// running VM instance must provide snapshots and VM settings
/// necessary to create a VM (even if they end up not being used).
///
/// In a running VM instance, the service isolate is launched by
/// default if the VM is configured to do so. All root isolates must
/// be launched and referenced explicitly.
class DartVM {
public:
~DartVM();
//----------------------------------------------------------------------------
/// @brief Checks if VM instances in the process can run precompiled
/// code. This call can be made at any time and does not depend on
/// a running VM instance. There are no threading restrictions.
///
/// @return If VM instances in the process run precompiled code.
///
static bool IsRunningPrecompiledCode();
//----------------------------------------------------------------------------
/// @brief The number of times the VM has been launched in the process.
/// This call is inherently racy because the VM could be in the
/// process of starting up on another thread between the time the
/// caller makes this call and uses to result. For this purpose,
/// this call is only meant to be used as a debugging aid and
/// primarily only used in tests where the threading model is
/// consistent.
///
/// @return The number of times the VM has been launched.
///
static size_t GetVMLaunchCount();
//----------------------------------------------------------------------------
/// @brief The settings used to launch the running VM instance.
///
/// @attention Even though all callers that need to acquire a strong
/// reference to a VM need to provide a valid settings object, the
/// VM will only reference the settings used by the first caller
/// that bootstraps the VM in the process.
///
/// @return A valid setting object.
///
const Settings& GetSettings() const;
//----------------------------------------------------------------------------
/// @brief The VM and isolate snapshots used by this running Dart VM
/// instance.
///
/// @return A valid VM data instance.
///
std::shared_ptr<const DartVMData> GetVMData() const;
//----------------------------------------------------------------------------
/// @brief The service protocol instance associated with this running
/// Dart VM instance. This object manages native handlers for
/// engine vended service protocol methods.
///
/// @return The service protocol for this Dart VM instance.
///
std::shared_ptr<ServiceProtocol> GetServiceProtocol() const;
//----------------------------------------------------------------------------
/// @brief The isolate name server for this running VM instance. The
/// isolate name server maps names (strings) to Dart ports.
/// Running isolates can discover and communicate with each other
/// by advertising and resolving ports at well known names.
///
/// @return The isolate name server.
///
std::shared_ptr<IsolateNameServer> GetIsolateNameServer() const;
//----------------------------------------------------------------------------
/// @brief The task runner whose tasks may be executed concurrently on a
/// pool of worker threads. All subsystems within a running shell
/// instance use this worker pool for their concurrent tasks. This
/// also means that the concurrent worker pool may service tasks
/// from multiple shell instances. The number of workers in a
/// concurrent worker pool depends on the hardware concurrency
/// of the target device (usually equal to the number of logical
/// CPU cores).
///
///
/// @attention Even though concurrent task queue is associated with a running
/// Dart VM instance, the worker pool used by the Flutter engine
/// is NOT shared with the Dart VM internal worker pool. The
/// presence of this worker pool as member of the Dart VM is
/// merely to utilize the strong thread safety guarantees around
/// Dart VM lifecycle for the lifecycle of the concurrent worker
/// pool as well.
///
/// @return The task runner for the concurrent worker thread pool.
///
std::shared_ptr<fml::ConcurrentTaskRunner> GetConcurrentWorkerTaskRunner()
const;
//----------------------------------------------------------------------------
/// @brief The concurrent message loop hosts threads that are used by the
/// engine to perform tasks long running background tasks.
/// Typically, to post tasks to this message loop, the
/// `GetConcurrentWorkerTaskRunner` method may be used.
///
/// @see GetConcurrentWorkerTaskRunner
///
/// @return The concurrent message loop used by this running Dart VM
/// instance.
///
std::shared_ptr<fml::ConcurrentMessageLoop> GetConcurrentMessageLoop();
private:
const Settings settings_;
std::shared_ptr<fml::ConcurrentMessageLoop> concurrent_message_loop_;
SkiaConcurrentExecutor skia_concurrent_executor_;
std::shared_ptr<const DartVMData> vm_data_;
const std::shared_ptr<IsolateNameServer> isolate_name_server_;
const std::shared_ptr<ServiceProtocol> service_protocol_;
friend class DartVMRef;
friend class DartIsolate;
static std::shared_ptr<DartVM> Create(
const Settings& settings,
fml::RefPtr<const DartSnapshot> vm_snapshot,
fml::RefPtr<const DartSnapshot> isolate_snapshot,
std::shared_ptr<IsolateNameServer> isolate_name_server);
DartVM(const std::shared_ptr<const DartVMData>& data,
std::shared_ptr<IsolateNameServer> isolate_name_server);
FML_DISALLOW_COPY_AND_ASSIGN(DartVM);
};
} // namespace flutter
#endif // FLUTTER_RUNTIME_DART_VM_H_