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
143
144
145
146
147
148
149
|
// Copyright (c) 2010 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.
// Trace events to track application performance. Events consist of a name
// a type (BEGIN, END or INSTANT), a tracking id and extra string data.
// In addition, the current process id, thread id, a timestamp down to the
// microsecond and a file and line number of the calling location.
//
// The current implementation logs these events into a log file of the form
// trace_<pid>.log where it's designed to be post-processed to generate a
// trace report. In the future, it may use another mechansim to facilitate
// real-time analysis.
#ifndef BASE_DEBUG_TRACE_EVENT_H_
#define BASE_DEBUG_TRACE_EVENT_H_
#pragma once
#include "build/build_config.h"
#if defined(OS_WIN)
// On Windows we always pull in an alternative implementation
// which logs to Event Tracing for Windows.
//
// Note that the Windows implementation is always enabled, irrespective the
// value of the CHROMIUM_ENABLE_TRACE_EVENT define. The Windows implementation
// is controlled by Event Tracing for Windows, which will turn tracing on only
// if there is someone listening for the events it generates.
#include "base/debug/trace_event_win.h"
#else // defined(OS_WIN)
#include <string>
#include "base/lock.h"
#include "base/scoped_ptr.h"
#include "base/singleton.h"
#include "base/time.h"
#include "base/timer.h"
#ifndef CHROMIUM_ENABLE_TRACE_EVENT
#define TRACE_EVENT_BEGIN(name, id, extra) ((void) 0)
#define TRACE_EVENT_END(name, id, extra) ((void) 0)
#define TRACE_EVENT_INSTANT(name, id, extra) ((void) 0)
#else // CHROMIUM_ENABLE_TRACE_EVENT
// Use the following macros rather than using the TraceLog class directly as the
// underlying implementation may change in the future. Here's a sample usage:
// TRACE_EVENT_BEGIN("v8.run", documentId, scriptLocation);
// RunScript(script);
// TRACE_EVENT_END("v8.run", documentId, scriptLocation);
// Record that an event (of name, id) has begun. All BEGIN events should have
// corresponding END events with a matching (name, id).
#define TRACE_EVENT_BEGIN(name, id, extra) \
Singleton<base::debug::TraceLog>::get()->Trace( \
name, \
base::debug::TraceLog::EVENT_BEGIN, \
reinterpret_cast<const void*>(id), \
extra, \
__FILE__, \
__LINE__)
// Record that an event (of name, id) has ended. All END events should have
// corresponding BEGIN events with a matching (name, id).
#define TRACE_EVENT_END(name, id, extra) \
Singleton<base::debug::TraceLog>::get()->Trace( \
name, \
base::debug::TraceLog::EVENT_END, \
reinterpret_cast<const void*>(id), \
extra, \
__FILE__, \
__LINE__)
// Record that an event (of name, id) with no duration has happened.
#define TRACE_EVENT_INSTANT(name, id, extra) \
Singleton<base::debug::TraceLog>::get()->Trace( \
name, \
base::debug::TraceLog::EVENT_INSTANT, \
reinterpret_cast<const void*>(id), \
extra, \
__FILE__, \
__LINE__)
#endif // CHROMIUM_ENABLE_TRACE_EVENT
namespace base {
class ProcessMetrics;
namespace debug {
class TraceLog {
public:
enum EventType {
EVENT_BEGIN,
EVENT_END,
EVENT_INSTANT
};
// Is tracing currently enabled.
static bool IsTracing();
// Start logging trace events.
static bool StartTracing();
// Stop logging trace events.
static void StopTracing();
// Log a trace event of (name, type, id) with the optional extra string.
void Trace(const std::string& name,
EventType type,
const void* id,
const std::wstring& extra,
const char* file,
int line);
void Trace(const std::string& name,
EventType type,
const void* id,
const std::string& extra,
const char* file,
int line);
private:
// This allows constructor and destructor to be private and usable only
// by the Singleton class.
friend struct DefaultSingletonTraits<TraceLog>;
TraceLog();
~TraceLog();
bool OpenLogFile();
void CloseLogFile();
bool Start();
void Stop();
void Heartbeat();
void Log(const std::string& msg);
bool enabled_;
FILE* log_file_;
Lock file_lock_;
TimeTicks trace_start_time_;
#ifndef ANDROID
scoped_ptr<base::ProcessMetrics> process_metrics_;
#endif
RepeatingTimer<TraceLog> timer_;
};
} // namespace debug
} // namespace base
#endif // defined(OS_WIN)
#endif // BASE_DEBUG_TRACE_EVENT_H_
|
