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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ART_SRC_TIMING_LOGGER_H_
#define ART_SRC_TIMING_LOGGER_H_
#include "base/histogram.h"
#include "base/macros.h"
#include "base/mutex.h"
#include <string>
#include <vector>
namespace art {
class CumulativeLogger;
class TimingLogger {
public:
explicit TimingLogger(const std::string& name, bool precise);
void AddSplit(const std::string& label);
void Dump(std::ostream& os) const;
void Reset();
uint64_t GetTotalNs() const;
protected:
const std::string name_;
const bool precise_;
std::vector<uint64_t> times_;
std::vector<std::string> labels_;
friend class CumulativeLogger;
};
namespace base {
class NewTimingLogger;
} // namespace base
class CumulativeLogger {
public:
explicit CumulativeLogger(const std::string& name);
void prepare_stats();
~CumulativeLogger();
void Start();
void End();
void Reset();
void Dump(std::ostream& os) LOCKS_EXCLUDED(lock_);
uint64_t GetTotalNs() const;
// Allow the name to be modified, particularly when the cumulative logger is a field within a
// parent class that is unable to determine the "name" of a sub-class.
void SetName(const std::string& name);
void AddLogger(const TimingLogger& logger) LOCKS_EXCLUDED(lock_);
void AddNewLogger(const base::NewTimingLogger& logger) LOCKS_EXCLUDED(lock_);
private:
void AddPair(const std::string &label, uint64_t delta_time)
EXCLUSIVE_LOCKS_REQUIRED(lock_);
void DumpHistogram(std::ostream &os) EXCLUSIVE_LOCKS_REQUIRED(lock_);
uint64_t GetTotalTime() const;
static const uint64_t kAdjust = 1000;
std::vector<Histogram<uint64_t> *> histograms_ GUARDED_BY(lock_);
std::string name_;
const std::string lock_name_;
mutable Mutex lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
size_t index_ GUARDED_BY(lock_);
size_t iterations_ GUARDED_BY(lock_);
DISALLOW_COPY_AND_ASSIGN(CumulativeLogger);
};
namespace base {
// A replacement to timing logger that know when a split starts for the purposes of logging.
// TODO: replace uses of TimingLogger with base::NewTimingLogger.
class NewTimingLogger {
public:
explicit NewTimingLogger(const char* name, bool precise, bool verbose);
// Clears current splits and labels.
void Reset();
// Starts a split, a split shouldn't be in progress.
void StartSplit(const char* new_split_label);
// Ends the current split and starts the one given by the label.
void NewSplit(const char* new_split_label);
// Ends the current split and records the end time.
void EndSplit();
uint64_t GetTotalNs() const;
void Dump(std::ostream& os) const;
const std::vector<std::pair<uint64_t, const char*> >& GetSplits() const {
return splits_;
}
protected:
// The name of the timing logger.
const std::string name_;
// Do we want to print the exactly recorded split (true) or round down to the time unit being
// used (false).
const bool precise_;
// Verbose logging.
const bool verbose_;
// The name of the current split.
const char* current_split_;
// The nanosecond time the current split started on.
uint64_t current_split_start_ns_;
// Splits are nanosecond times and split names.
std::vector<std::pair<uint64_t, const char*> > splits_;
private:
DISALLOW_COPY_AND_ASSIGN(NewTimingLogger);
};
} // namespace base
} // namespace art
#endif // ART_SRC_TIMING_LOGGER_H_
|
