Add a basic compiler dispatcher

src/compiler-dispatcher/compiler-dispatcher.cc

+// Copyright 2016 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/compiler-dispatcher/compiler-dispatcher.h"
+
+#include "src/compiler-dispatcher/compiler-dispatcher-job.h"
+#include "src/compiler-dispatcher/compiler-dispatcher-tracer.h"
+#include "src/objects-inl.h"
+
+namespace v8 {
+namespace internal {
+
+CompilerDispatcher::CompilerDispatcher(Isolate* isolate, size_t max_stack_size)
+    : isolate_(isolate),
+      max_stack_size_(max_stack_size),
+      tracer_(new CompilerDispatcherTracer(isolate_)) {}
+
+CompilerDispatcher::~CompilerDispatcher() {}
+
+bool CompilerDispatcher::Enqueue(Handle<SharedFunctionInfo> function) {
+  DCHECK(function->script()->IsScript());
+  if (IsEnqueued(function)) return true;
+  std::unique_ptr<CompilerDispatcherJob> job(new CompilerDispatcherJob(

[marja, 2016/12/12 09:00:02]

Nit: no need to construct job if we do the early return based on the key. (But
this comment is hopefully obsolete bc of the next comment.)

+      isolate_, tracer_.get(), function, max_stack_size_));
+  std::pair<int, int> key(Script::cast(function->script())->id(),
+                          function->function_literal_id());
+  // Script::id() is not guaranteed to be unique, so even if the function isn't
+  // enqueued, we might not be able to enqueue it.

[marja, 2016/12/12 09:00:02]

Hmm, this is weird. So we cannot enqueue things because we're not able to assign
unique IDs for them?

So we need to store the jobs so that they're searchable by keys... but is there
anything preventing us from having multiple jobs with the same key, if we have a
data structure that supports that? E.g., do we always have the
SharedFunctionInfo available that we can check for real equality (not just
equality of the IDs) when we need to.

(I guess we need to check the real equality anyway, since the IDs are not
unique, so if we later check stuff like "is this function in the queue", it's
not enough to check based on IDs. So it should work.)

[rmcilroy, 2016/12/12 09:50:39]

Also, does this mean we are only able to enqueue one function per script at a
time? This seems like a limitation we'd want to avoid if we want to be able to
compile in parallel. +1 to Marja's suggestion.

[marja, 2016/12/12 09:54:59]

I don't think it means that, since the key is the (script id, function id) pair.

[rmcilroy, 2016/12/12 10:08:30]

Ahh right enough, I was thinking the pair was for the insert.

[jochen (gone - plz use gerrit), 2016/12/12 10:51:17]

done

+  if (jobs_.find(key) != jobs_.end()) return false;
+  jobs_.insert(std::make_pair(key, std::move(job)));
+  return true;
+}
+
+bool CompilerDispatcher::IsEnqueued(Handle<SharedFunctionInfo> function) const {
+  if (!function->script()->IsScript()) return false;
+  std::pair<int, int> key(Script::cast(function->script())->id(),
+                          function->function_literal_id());
+  auto job = jobs_.find(key);
+  if (job == jobs_.end()) return false;
+  return job->second->IsProcessing(function);
+}
+
+bool CompilerDispatcher::FinishNow(Handle<SharedFunctionInfo> function) {
+  if (!IsEnqueued(function)) return false;
+  std::pair<int, int> key(Script::cast(function->script())->id(),

[marja, 2016/12/12 09:00:02]

How about having a job-finding helper function - it's confusing that the
ID-based check is not enough? Also, this code does find twice (first in
IsEnqueued and then here), that's unnecessary.

(In the version I suggest a helper function would also make it clearer.)

[jochen (gone - plz use gerrit), 2016/12/12 10:51:17]

done

+                          function->function_literal_id());
+  auto job = jobs_.find(key);
+
+  // TODO(jochen): Check if there's an in-flight background task working on this

[rmcilroy, 2016/12/12 09:50:39]

Could you DCHECK there is no background thread processing it until this TODO is
done?

[jochen (gone - plz use gerrit), 2016/12/12 10:51:17]

there's currently no way to check whether a job is running on a background
thread

+  // job.
+  while (!IsDone(job->second.get())) {
+    DoNextStepOnMainThread(job->second.get());
+  }
+  bool result = job->second->status() != CompileJobStatus::kFailed;
+  jobs_.erase(job);
+  return result;
+}
+
+void CompilerDispatcher::Abort(Handle<SharedFunctionInfo> function,
+                               BlockingBehavior blocking) {
+  USE(blocking);
+  if (!IsEnqueued(function)) return;

[marja, 2016/12/12 09:00:02]

Ditto

+  std::pair<int, int> key(Script::cast(function->script())->id(),
+                          function->function_literal_id());
+  auto job = jobs_.find(key);
+
+  // TODO(jochen): Check if there's an in-flight background task working on this

[rmcilroy, 2016/12/12 09:50:39]

Ditto (and below).

+  // job.
+  jobs_.erase(job);
+}
+
+void CompilerDispatcher::AbortAll(BlockingBehavior blocking) {
+  USE(blocking);
+  // TODO(jochen): Check if there's an in-flight background task working on this
+  // job.
+  jobs_.clear();
+}
+
+// static
+bool CompilerDispatcher::DoNextStepOnMainThread(CompilerDispatcherJob* job) {
+  switch (job->status()) {
+    case CompileJobStatus::kInitial:
+      job->PrepareToParseOnMainThread();
+      break;
+
+    case CompileJobStatus::kReadyToParse:
+      job->Parse();
+      break;
+
+    case CompileJobStatus::kParsed:
+      job->FinalizeParsingOnMainThread();
+      break;
+
+    case CompileJobStatus::kReadyToAnalyse:
+      job->PrepareToCompileOnMainThread();
+      break;
+
+    case CompileJobStatus::kReadyToCompile:
+      job->Compile();
+      break;
+
+    case CompileJobStatus::kCompiled:
+      job->FinalizeCompilingOnMainThread();
+      break;
+
+    case CompileJobStatus::kFailed:
+    case CompileJobStatus::kDone:
+      break;
+  }
+
+  return job->status() != CompileJobStatus::kFailed;
+}
+
+// static
+bool CompilerDispatcher::IsDone(CompilerDispatcherJob* job) {
+  return job->status() == CompileJobStatus::kDone ||
+         job->status() == CompileJobStatus::kFailed;
+}
+
+}  // namespace internal
+}  // namespace v8