[complier] Enable parallel eager inner function compilation with compiler dispatcher.

src/compiler-dispatcher/compiler-dispatcher-tracer.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_TRACER_H_
 #define V8_COMPILER_DISPATCHER_COMPILER_DISPATCHER_TRACER_H_
 
 #include <utility>
 
 #include "src/base/macros.h"
@@ skipping 17 matching lines @@
 
 #define COMPILER_DISPATCHER_TRACE_SCOPE(tracer, scope_id) \
   COMPILER_DISPATCHER_TRACE_SCOPE_WITH_NUM(tracer, scope_id, 0)
 
 class V8_EXPORT_PRIVATE CompilerDispatcherTracer {
  public:
   enum class ScopeID {
     kPrepareToParse,
     kParse,
     kFinalizeParsing,
+    kAnalyze,
     kPrepareToCompile,
     kCompile,
     kFinalizeCompiling
   };
 
   class Scope {
    public:
     Scope(CompilerDispatcherTracer* tracer, ScopeID scope_id, size_t num = 0);
     ~Scope();
 
     static const char* Name(ScopeID scoped_id);
 
    private:
     CompilerDispatcherTracer* tracer_;
     ScopeID scope_id_;
     size_t num_;
     double start_time_;
 
     DISALLOW_COPY_AND_ASSIGN(Scope);
   };
 
   explicit CompilerDispatcherTracer(Isolate* isolate);
   ~CompilerDispatcherTracer();
 
   void RecordPrepareToParse(double duration_ms);
   void RecordParse(double duration_ms, size_t source_length);
   void RecordFinalizeParsing(double duration_ms);
+  void RecordAnalyze(double duration_ms);
   void RecordPrepareToCompile(double duration_ms);
   void RecordCompile(double duration_ms, size_t ast_size_in_bytes);
   void RecordFinalizeCompiling(double duration_ms);
 
   double EstimatePrepareToParseInMs() const;
   double EstimateParseInMs(size_t source_length) const;
   double EstimateFinalizeParsingInMs() const;
+  double EstimateAnalyzeInMs() const;
   double EstimatePrepareToCompileInMs() const;
   double EstimateCompileInMs(size_t ast_size_in_bytes) const;
   double EstimateFinalizeCompilingInMs() const;
 
   void DumpStatistics() const;
 
  private:
   static double Average(const base::RingBuffer<double>& buffer);
   static double Estimate(
       const base::RingBuffer<std::pair<size_t, double>>& buffer, size_t num);
 
   mutable base::Mutex mutex_;
   base::RingBuffer<double> prepare_parse_events_;
   base::RingBuffer<std::pair<size_t, double>> parse_events_;
   base::RingBuffer<double> finalize_parsing_events_;
+  base::RingBuffer<double> analyze_events_;
   base::RingBuffer<double> prepare_compile_events_;
   base::RingBuffer<std::pair<size_t, double>> compile_events_;
   base::RingBuffer<double> finalize_compiling_events_;
 
   RuntimeCallStats* runtime_call_stats_;
 
   DISALLOW_COPY_AND_ASSIGN(CompilerDispatcherTracer);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_DISPATCHER_COMPILER_DISPATCHER_TRACER_H_