1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
// Copyright 2014 The Chromium 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 "cc/scheduler/begin_frame_tracker.h"
namespace cc {
BeginFrameTracker::BeginFrameTracker(const tracked_objects::Location& location)
: location_(location),
location_string_(location.ToString()),
current_updated_at_(),
current_args_(),
current_finished_at_(base::TimeTicks::FromInternalValue(-1)) {}
BeginFrameTracker::~BeginFrameTracker() {
}
void BeginFrameTracker::Start(BeginFrameArgs new_args) {
// Trace the frame time being passed between BeginFrameTrackers.
TRACE_EVENT_FLOW_STEP0(
TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler.frames"), "BeginFrameArgs",
new_args.frame_time.ToInternalValue(), location_string_);
// Trace this specific begin frame tracker Start/Finish times.
TRACE_EVENT_ASYNC_BEGIN2(
TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler.frames"),
location_string_.c_str(), new_args.frame_time.ToInternalValue(),
"new args", new_args.AsValue(), "current args", current_args_.AsValue());
// Check the new BeginFrameArgs are valid and monotonically increasing.
DCHECK(new_args.IsValid());
DCHECK_LE(current_args_.frame_time, new_args.frame_time);
DCHECK(HasFinished())
<< "Tried to start a new frame before finishing an existing frame.";
current_updated_at_ = base::TimeTicks::Now();
current_args_ = new_args;
current_finished_at_ = base::TimeTicks();
// TODO(mithro): Add UMA tracking of delta between current_updated_at_ time
// and the new_args.frame_time argument. This will give us how long after a
// BeginFrameArgs message was created before we started processing it.
}
const BeginFrameArgs& BeginFrameTracker::Current() const {
DCHECK(!HasFinished())
<< "Tried to use BeginFrameArgs after marking the frame finished.";
DCHECK(current_args_.IsValid())
<< "Tried to use BeginFrameArgs before starting a frame!";
return current_args_;
}
void BeginFrameTracker::Finish() {
DCHECK(!HasFinished()) << "Tried to finish an already finished frame";
current_finished_at_ = base::TimeTicks::Now();
TRACE_EVENT_ASYNC_END0(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler.frames"),
location_string_.c_str(),
current_args_.frame_time.ToInternalValue());
}
const BeginFrameArgs& BeginFrameTracker::Last() const {
DCHECK(current_args_.IsValid())
<< "Tried to use last BeginFrameArgs before starting a frame!";
DCHECK(HasFinished())
<< "Tried to use last BeginFrameArgs before the frame is finished.";
return current_args_;
}
base::TimeDelta BeginFrameTracker::Interval() const {
base::TimeDelta interval = current_args_.interval;
// Normal interval will be ~16ms, 200Hz (5ms) screens are the fastest
// easily available so anything less than that is likely an error.
if (interval < base::TimeDelta::FromMilliseconds(1)) {
interval = BeginFrameArgs::DefaultInterval();
}
return interval;
}
void BeginFrameTracker::AsValueInto(
base::TimeTicks now,
base::trace_event::TracedValue* state) const {
state->SetInteger("updated_at_us",
(current_updated_at_ - base::TimeTicks()).InMicroseconds());
state->SetInteger("finished_at_us", (current_finished_at_ - base::TimeTicks())
.InMicroseconds());
if (HasFinished()) {
state->SetString("state", "FINISHED");
state->BeginDictionary("current_args_");
} else {
state->SetString("state", "USING");
state->BeginDictionary("last_args_");
}
current_args_.AsValueInto(state);
state->EndDictionary();
base::TimeTicks frame_time = current_args_.frame_time;
base::TimeTicks deadline = current_args_.deadline;
base::TimeDelta interval = current_args_.interval;
state->BeginDictionary("major_timestamps_in_ms");
state->SetDouble("0_interval", interval.InMillisecondsF());
state->SetDouble("1_now_to_deadline", (deadline - now).InMillisecondsF());
state->SetDouble("2_frame_time_to_now", (now - frame_time).InMillisecondsF());
state->SetDouble("3_frame_time_to_deadline",
(deadline - frame_time).InMillisecondsF());
state->SetDouble("4_now", (now - base::TimeTicks()).InMillisecondsF());
state->SetDouble("5_frame_time",
(frame_time - base::TimeTicks()).InMillisecondsF());
state->SetDouble("6_deadline",
(deadline - base::TimeTicks()).InMillisecondsF());
state->EndDictionary();
}
const BeginFrameArgs& BeginFrameTracker::DangerousMethodCurrentOrLast() const {
if (!HasFinished()) {
return Current();
} else {
return Last();
}
}
} // namespace cc
|
