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             : #ifndef V8_COUNTERS_INL_H_
       6             : #define V8_COUNTERS_INL_H_
       7             : 
       8             : #include "src/counters.h"
       9             : 
      10             : namespace v8 {
      11             : namespace internal {
      12             : 
      13           0 : void RuntimeCallTimer::Start(RuntimeCallCounter* counter,
      14             :                              RuntimeCallTimer* parent) {
      15             :   DCHECK(!IsStarted());
      16           0 :   counter_ = counter;
      17             :   parent_.SetValue(parent);
      18           0 :   if (FLAG_runtime_stats ==
      19             :       v8::tracing::TracingCategoryObserver::ENABLED_BY_SAMPLING) {
      20           0 :     return;
      21             :   }
      22             :   base::TimeTicks now = Now();
      23           0 :   if (parent) parent->Pause(now);
      24             :   Resume(now);
      25             :   DCHECK(IsStarted());
      26             : }
      27             : 
      28             : void RuntimeCallTimer::Pause(base::TimeTicks now) {
      29             :   DCHECK(IsStarted());
      30             :   elapsed_ += (now - start_ticks_);
      31           0 :   start_ticks_ = base::TimeTicks();
      32             : }
      33             : 
      34             : void RuntimeCallTimer::Resume(base::TimeTicks now) {
      35             :   DCHECK(!IsStarted());
      36           0 :   start_ticks_ = now;
      37             : }
      38             : 
      39           0 : RuntimeCallTimer* RuntimeCallTimer::Stop() {
      40           0 :   if (!IsStarted()) return parent();
      41             :   base::TimeTicks now = Now();
      42             :   Pause(now);
      43           0 :   counter_->Increment();
      44             :   CommitTimeToCounter();
      45             : 
      46             :   RuntimeCallTimer* parent_timer = parent();
      47           0 :   if (parent_timer) {
      48             :     parent_timer->Resume(now);
      49             :   }
      50           0 :   return parent_timer;
      51             : }
      52             : 
      53             : void RuntimeCallTimer::CommitTimeToCounter() {
      54           0 :   counter_->Add(elapsed_);
      55             :   elapsed_ = base::TimeDelta();
      56             : }
      57             : 
      58             : bool RuntimeCallTimer::IsStarted() { return start_ticks_ != base::TimeTicks(); }
      59             : 
      60             : base::TimeTicks RuntimeCallTimer::Now() {
      61           0 :   return base::TimeTicks::HighResolutionNow();
      62             : }
      63             : 
      64   600971186 : RuntimeCallTimerScope::RuntimeCallTimerScope(
      65   600971186 :     Isolate* isolate, RuntimeCallStats::CounterId counter_id) {
      66   600971186 :   if (V8_UNLIKELY(FLAG_runtime_stats)) {
      67           0 :     Initialize(isolate->counters()->runtime_call_stats(), counter_id);
      68             :   }
      69   600971186 : }
      70             : 
      71    61997281 : RuntimeCallTimerScope::RuntimeCallTimerScope(
      72    61997281 :     HeapObject* heap_object, RuntimeCallStats::CounterId counter_id) {
      73   123994613 :   RuntimeCallTimerScope(heap_object->GetIsolate(), counter_id);
      74    61997332 : }
      75             : 
      76    19929335 : RuntimeCallTimerScope::RuntimeCallTimerScope(
      77    19929335 :     RuntimeCallStats* stats, RuntimeCallStats::CounterId counter_id) {
      78    19929335 :   if (V8_UNLIKELY(FLAG_runtime_stats)) {
      79             :     Initialize(stats, counter_id);
      80             :   }
      81    19929335 : }
      82             : 
      83             : }  // namespace internal
      84             : }  // namespace v8
      85             : 
      86             : #endif  // V8_COUNTERS_INL_H_