LCOV - code coverage report
Current view: top level - src/compiler-dispatcher - compiler-dispatcher-tracer.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 86 98 87.8 %
Date: 2017-04-26 Functions: 21 23 91.3 %

          Line data    Source code
       1             : // Copyright 2016 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #include "src/compiler-dispatcher/compiler-dispatcher-tracer.h"
       6             : 
       7             : #include "src/isolate.h"
       8             : #include "src/utils.h"
       9             : 
      10             : namespace v8 {
      11             : namespace internal {
      12             : 
      13             : namespace {
      14             : 
      15         374 : double MonotonicallyIncreasingTimeInMs() {
      16         374 :   return V8::GetCurrentPlatform()->MonotonicallyIncreasingTime() *
      17         374 :          static_cast<double>(base::Time::kMillisecondsPerSecond);
      18             : }
      19             : 
      20             : const double kEstimatedRuntimeWithoutData = 1.0;
      21             : 
      22             : }  // namespace
      23             : 
      24         187 : CompilerDispatcherTracer::Scope::Scope(CompilerDispatcherTracer* tracer,
      25             :                                        ScopeID scope_id, size_t num)
      26         187 :     : tracer_(tracer), scope_id_(scope_id), num_(num) {
      27         187 :   start_time_ = MonotonicallyIncreasingTimeInMs();
      28         187 : }
      29             : 
      30         187 : CompilerDispatcherTracer::Scope::~Scope() {
      31         187 :   double elapsed = MonotonicallyIncreasingTimeInMs() - start_time_;
      32         187 :   switch (scope_id_) {
      33             :     case ScopeID::kPrepareToParse:
      34          28 :       tracer_->RecordPrepareToParse(elapsed);
      35          28 :       break;
      36             :     case ScopeID::kParse:
      37          28 :       tracer_->RecordParse(elapsed, num_);
      38          28 :       break;
      39             :     case ScopeID::kFinalizeParsing:
      40          27 :       tracer_->RecordFinalizeParsing(elapsed);
      41          27 :       break;
      42             :     case ScopeID::kAnalyze:
      43          26 :       tracer_->RecordAnalyze(elapsed);
      44          26 :       break;
      45             :     case ScopeID::kPrepareToCompile:
      46          29 :       tracer_->RecordPrepareToCompile(elapsed);
      47          29 :       break;
      48             :     case ScopeID::kCompile:
      49          25 :       tracer_->RecordCompile(elapsed, num_);
      50          25 :       break;
      51             :     case ScopeID::kFinalizeCompiling:
      52          24 :       tracer_->RecordFinalizeCompiling(elapsed);
      53          24 :       break;
      54             :   }
      55         187 : }
      56             : 
      57             : // static
      58           0 : const char* CompilerDispatcherTracer::Scope::Name(ScopeID scope_id) {
      59           0 :   switch (scope_id) {
      60             :     case ScopeID::kPrepareToParse:
      61             :       return "V8.BackgroundCompile_PrepareToParse";
      62             :     case ScopeID::kParse:
      63           0 :       return "V8.BackgroundCompile_Parse";
      64             :     case ScopeID::kFinalizeParsing:
      65           0 :       return "V8.BackgroundCompile_FinalizeParsing";
      66             :     case ScopeID::kAnalyze:
      67           0 :       return "V8.BackgroundCompile_Analyze";
      68             :     case ScopeID::kPrepareToCompile:
      69           0 :       return "V8.BackgroundCompile_PrepareToCompile";
      70             :     case ScopeID::kCompile:
      71           0 :       return "V8.BackgroundCompile_Compile";
      72             :     case ScopeID::kFinalizeCompiling:
      73           0 :       return "V8.BackgroundCompile_FinalizeCompiling";
      74             :   }
      75           0 :   UNREACHABLE();
      76             :   return nullptr;
      77             : }
      78             : 
      79      121639 : CompilerDispatcherTracer::CompilerDispatcherTracer(Isolate* isolate)
      80      121642 :     : runtime_call_stats_(nullptr) {
      81             :   // isolate might be nullptr during unittests.
      82       60821 :   if (isolate) {
      83       60818 :     runtime_call_stats_ = isolate->counters()->runtime_call_stats();
      84             :   }
      85       60821 : }
      86             : 
      87       59324 : CompilerDispatcherTracer::~CompilerDispatcherTracer() {}
      88             : 
      89          31 : void CompilerDispatcherTracer::RecordPrepareToParse(double duration_ms) {
      90          31 :   base::LockGuard<base::Mutex> lock(&mutex_);
      91             :   prepare_parse_events_.Push(duration_ms);
      92          31 : }
      93             : 
      94          31 : void CompilerDispatcherTracer::RecordParse(double duration_ms,
      95             :                                            size_t source_length) {
      96          31 :   base::LockGuard<base::Mutex> lock(&mutex_);
      97          31 :   parse_events_.Push(std::make_pair(source_length, duration_ms));
      98          31 : }
      99             : 
     100          27 : void CompilerDispatcherTracer::RecordFinalizeParsing(double duration_ms) {
     101          27 :   base::LockGuard<base::Mutex> lock(&mutex_);
     102             :   finalize_parsing_events_.Push(duration_ms);
     103          27 : }
     104             : 
     105          26 : void CompilerDispatcherTracer::RecordAnalyze(double duration_ms) {
     106          26 :   base::LockGuard<base::Mutex> lock(&mutex_);
     107             :   analyze_events_.Push(duration_ms);
     108          26 : }
     109             : 
     110          29 : void CompilerDispatcherTracer::RecordPrepareToCompile(double duration_ms) {
     111          29 :   base::LockGuard<base::Mutex> lock(&mutex_);
     112             :   prepare_compile_events_.Push(duration_ms);
     113          29 : }
     114             : 
     115          31 : void CompilerDispatcherTracer::RecordCompile(double duration_ms,
     116             :                                              size_t ast_size_in_bytes) {
     117          31 :   base::LockGuard<base::Mutex> lock(&mutex_);
     118          31 :   compile_events_.Push(std::make_pair(ast_size_in_bytes, duration_ms));
     119          31 : }
     120             : 
     121          24 : void CompilerDispatcherTracer::RecordFinalizeCompiling(double duration_ms) {
     122          24 :   base::LockGuard<base::Mutex> lock(&mutex_);
     123             :   finalize_compiling_events_.Push(duration_ms);
     124          24 : }
     125             : 
     126          15 : double CompilerDispatcherTracer::EstimatePrepareToParseInMs() const {
     127          15 :   base::LockGuard<base::Mutex> lock(&mutex_);
     128          30 :   return Average(prepare_parse_events_);
     129             : }
     130             : 
     131          17 : double CompilerDispatcherTracer::EstimateParseInMs(size_t source_length) const {
     132          17 :   base::LockGuard<base::Mutex> lock(&mutex_);
     133          34 :   return Estimate(parse_events_, source_length);
     134             : }
     135             : 
     136          13 : double CompilerDispatcherTracer::EstimateFinalizeParsingInMs() const {
     137          13 :   base::LockGuard<base::Mutex> lock(&mutex_);
     138          26 :   return Average(finalize_parsing_events_);
     139             : }
     140             : 
     141          12 : double CompilerDispatcherTracer::EstimateAnalyzeInMs() const {
     142          12 :   base::LockGuard<base::Mutex> lock(&mutex_);
     143          24 :   return Average(analyze_events_);
     144             : }
     145             : 
     146          15 : double CompilerDispatcherTracer::EstimatePrepareToCompileInMs() const {
     147          15 :   base::LockGuard<base::Mutex> lock(&mutex_);
     148          30 :   return Average(prepare_compile_events_);
     149             : }
     150             : 
     151          16 : double CompilerDispatcherTracer::EstimateCompileInMs(
     152             :     size_t ast_size_in_bytes) const {
     153          16 :   base::LockGuard<base::Mutex> lock(&mutex_);
     154          32 :   return Estimate(compile_events_, ast_size_in_bytes);
     155             : }
     156             : 
     157          11 : double CompilerDispatcherTracer::EstimateFinalizeCompilingInMs() const {
     158          11 :   base::LockGuard<base::Mutex> lock(&mutex_);
     159          22 :   return Average(finalize_compiling_events_);
     160             : }
     161             : 
     162           0 : void CompilerDispatcherTracer::DumpStatistics() const {
     163             :   PrintF(
     164             :       "CompilerDispatcherTracer: "
     165             :       "prepare_parsing=%.2lfms parsing=%.2lfms/kb finalize_parsing=%.2lfms "
     166             :       "analyze=%.2lfms prepare_compiling=%.2lfms compiling=%.2lfms/kb "
     167             :       "finalize_compiling=%.2lfms\n",
     168             :       EstimatePrepareToParseInMs(), EstimateParseInMs(1 * KB),
     169             :       EstimateFinalizeParsingInMs(), EstimateAnalyzeInMs(),
     170             :       EstimatePrepareToCompileInMs(), EstimateCompileInMs(1 * KB),
     171           0 :       EstimateFinalizeCompilingInMs());
     172           0 : }
     173             : 
     174          66 : double CompilerDispatcherTracer::Average(
     175          66 :     const base::RingBuffer<double>& buffer) {
     176          66 :   if (buffer.Count() == 0) return 0.0;
     177          13 :   double sum = buffer.Sum([](double a, double b) { return a + b; }, 0.0);
     178          11 :   return sum / buffer.Count();
     179             : }
     180             : 
     181          33 : double CompilerDispatcherTracer::Estimate(
     182          33 :     const base::RingBuffer<std::pair<size_t, double>>& buffer, size_t num) {
     183          33 :   if (buffer.Count() == 0) return kEstimatedRuntimeWithoutData;
     184             :   std::pair<size_t, double> sum = buffer.Sum(
     185             :       [](std::pair<size_t, double> a, std::pair<size_t, double> b) {
     186          16 :         return std::make_pair(a.first + b.first, a.second + b.second);
     187             :       },
     188          12 :       std::make_pair(0, 0.0));
     189          12 :   return num * (sum.second / sum.first);
     190             : }
     191             : 
     192             : }  // namespace internal
     193             : }  // namespace v8

Generated by: LCOV version 1.10