Add a basic compiler dispatcher

src/compiler-dispatcher/compiler-dispatcher-job.h

 // 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.
 
 #ifndef V8_COMPILER_DISPATCHER_COMPILER_DISPATCHER_JOB_H_
 #define V8_COMPILER_DISPATCHER_COMPILER_DISPATCHER_JOB_H_
 
 #include <memory>
 
 #include "src/base/macros.h"
@@ skipping 22 matching lines @@
   kParsed,
   kReadyToAnalyse,
   kReadyToCompile,
   kCompiled,
   kFailed,
   kDone,
 };
 
 class V8_EXPORT_PRIVATE CompilerDispatcherJob {
  public:
-  CompilerDispatcherJob(Isolate* isolate, Handle<SharedFunctionInfo> shared,
+  CompilerDispatcherJob(Isolate* isolate, CompilerDispatcherTracer* tracer,
+                        Handle<SharedFunctionInfo> shared,
                         size_t max_stack_size);
   ~CompilerDispatcherJob();
 
   CompileJobStatus status() const { return status_; }
   bool can_parse_on_background_thread() const {
     return can_parse_on_background_thread_;
   }
   // Should only be called after kReadyToCompile.
   bool can_compile_on_background_thread() const {
     DCHECK(compile_job_.get());
     return can_compile_on_background_thread_;
   }
 
+  // Returns true if this CompilerDispatcherJob was created for the given
+  // function.
+  bool IsProcessing(Handle<SharedFunctionInfo> shared) const;

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

Naming nit: IsProcessing has a connotation that something is "in progress", and
it's not clear that IsProcessing is true after the compilation job has finished
too.

IsAssociatedWith?

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

Or how about just a getter which returns the SFI and do the equality check in
the caller?

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

that would require creating a new handle, as the member of the job is a global
handle, so we can't just return it

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

done

+
   // Transition from kInitial to kReadyToParse.
   void PrepareToParseOnMainThread();
 
   // Transition from kReadyToParse to kParsed.
   void Parse();
 
   // Transition from kParsed to kReadyToAnalyse (or kFailed). Returns false
   // when transitioning to kFailed. In that case, an exception is pending.
   bool FinalizeParsingOnMainThread();
 
@@ skipping 36 matching lines @@
   bool can_parse_on_background_thread_;
   bool can_compile_on_background_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(CompilerDispatcherJob);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_DISPATCHER_COMPILER_DISPATCHER_JOB_H_