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.

Sign up for GitHub

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

Jump to bottom

deps: backport d727680 from V8 upstream #14947

Closed
wants to merge 2 commits into from
Closed

deps: backport d727680 from V8 upstream #14947

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
05f264e
deps: backport d727680 from V8 upstream
Aug 19, 2017
b12ec10
[SQUASH?] Fix compilation error
Aug 19, 2017
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
179 changes: 81 additions & 98 deletions deps/v8/src/d8.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -191,76 +191,65 @@ class MockArrayBufferAllocator : public ArrayBufferAllocatorBase {
}
};


// Predictable v8::Platform implementation. All background and foreground
// tasks are run immediately, delayed tasks are not executed at all.
// Predictable v8::Platform implementation. Background tasks and idle tasks are
// disallowed, and the time reported by {MonotonicallyIncreasingTime} is
// deterministic.
class PredictablePlatform : public Platform {
public:
PredictablePlatform() {}

void CallOnBackgroundThread(Task* task,
ExpectedRuntime expected_runtime) override {
task->Run();
delete task;
}

void CallOnForegroundThread(v8::Isolate* isolate, Task* task) override {
task->Run();
delete task;
}

void CallDelayedOnForegroundThread(v8::Isolate* isolate, Task* task,
double delay_in_seconds) override {
delete task;
}

void CallIdleOnForegroundThread(v8::Isolate* isolate,
IdleTask* task) override {
UNREACHABLE();
}

bool IdleTasksEnabled(v8::Isolate* isolate) override { return false; }

double MonotonicallyIncreasingTime() override {
return synthetic_time_in_sec_ += 0.00001;
}

v8::TracingController* GetTracingController() override {
return platform_->GetTracingController();
}

using Platform::AddTraceEvent;
uint64_t AddTraceEvent(char phase, const uint8_t* categoryEnabledFlag,
const char* name, const char* scope, uint64_t id,
uint64_t bind_id, int numArgs, const char** argNames,
const uint8_t* argTypes, const uint64_t* argValues,
unsigned int flags) override {
return 0;
}

void UpdateTraceEventDuration(const uint8_t* categoryEnabledFlag,
const char* name, uint64_t handle) override {}

const uint8_t* GetCategoryGroupEnabled(const char* name) override {
static uint8_t no = 0;
return &no;
}

const char* GetCategoryGroupName(
const uint8_t* categoryEnabledFlag) override {
static const char* dummy = "dummy";
return dummy;
}

private:
double synthetic_time_in_sec_ = 0.0;

DISALLOW_COPY_AND_ASSIGN(PredictablePlatform);
public:
explicit PredictablePlatform(std::unique_ptr<Platform> platform)
: platform_(std::move(platform)) {
DCHECK_NOT_NULL(platform_);
}

void CallOnBackgroundThread(Task* task,
ExpectedRuntime expected_runtime) override {
// It's not defined when background tasks are being executed, so we can just
// execute them right away.
task->Run();
delete task;
}

void CallOnForegroundThread(v8::Isolate* isolate, Task* task) override {
platform_->CallOnForegroundThread(isolate, task);
}

void CallDelayedOnForegroundThread(v8::Isolate* isolate, Task* task,
double delay_in_seconds) override {
platform_->CallDelayedOnForegroundThread(isolate, task, delay_in_seconds);
}

void CallIdleOnForegroundThread(Isolate* isolate, IdleTask* task) override {
UNREACHABLE();
}

bool IdleTasksEnabled(Isolate* isolate) override { return false; }

double MonotonicallyIncreasingTime() override {
return synthetic_time_in_sec_ += 0.00001;
}

v8::TracingController* GetTracingController() override {
return platform_->GetTracingController();
}

Platform* platform() const { return platform_.get(); }

private:
double synthetic_time_in_sec_ = 0.0;
std::unique_ptr<Platform> platform_;

DISALLOW_COPY_AND_ASSIGN(PredictablePlatform);
};


v8::Platform* g_platform = NULL;

v8::Platform* GetDefaultPlatform() {
return i::FLAG_verify_predictable
? static_cast<PredictablePlatform*>(g_platform)->platform()
: g_platform;
}

