Remove runtime-call-stats from compiler dispatcher

src/compiler-dispatcher/compiler-dispatcher-tracer.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-tracer.h"
 
 #include "src/isolate.h"
 
 namespace v8 {
 namespace internal {
 
 namespace {
 
 double MonotonicallyIncreasingTimeInMs() {
   return V8::GetCurrentPlatform()->MonotonicallyIncreasingTime() *
          static_cast<double>(base::Time::kMillisecondsPerSecond);
 }
 
 const double kEstimatedRuntimeWithoutData = 1.0;
 
 }  // namespace
 
 CompilerDispatcherTracer::Scope::Scope(CompilerDispatcherTracer* tracer,
                                        ScopeID scope_id, size_t num)
     : tracer_(tracer), scope_id_(scope_id), num_(num) {
   start_time_ = MonotonicallyIncreasingTimeInMs();
-  // TODO(cbruni): remove once we fully moved to a trace-based system.
-  if (V8_UNLIKELY(FLAG_runtime_stats)) {
-    RuntimeCallStats::Enter(tracer_->runtime_call_stats_, &timer_,
-                            &RuntimeCallStats::CompilerDispatcher);
-  }
 }
 
 CompilerDispatcherTracer::Scope::~Scope() {
   double elapsed = MonotonicallyIncreasingTimeInMs() - start_time_;
   switch (scope_id_) {
     case ScopeID::kPrepareToParse:
       tracer_->RecordPrepareToParse(elapsed);
       break;
     case ScopeID::kParse:
       tracer_->RecordParse(elapsed, num_);
       break;
     case ScopeID::kFinalizeParsing:
       tracer_->RecordFinalizeParsing(elapsed);
       break;
     case ScopeID::kPrepareToCompile:
       tracer_->RecordPrepareToCompile(elapsed);
       break;
     case ScopeID::kCompile:
       tracer_->RecordCompile(elapsed, num_);
       break;
     case ScopeID::kFinalizeCompiling:
       tracer_->RecordFinalizeCompiling(elapsed);
       break;
   }
-  // TODO(cbruni): remove once we fully moved to a trace-based system.
-  if (V8_UNLIKELY(FLAG_runtime_stats)) {
-    RuntimeCallStats::Leave(tracer_->runtime_call_stats_, &timer_);
-  }
 }
 
 // static
 const char* CompilerDispatcherTracer::Scope::Name(ScopeID scope_id) {
   switch (scope_id) {
     case ScopeID::kPrepareToParse:
       return "V8.BackgroundCompile_PrepareToParse";
     case ScopeID::kParse:
       return "V8.BackgroundCompile_Parse";
     case ScopeID::kFinalizeParsing:
@@ skipping 95 matching lines @@
   std::pair<size_t, double> sum = buffer.Sum(
       [](std::pair<size_t, double> a, std::pair<size_t, double> b) {
         return std::make_pair(a.first + b.first, a.second + b.second);
       },
       std::make_pair(0, 0.0));
   return num * (sum.second / sum.first);
 }
 
 }  // namespace internal
 }  // namespace v8