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
150
151
152
153
|
/*
* 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_RUNTIME_TRACE_H_
#define ART_RUNTIME_TRACE_H_
#include <ostream>
#include <set>
#include <string>
#include <vector>
#include "base/macros.h"
#include "globals.h"
#include "instrumentation.h"
#include "os.h"
#include "safe_map.h"
#include "UniquePtr.h"
namespace art {
namespace mirror {
class ArtMethod;
} // namespace mirror
class Thread;
enum ProfilerClockSource {
kProfilerClockSourceThreadCpu,
kProfilerClockSourceWall,
kProfilerClockSourceDual, // Both wall and thread CPU clocks.
};
class Trace : public instrumentation::InstrumentationListener {
public:
enum TraceFlag {
kTraceCountAllocs = 1,
};
static void SetDefaultClockSource(ProfilerClockSource clock_source);
static void Start(const char* trace_filename, int trace_fd, int buffer_size, int flags,
bool direct_to_ddms)
LOCKS_EXCLUDED(Locks::mutator_lock_,
Locks::thread_list_lock_,
Locks::thread_suspend_count_lock_,
Locks::trace_lock_);
static void Stop() LOCKS_EXCLUDED(Locks::trace_lock_);
static void Shutdown() LOCKS_EXCLUDED(Locks::trace_lock_);
static bool IsMethodTracingActive() LOCKS_EXCLUDED(Locks::trace_lock_);
bool UseWallClock();
bool UseThreadCpuClock();
void CompareAndUpdateStackTrace(Thread* thread, std::vector<mirror::AbstractMethod*>* stack_trace)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
virtual void MethodEntered(Thread* thread, mirror::Object* this_object,
const mirror::ArtMethod* method, uint32_t dex_pc)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
virtual void MethodExited(Thread* thread, mirror::Object* this_object,
const mirror::ArtMethod* method, uint32_t dex_pc,
const JValue& return_value)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
virtual void MethodUnwind(Thread* thread, const mirror::ArtMethod* method, uint32_t dex_pc)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
virtual void DexPcMoved(Thread* thread, mirror::Object* this_object,
const mirror::ArtMethod* method, uint32_t new_dex_pc)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
virtual void ExceptionCaught(Thread* thread, const ThrowLocation& throw_location,
mirror::ArtMethod* catch_method, uint32_t catch_dex_pc,
mirror::Throwable* exception_object)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
~Trace();
private:
explicit Trace(File* trace_file, int buffer_size, int flags);
static void* RunSamplingThread(void* arg) LOCKS_EXCLUDED(Locks::trace_lock_);
void FinishTracing() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void LogMethodTraceEvent(Thread* thread, const mirror::ArtMethod* method,
instrumentation::Instrumentation::InstrumentationEvent event);
// Methods to output traced methods and threads.
void GetVisitedMethods(size_t end_offset, std::set<mirror::ArtMethod*>* visited_methods);
void DumpMethodList(std::ostream& os, const std::set<mirror::ArtMethod*>& visited_methods)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void DumpThreadList(std::ostream& os) LOCKS_EXCLUDED(Locks::thread_list_lock_);
// Singleton instance of the Trace or NULL when no method tracing is active.
static Trace* volatile the_trace_ GUARDED_BY(Locks::trace_lock_);
// The default profiler clock source.
static ProfilerClockSource default_clock_source_;
// True if traceview should sample instead of instrumenting method entry/exit.
static bool sampling_enabled_;
// Sampling interval in microseconds.
static uint32_t sampling_interval_us_;
// Sampling thread, non-zero when sampling.
static pthread_t sampling_pthread_;
// Maps a thread to its most recent stack trace sample.
SafeMap<Thread*, std::vector<mirror::AbstractMethod*>*> thread_stack_trace_map_;
// Maps a thread to its clock base.
SafeMap<Thread*, uint64_t> thread_clock_base_map_;
// File to write trace data out to, NULL if direct to ddms.
UniquePtr<File> trace_file_;
// Buffer to store trace data.
UniquePtr<uint8_t> buf_;
// Flags enabling extra tracing of things such as alloc counts.
const int flags_;
const ProfilerClockSource clock_source_;
// Size of buf_.
const int buffer_size_;
// Time trace was created.
const uint64_t start_time_;
// Offset into buf_.
volatile int32_t cur_offset_;
// Did we overflow the buffer recording traces?
bool overflow_;
DISALLOW_COPY_AND_ASSIGN(Trace);
};
} // namespace art
#endif // ART_RUNTIME_TRACE_H_
|
