blob: 9bd5f068c4c6cca33ed1732a06a96b10a3c2d566 [file] [log] [blame] [edit]
// Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
#ifndef RUNTIME_BIN_ISOLATE_DATA_H_
#define RUNTIME_BIN_ISOLATE_DATA_H_
#include <memory>
#include <utility>
#include "include/dart_api.h"
#include "platform/assert.h"
#include "platform/globals.h"
#include "platform/growable_array.h"
#include "platform/utils.h"
namespace dart {
// Forward declaration.
template <typename T>
class MallocGrowableArray;
} // namespace dart
namespace dart {
namespace bin {
// Forward declaration.
class AppSnapshot;
class EventHandler;
class Loader;
// Data associated with every isolate group in the standalone VM
// embedding. This is used to free external resources for each isolate
// group when the isolate group shuts down.
class IsolateGroupData {
public:
IsolateGroupData(const char* url,
const char* packages_file,
AppSnapshot* app_snapshot,
bool isolate_run_app_snapshot);
~IsolateGroupData();
char* script_url;
const std::shared_ptr<uint8_t>& kernel_buffer() const {
return kernel_buffer_;
}
intptr_t kernel_buffer_size() const { return kernel_buffer_size_; }
// Associate the given kernel buffer with this IsolateGroupData without
// giving it ownership of the buffer.
void SetKernelBufferUnowned(uint8_t* buffer, intptr_t size) {
ASSERT(kernel_buffer_.get() == nullptr);
kernel_buffer_ = std::shared_ptr<uint8_t>(buffer, FreeUnownedKernelBuffer);
kernel_buffer_size_ = size;
}
// Associate the given kernel buffer with this IsolateGroupData and give it
// ownership of the buffer. This IsolateGroupData is the first one to own the
// buffer.
void SetKernelBufferNewlyOwned(uint8_t* buffer, intptr_t size) {
ASSERT(kernel_buffer_.get() == nullptr);
kernel_buffer_ = std::shared_ptr<uint8_t>(buffer, free);
kernel_buffer_size_ = size;
}
// Associate the given kernel buffer with this IsolateGroupData and give it
// ownership of the buffer. The buffer is already owned by another
// IsolateGroupData.
void SetKernelBufferAlreadyOwned(std::shared_ptr<uint8_t> buffer,
intptr_t size) {
ASSERT(kernel_buffer_.get() == nullptr);
kernel_buffer_ = std::move(buffer);
kernel_buffer_size_ = size;
}
const char* resolved_packages_config() const {
return resolved_packages_config_;
}
void set_resolved_packages_config(const char* packages_config) {
if (resolved_packages_config_ != nullptr) {
free(resolved_packages_config_);
resolved_packages_config_ = nullptr;
}
resolved_packages_config_ = Utils::StrDup(packages_config);
}
bool RunFromAppSnapshot() const {
// If the main isolate is using an app snapshot the [app_snapshot_] pointer
// will be still nullptr (see main.cc:CreateIsolateGroupAndSetupHelper)
//
// Because of thus we have an additional boolean signaling whether the
// isolate was started from an app snapshot.
return app_snapshot_ != nullptr || isolate_run_app_snapshot_;
}
void AddLoadingUnit(AppSnapshot* loading_unit) {
loading_units_.Add(loading_unit);
}
private:
friend class IsolateData; // For packages_file_
std::unique_ptr<AppSnapshot> app_snapshot_;
MallocGrowableArray<AppSnapshot*> loading_units_;
char* resolved_packages_config_;
std::shared_ptr<uint8_t> kernel_buffer_;
intptr_t kernel_buffer_size_;
char* packages_file_ = nullptr;
bool isolate_run_app_snapshot_;
static void FreeUnownedKernelBuffer(uint8_t*) {}
DISALLOW_COPY_AND_ASSIGN(IsolateGroupData);
};
// Data associated with every isolate in the standalone VM
// embedding. This is used to free external resources for each isolate
// when the isolate shuts down.
class IsolateData {
public:
explicit IsolateData(IsolateGroupData* isolate_group_data);
~IsolateData();
IsolateGroupData* isolate_group_data() const { return isolate_group_data_; }
void UpdatePackagesFile(const char* packages_file) {
if (packages_file != nullptr) {
free(packages_file_);
packages_file_ = nullptr;
}
packages_file_ = Utils::StrDup(packages_file);
}
// While loading a loader is associated with the isolate.
bool HasLoader() const { return loader_ != nullptr; }
Loader* loader() const {
ASSERT(loader_ != nullptr);
return loader_;
}
void set_loader(Loader* loader) {
ASSERT((loader_ == nullptr) || (loader == nullptr));
loader_ = loader;
}
const char* packages_file() const { return packages_file_; }
private:
IsolateGroupData* isolate_group_data_;
Loader* loader_;
char* packages_file_;
DISALLOW_COPY_AND_ASSIGN(IsolateData);
};
} // namespace bin
} // namespace dart
#endif // RUNTIME_BIN_ISOLATE_DATA_H_