static Local<Value> Throw(Isolate* isolate, const char* message) {
return isolate->ThrowException(
String::NewFromUtf8(isolate, message, NewStringType::kNormal)
Expand Down Expand Up @@ -1389,8 +1378,6 @@ void Shell::Quit(const v8::FunctionCallbackInfo<v8::Value>& args) {
const_cast<v8::FunctionCallbackInfo<v8::Value>*>(&args));
}

// Note that both WaitUntilDone and NotifyDone are no-op when
// --verify-predictable. See comment in Shell::EnsureEventLoopInitialized.
void Shell::WaitUntilDone(const v8::FunctionCallbackInfo<v8::Value>& args) {
SetWaitUntilDone(args.GetIsolate(), true);
}
Expand Down Expand Up @@ -2767,13 +2754,8 @@ void Shell::CollectGarbage(Isolate* isolate) {
}

void Shell::EnsureEventLoopInitialized(Isolate* isolate) {
// When using PredictablePlatform (i.e. FLAG_verify_predictable),
// we don't need event loop support, because tasks are completed
// immediately - both background and foreground ones.
if (!i::FLAG_verify_predictable) {
v8::platform::EnsureEventLoopInitialized(g_platform, isolate);
SetWaitUntilDone(isolate, false);
}
v8::platform::EnsureEventLoopInitialized(GetDefaultPlatform(), isolate);
SetWaitUntilDone(isolate, false);
}

void Shell::SetWaitUntilDone(Isolate* isolate, bool value) {
Expand All @@ -2792,29 +2774,32 @@ bool Shell::IsWaitUntilDone(Isolate* isolate) {
}

void Shell::CompleteMessageLoop(Isolate* isolate) {
// See comment in EnsureEventLoopInitialized.
if (i::FLAG_verify_predictable) return;
Platform* platform = GetDefaultPlatform();
while (v8::platform::PumpMessageLoop(
g_platform, isolate,
platform, isolate,
Shell::IsWaitUntilDone(isolate)
? platform::MessageLoopBehavior::kWaitForWork
: platform::MessageLoopBehavior::kDoNotWait)) {
isolate->RunMicrotasks();
}
v8::platform::RunIdleTasks(g_platform, isolate,
50.0 / base::Time::kMillisecondsPerSecond);
if (platform->IdleTasksEnabled(isolate)) {
v8::platform::RunIdleTasks(platform, isolate,
50.0 / base::Time::kMillisecondsPerSecond);
}
}

void Shell::EmptyMessageQueues(Isolate* isolate) {
if (i::FLAG_verify_predictable) return;
Platform* platform = GetDefaultPlatform();
// Pump the message loop until it is empty.
while (v8::platform::PumpMessageLoop(
g_platform, isolate, platform::MessageLoopBehavior::kDoNotWait)) {
platform, isolate, platform::MessageLoopBehavior::kDoNotWait)) {
isolate->RunMicrotasks();
}
// Run the idle tasks.
v8::platform::RunIdleTasks(g_platform, isolate,
50.0 / base::Time::kMillisecondsPerSecond);
if (platform->IdleTasksEnabled(isolate)) {
v8::platform::RunIdleTasks(platform, isolate,
50.0 / base::Time::kMillisecondsPerSecond);
}
}

class Serializer : public ValueSerializer::Delegate {
Expand Down Expand Up @@ -3067,29 +3052,29 @@ int Shell::Main(int argc, char* argv[]) {
if (!SetOptions(argc, argv)) return 1;
v8::V8::InitializeICUDefaultLocation(argv[0], options.icu_data_file);

v8::platform::InProcessStackDumping in_process_stack_dumping =
options.disable_in_process_stack_traces
? v8::platform::InProcessStackDumping::kDisabled
: v8::platform::InProcessStackDumping::kEnabled;

g_platform = v8::platform::CreateDefaultPlatform(
0, v8::platform::IdleTaskSupport::kEnabled, in_process_stack_dumping);
if (i::FLAG_verify_predictable) {
g_platform = new PredictablePlatform(std::unique_ptr<Platform>(g_platform));
}

platform::tracing::TracingController* tracing_controller = nullptr;
if (options.trace_enabled) {
if (options.trace_enabled && !i::FLAG_verify_predictable) {
trace_file.open("v8_trace.json");
tracing_controller = new platform::tracing::TracingController();
platform::tracing::TraceBuffer* trace_buffer =
platform::tracing::TraceBuffer::CreateTraceBufferRingBuffer(
platform::tracing::TraceBuffer::kRingBufferChunks,
platform::tracing::TraceWriter::CreateJSONTraceWriter(trace_file));
tracing_controller->Initialize(trace_buffer);
platform::SetTracingController(g_platform, tracing_controller);
}

v8::platform::InProcessStackDumping in_process_stack_dumping =
options.disable_in_process_stack_traces
? v8::platform::InProcessStackDumping::kDisabled
: v8::platform::InProcessStackDumping::kEnabled;

g_platform = i::FLAG_verify_predictable
? new PredictablePlatform()
: v8::platform::CreateDefaultPlatform(
0, v8::platform::IdleTaskSupport::kEnabled,
in_process_stack_dumping,
tracing_controller);

v8::V8::InitializePlatform(g_platform);
v8::V8::Initialize();
if (options.natives_blob || options.snapshot_blob) {
Expand Down Expand Up @@ -3136,6 +3121,7 @@ int Shell::Main(int argc, char* argv[]) {
}

Isolate* isolate = Isolate::New(create_params);

D8Console console(isolate);
{
Isolate::Scope scope(isolate);
Expand Down Expand Up @@ -3205,9 +3191,6 @@ int Shell::Main(int argc, char* argv[]) {
V8::Dispose();
V8::ShutdownPlatform();
delete g_platform;
if (i::FLAG_verify_predictable) {
delete tracing_controller;
}

return result;
}
Expand Down
2 changes: 1 addition & 1 deletion deps/v8/src/heap/page-parallel-job.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -69,7 +69,7 @@ class PageParallelJob {
void Run(int num_tasks, Callback per_task_data_callback) {
if (num_items_ == 0) return;
DCHECK_GE(num_tasks, 1);
uint32_t task_ids[kMaxNumberOfTasks];
CancelableTaskManager::Id task_ids[kMaxNumberOfTasks];
const int max_num_tasks = Min(
kMaxNumberOfTasks,
static_cast<int>(
Expand Down
14 changes: 7 additions & 7 deletions deps/v8/src/libplatform/default-platform.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -47,25 +47,25 @@ v8::Platform* CreateDefaultPlatform(int thread_pool_size,

bool PumpMessageLoop(v8::Platform* platform, v8::Isolate* isolate,
MessageLoopBehavior behavior) {
return reinterpret_cast<DefaultPlatform*>(platform)->PumpMessageLoop(
isolate, behavior);
return static_cast<DefaultPlatform*>(platform)->PumpMessageLoop(isolate,
behavior);
}

void EnsureEventLoopInitialized(v8::Platform* platform, v8::Isolate* isolate) {
return reinterpret_cast<DefaultPlatform*>(platform)
->EnsureEventLoopInitialized(isolate);
return static_cast<DefaultPlatform*>(platform)->EnsureEventLoopInitialized(
isolate);
}

void RunIdleTasks(v8::Platform* platform, v8::Isolate* isolate,
double idle_time_in_seconds) {
reinterpret_cast<DefaultPlatform*>(platform)->RunIdleTasks(
isolate, idle_time_in_seconds);
static_cast<DefaultPlatform*>(platform)->RunIdleTasks(isolate,
idle_time_in_seconds);
}

void SetTracingController(
v8::Platform* platform,
v8::platform::tracing::TracingController* tracing_controller) {
return reinterpret_cast<DefaultPlatform*>(platform)->SetTracingController(
return static_cast<DefaultPlatform*>(platform)->SetTracingController(
tracing_controller);
}

Expand Down
23 changes: 6 additions & 17 deletions deps/v8/src/wasm/wasm-module.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2695,10 +2695,6 @@ void wasm::AsyncInstantiate(Isolate* isolate, Handle<JSPromise> promise,
// foreground task. All other tasks (e.g. decoding and validating, the majority
// of the work of compilation) can be background tasks.
// TODO(wasm): factor out common parts of this with the synchronous pipeline.
//
// Note: In predictable mode, DoSync and DoAsync execute the referenced function
// immediately before returning. Thus we handle the predictable mode specially,
// e.g. when we synchronizing tasks or when we delete the AyncCompileJob.
class AsyncCompileJob {
// TODO(ahaas): Fix https://bugs.chromium.org/p/v8/issues/detail?id=6263 to
// make sure that d8 does not shut down before the AsyncCompileJob is
Expand Down Expand Up @@ -2761,14 +2757,14 @@ class AsyncCompileJob {
RejectPromise(isolate_, context_, thrower, module_promise_);
// The AsyncCompileJob is finished, we resolved the promise, we do not need
// the data anymore. We can delete the AsyncCompileJob object.
if (!FLAG_verify_predictable) delete this;
delete this;
}

void AsyncCompileSucceeded(Handle<Object> result) {
ResolvePromise(isolate_, context_, module_promise_, result);
// The AsyncCompileJob is finished, we resolved the promise, we do not need
// the data anymore. We can delete the AsyncCompileJob object.
if (!FLAG_verify_predictable) delete this;
delete this;
}

enum TaskType { SYNC, ASYNC };
Expand Down Expand Up @@ -2975,9 +2971,7 @@ class AsyncCompileJob {
// TODO(ahaas): Limit the number of outstanding compilation units to be
// finished to reduce memory overhead.
}
// Special handling for predictable mode, see above.
if (!FLAG_verify_predictable)
job_->helper_->module_->pending_tasks.get()->Signal();
job_->helper_->module_->pending_tasks.get()->Signal();
}
};

Expand Down Expand Up @@ -3026,12 +3020,9 @@ class AsyncCompileJob {
// Bump next_unit_, such that background tasks stop processing the queue.
job_->helper_->next_unit_.SetValue(
job_->helper_->compilation_units_.size());
// Special handling for predictable mode, see above.
if (!FLAG_verify_predictable) {
for (size_t i = 0; i < job_->num_background_tasks_; ++i) {
// We wait for it to finish.
job_->helper_->module_->pending_tasks.get()->Wait();
}
for (size_t i = 0; i < job_->num_background_tasks_; ++i) {
// We wait for it to finish.
job_->helper_->module_->pending_tasks.get()->Wait();
}
if (thrower_.error()) {
job_->DoSync<FailCompile>(std::move(thrower_));
Expand Down Expand Up @@ -3194,8 +3185,6 @@ void wasm::AsyncCompile(Isolate* isolate, Handle<JSPromise> promise,
auto job = new AsyncCompileJob(isolate, std::move(copy), bytes.length(),
handle(isolate->context()), promise);
job->Start();
// Special handling for predictable mode, see above.
if (FLAG_verify_predictable) delete job;
}

Handle<Code> wasm::CompileLazy(Isolate* isolate) {
Expand Down