blob: ab342aa8823915e97e0ec5cac002202f001a947e [file] [log] [blame]
Elliott Hughes2faa5f12012-01-30 14:42:07 -08001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
jeffhaoe343b762011-12-05 16:36:44 -080016
17#include "trace.h"
18
jeffhaoa9ef3fd2011-12-13 18:33:43 -080019#include <sys/uio.h>
John Reck0624a272015-03-26 15:47:54 -070020#include <unistd.h>
jeffhaoa9ef3fd2011-12-13 18:33:43 -080021
Ian Rogerscf7f1912014-10-22 22:06:39 -070022#define ATRACE_TAG ATRACE_TAG_DALVIK
23#include "cutils/trace.h"
24
Mathieu Chartiere401d142015-04-22 13:56:20 -070025#include "art_method-inl.h"
Andreas Gampee34a42c2015-04-25 14:44:29 -070026#include "base/casts.h"
Jeff Hao0abc72e2013-08-13 13:45:14 -070027#include "base/stl_util.h"
Vladimir Marko80afd022015-05-19 18:08:00 +010028#include "base/time_utils.h"
Elliott Hughes76160052012-12-12 16:31:20 -080029#include "base/unix_file/fd_file.h"
jeffhaoe343b762011-12-05 16:36:44 -080030#include "class_linker.h"
Ian Rogers62d6c772013-02-27 08:32:07 -080031#include "common_throws.h"
jeffhaoa9ef3fd2011-12-13 18:33:43 -080032#include "debugger.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070033#include "dex_file-inl.h"
Mathieu Chartieraa516822015-10-02 15:53:37 -070034#include "gc/scoped_gc_critical_section.h"
jeffhao725a9572012-11-13 18:20:12 -080035#include "instrumentation.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070036#include "mirror/class-inl.h"
Andreas Gampe40da2862015-02-27 12:49:04 -080037#include "mirror/dex_cache-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080038#include "mirror/object_array-inl.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070039#include "mirror/object-inl.h"
jeffhaoa9ef3fd2011-12-13 18:33:43 -080040#include "os.h"
Ian Rogers00f7d0e2012-07-19 15:28:27 -070041#include "scoped_thread_state_change.h"
Jeff Hao0abc72e2013-08-13 13:45:14 -070042#include "ScopedLocalRef.h"
jeffhaoe343b762011-12-05 16:36:44 -080043#include "thread.h"
Ian Rogers57b86d42012-03-27 16:05:41 -070044#include "thread_list.h"
Vladimir Marko80afd022015-05-19 18:08:00 +010045#include "utils.h"
Ian Rogers166db042013-07-26 12:05:57 -070046#include "entrypoints/quick/quick_entrypoints.h"
jeffhao2692b572011-12-16 15:42:28 -080047
48namespace art {
49
Mathieu Chartier4d64cd42015-06-02 16:38:29 -070050static constexpr size_t TraceActionBits = MinimumBitsToStore(
51 static_cast<size_t>(kTraceMethodActionMask));
Andreas Gampe40da2862015-02-27 12:49:04 -080052static constexpr uint8_t kOpNewMethod = 1U;
53static constexpr uint8_t kOpNewThread = 2U;
54
Jeff Hao0abc72e2013-08-13 13:45:14 -070055class BuildStackTraceVisitor : public StackVisitor {
56 public:
Nicolas Geoffray8e5bd182015-05-06 11:34:34 +010057 explicit BuildStackTraceVisitor(Thread* thread)
58 : StackVisitor(thread, nullptr, StackVisitor::StackWalkKind::kIncludeInlinedFrames),
59 method_trace_(Trace::AllocStackTrace()) {}
Jeff Hao0abc72e2013-08-13 13:45:14 -070060
Mathieu Chartier90443472015-07-16 20:32:27 -070061 bool VisitFrame() SHARED_REQUIRES(Locks::mutator_lock_) {
Mathieu Chartiere401d142015-04-22 13:56:20 -070062 ArtMethod* m = GetMethod();
Jeff Hao0abc72e2013-08-13 13:45:14 -070063 // Ignore runtime frames (in particular callee save).
64 if (!m->IsRuntimeMethod()) {
65 method_trace_->push_back(m);
66 }
67 return true;
68 }
69
70 // Returns a stack trace where the topmost frame corresponds with the first element of the vector.
Mathieu Chartiere401d142015-04-22 13:56:20 -070071 std::vector<ArtMethod*>* GetStackTrace() const {
Jeff Hao0abc72e2013-08-13 13:45:14 -070072 return method_trace_;
73 }
74
75 private:
Mathieu Chartiere401d142015-04-22 13:56:20 -070076 std::vector<ArtMethod*>* const method_trace_;
Sebastien Hertz26f72862015-09-15 09:52:07 +020077
78 DISALLOW_COPY_AND_ASSIGN(BuildStackTraceVisitor);
Jeff Hao0abc72e2013-08-13 13:45:14 -070079};
80
jeffhaoa9ef3fd2011-12-13 18:33:43 -080081static const char kTraceTokenChar = '*';
82static const uint16_t kTraceHeaderLength = 32;
83static const uint32_t kTraceMagicValue = 0x574f4c53;
84static const uint16_t kTraceVersionSingleClock = 2;
85static const uint16_t kTraceVersionDualClock = 3;
Mathieu Chartier4d64cd42015-06-02 16:38:29 -070086static const uint16_t kTraceRecordSizeSingleClock = 10; // using v2
87static const uint16_t kTraceRecordSizeDualClock = 14; // using v3 with two timestamps
jeffhaoa9ef3fd2011-12-13 18:33:43 -080088
Ian Rogerse63db272014-07-15 15:36:11 -070089TraceClockSource Trace::default_clock_source_ = kDefaultTraceClockSource;
Elliott Hughese119a362012-05-22 17:37:06 -070090
Andreas Gampe40da2862015-02-27 12:49:04 -080091Trace* volatile Trace::the_trace_ = nullptr;
Jeff Hao0abc72e2013-08-13 13:45:14 -070092pthread_t Trace::sampling_pthread_ = 0U;
Mathieu Chartiere401d142015-04-22 13:56:20 -070093std::unique_ptr<std::vector<ArtMethod*>> Trace::temp_stack_trace_;
Ian Rogers62d6c772013-02-27 08:32:07 -080094
Sebastien Hertz0462c4c2015-04-01 16:34:17 +020095// The key identifying the tracer to update instrumentation.
96static constexpr const char* kTracerInstrumentationKey = "Tracer";
97
Ian Rogers62d6c772013-02-27 08:32:07 -080098static TraceAction DecodeTraceAction(uint32_t tmid) {
99 return static_cast<TraceAction>(tmid & kTraceMethodActionMask);
100}
101
Mathieu Chartier4d64cd42015-06-02 16:38:29 -0700102ArtMethod* Trace::DecodeTraceMethod(uint32_t tmid) {
103 MutexLock mu(Thread::Current(), *unique_methods_lock_);
104 return unique_methods_[tmid >> TraceActionBits];
105}
106
107uint32_t Trace::EncodeTraceMethod(ArtMethod* method) {
108 MutexLock mu(Thread::Current(), *unique_methods_lock_);
109 uint32_t idx;
110 auto it = art_method_id_map_.find(method);
111 if (it != art_method_id_map_.end()) {
112 idx = it->second;
113 } else {
114 unique_methods_.push_back(method);
115 idx = unique_methods_.size() - 1;
116 art_method_id_map_.emplace(method, idx);
117 }
118 DCHECK_LT(idx, unique_methods_.size());
119 DCHECK_EQ(unique_methods_[idx], method);
120 return idx;
121}
122
123uint32_t Trace::EncodeTraceMethodAndAction(ArtMethod* method, TraceAction action) {
124 uint32_t tmid = (EncodeTraceMethod(method) << TraceActionBits) | action;
125 DCHECK_EQ(method, DecodeTraceMethod(tmid));
Ian Rogers62d6c772013-02-27 08:32:07 -0800126 return tmid;
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800127}
128
Mathieu Chartiere401d142015-04-22 13:56:20 -0700129std::vector<ArtMethod*>* Trace::AllocStackTrace() {
Mathieu Chartier4d64cd42015-06-02 16:38:29 -0700130 return (temp_stack_trace_.get() != nullptr) ? temp_stack_trace_.release() :
131 new std::vector<ArtMethod*>();
Jeff Hao5ce4b172013-08-16 16:27:18 -0700132}
133
Mathieu Chartiere401d142015-04-22 13:56:20 -0700134void Trace::FreeStackTrace(std::vector<ArtMethod*>* stack_trace) {
Jeff Hao5ce4b172013-08-16 16:27:18 -0700135 stack_trace->clear();
136 temp_stack_trace_.reset(stack_trace);
137}
138
Ian Rogerse63db272014-07-15 15:36:11 -0700139void Trace::SetDefaultClockSource(TraceClockSource clock_source) {
Elliott Hughes0a18df82015-01-09 15:16:16 -0800140#if defined(__linux__)
Ian Rogers62d6c772013-02-27 08:32:07 -0800141 default_clock_source_ = clock_source;
142#else
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800143 if (clock_source != TraceClockSource::kWall) {
Jeff Hao5ce4b172013-08-16 16:27:18 -0700144 LOG(WARNING) << "Ignoring tracing request to use CPU time.";
Ian Rogers62d6c772013-02-27 08:32:07 -0800145 }
146#endif
147}
148
Ian Rogerse63db272014-07-15 15:36:11 -0700149static uint16_t GetTraceVersion(TraceClockSource clock_source) {
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800150 return (clock_source == TraceClockSource::kDual) ? kTraceVersionDualClock
Ian Rogers62d6c772013-02-27 08:32:07 -0800151 : kTraceVersionSingleClock;
152}
153
Ian Rogerse63db272014-07-15 15:36:11 -0700154static uint16_t GetRecordSize(TraceClockSource clock_source) {
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800155 return (clock_source == TraceClockSource::kDual) ? kTraceRecordSizeDualClock
Ian Rogers62d6c772013-02-27 08:32:07 -0800156 : kTraceRecordSizeSingleClock;
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800157}
158
Elliott Hughese119a362012-05-22 17:37:06 -0700159bool Trace::UseThreadCpuClock() {
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800160 return (clock_source_ == TraceClockSource::kThreadCpu) ||
161 (clock_source_ == TraceClockSource::kDual);
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800162}
163
Elliott Hughese119a362012-05-22 17:37:06 -0700164bool Trace::UseWallClock() {
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800165 return (clock_source_ == TraceClockSource::kWall) ||
166 (clock_source_ == TraceClockSource::kDual);
Elliott Hughese119a362012-05-22 17:37:06 -0700167}
168
Jeff Haoc5d824a2014-07-28 18:35:38 -0700169void Trace::MeasureClockOverhead() {
170 if (UseThreadCpuClock()) {
Jeff Hao57dac6e2013-08-15 16:36:24 -0700171 Thread::Current()->GetCpuMicroTime();
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800172 }
Jeff Haoc5d824a2014-07-28 18:35:38 -0700173 if (UseWallClock()) {
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800174 MicroTime();
175 }
176}
177
Jeff Hao5ce4b172013-08-16 16:27:18 -0700178// Compute an average time taken to measure clocks.
Jeff Haoc5d824a2014-07-28 18:35:38 -0700179uint32_t Trace::GetClockOverheadNanoSeconds() {
Jeff Hao57dac6e2013-08-15 16:36:24 -0700180 Thread* self = Thread::Current();
181 uint64_t start = self->GetCpuMicroTime();
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800182
183 for (int i = 4000; i > 0; i--) {
Jeff Haoc5d824a2014-07-28 18:35:38 -0700184 MeasureClockOverhead();
185 MeasureClockOverhead();
186 MeasureClockOverhead();
187 MeasureClockOverhead();
188 MeasureClockOverhead();
189 MeasureClockOverhead();
190 MeasureClockOverhead();
191 MeasureClockOverhead();
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800192 }
193
Jeff Hao5ce4b172013-08-16 16:27:18 -0700194 uint64_t elapsed_us = self->GetCpuMicroTime() - start;
195 return static_cast<uint32_t>(elapsed_us / 32);
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800196}
197
Elliott Hughesffb465f2012-03-01 18:46:05 -0800198// TODO: put this somewhere with the big-endian equivalent used by JDWP.
199static void Append2LE(uint8_t* buf, uint16_t val) {
Jeff Hao5ce4b172013-08-16 16:27:18 -0700200 *buf++ = static_cast<uint8_t>(val);
201 *buf++ = static_cast<uint8_t>(val >> 8);
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800202}
203
Elliott Hughesffb465f2012-03-01 18:46:05 -0800204// TODO: put this somewhere with the big-endian equivalent used by JDWP.
205static void Append4LE(uint8_t* buf, uint32_t val) {
Jeff Hao5ce4b172013-08-16 16:27:18 -0700206 *buf++ = static_cast<uint8_t>(val);
207 *buf++ = static_cast<uint8_t>(val >> 8);
208 *buf++ = static_cast<uint8_t>(val >> 16);
209 *buf++ = static_cast<uint8_t>(val >> 24);
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800210}
211
Elliott Hughesffb465f2012-03-01 18:46:05 -0800212// TODO: put this somewhere with the big-endian equivalent used by JDWP.
213static void Append8LE(uint8_t* buf, uint64_t val) {
Jeff Hao5ce4b172013-08-16 16:27:18 -0700214 *buf++ = static_cast<uint8_t>(val);
215 *buf++ = static_cast<uint8_t>(val >> 8);
216 *buf++ = static_cast<uint8_t>(val >> 16);
217 *buf++ = static_cast<uint8_t>(val >> 24);
218 *buf++ = static_cast<uint8_t>(val >> 32);
219 *buf++ = static_cast<uint8_t>(val >> 40);
220 *buf++ = static_cast<uint8_t>(val >> 48);
221 *buf++ = static_cast<uint8_t>(val >> 56);
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800222}
223
Mathieu Chartier90443472015-07-16 20:32:27 -0700224static void GetSample(Thread* thread, void* arg) SHARED_REQUIRES(Locks::mutator_lock_) {
Jeff Hao0abc72e2013-08-13 13:45:14 -0700225 BuildStackTraceVisitor build_trace_visitor(thread);
226 build_trace_visitor.WalkStack();
Mathieu Chartiere401d142015-04-22 13:56:20 -0700227 std::vector<ArtMethod*>* stack_trace = build_trace_visitor.GetStackTrace();
Jeff Hao0abc72e2013-08-13 13:45:14 -0700228 Trace* the_trace = reinterpret_cast<Trace*>(arg);
229 the_trace->CompareAndUpdateStackTrace(thread, stack_trace);
230}
231
Andreas Gampeca714582015-04-03 19:41:34 -0700232static void ClearThreadStackTraceAndClockBase(Thread* thread, void* arg ATTRIBUTE_UNUSED) {
Jeff Hao5ce4b172013-08-16 16:27:18 -0700233 thread->SetTraceClockBase(0);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700234 std::vector<ArtMethod*>* stack_trace = thread->GetStackTraceSample();
Andreas Gampe40da2862015-02-27 12:49:04 -0800235 thread->SetStackTraceSample(nullptr);
Jeff Hao5ce4b172013-08-16 16:27:18 -0700236 delete stack_trace;
237}
238
Jeff Hao0abc72e2013-08-13 13:45:14 -0700239void Trace::CompareAndUpdateStackTrace(Thread* thread,
Mathieu Chartiere401d142015-04-22 13:56:20 -0700240 std::vector<ArtMethod*>* stack_trace) {
Jeff Hao0abc72e2013-08-13 13:45:14 -0700241 CHECK_EQ(pthread_self(), sampling_pthread_);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700242 std::vector<ArtMethod*>* old_stack_trace = thread->GetStackTraceSample();
Jeff Hao5ce4b172013-08-16 16:27:18 -0700243 // Update the thread's stack trace sample.
244 thread->SetStackTraceSample(stack_trace);
Jeff Haoc1ff4b72013-08-19 11:33:10 -0700245 // Read timer clocks to use for all events in this trace.
246 uint32_t thread_clock_diff = 0;
247 uint32_t wall_clock_diff = 0;
248 ReadClocks(thread, &thread_clock_diff, &wall_clock_diff);
Andreas Gampe40da2862015-02-27 12:49:04 -0800249 if (old_stack_trace == nullptr) {
Jeff Hao5ce4b172013-08-16 16:27:18 -0700250 // If there's no previous stack trace sample for this thread, log an entry event for all
Jeff Hao0abc72e2013-08-13 13:45:14 -0700251 // methods in the trace.
Mathieu Chartier4d64cd42015-06-02 16:38:29 -0700252 for (auto rit = stack_trace->rbegin(); rit != stack_trace->rend(); ++rit) {
Jeff Haoc1ff4b72013-08-19 11:33:10 -0700253 LogMethodTraceEvent(thread, *rit, instrumentation::Instrumentation::kMethodEntered,
254 thread_clock_diff, wall_clock_diff);
Jeff Hao0abc72e2013-08-13 13:45:14 -0700255 }
256 } else {
257 // If there's a previous stack trace for this thread, diff the traces and emit entry and exit
258 // events accordingly.
Mathieu Chartier4d64cd42015-06-02 16:38:29 -0700259 auto old_rit = old_stack_trace->rbegin();
260 auto rit = stack_trace->rbegin();
Jeff Hao0abc72e2013-08-13 13:45:14 -0700261 // Iterate bottom-up over both traces until there's a difference between them.
262 while (old_rit != old_stack_trace->rend() && rit != stack_trace->rend() && *old_rit == *rit) {
263 old_rit++;
264 rit++;
265 }
266 // Iterate top-down over the old trace until the point where they differ, emitting exit events.
Mathieu Chartier4d64cd42015-06-02 16:38:29 -0700267 for (auto old_it = old_stack_trace->begin(); old_it != old_rit.base(); ++old_it) {
Jeff Haoc1ff4b72013-08-19 11:33:10 -0700268 LogMethodTraceEvent(thread, *old_it, instrumentation::Instrumentation::kMethodExited,
269 thread_clock_diff, wall_clock_diff);
Jeff Hao0abc72e2013-08-13 13:45:14 -0700270 }
271 // Iterate bottom-up over the new trace from the point where they differ, emitting entry events.
272 for (; rit != stack_trace->rend(); ++rit) {
Jeff Haoc1ff4b72013-08-19 11:33:10 -0700273 LogMethodTraceEvent(thread, *rit, instrumentation::Instrumentation::kMethodEntered,
274 thread_clock_diff, wall_clock_diff);
Jeff Hao0abc72e2013-08-13 13:45:14 -0700275 }
Jeff Hao5ce4b172013-08-16 16:27:18 -0700276 FreeStackTrace(old_stack_trace);
Jeff Hao0abc72e2013-08-13 13:45:14 -0700277 }
278}
279
280void* Trace::RunSamplingThread(void* arg) {
281 Runtime* runtime = Runtime::Current();
Ian Rogersef7d42f2014-01-06 12:55:46 -0800282 intptr_t interval_us = reinterpret_cast<intptr_t>(arg);
Jeff Hao4044bda2014-01-06 15:50:45 -0800283 CHECK_GE(interval_us, 0);
Jeff Hao0abc72e2013-08-13 13:45:14 -0700284 CHECK(runtime->AttachCurrentThread("Sampling Profiler", true, runtime->GetSystemThreadGroup(),
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800285 !runtime->IsAotCompiler()));
Jeff Hao0abc72e2013-08-13 13:45:14 -0700286
287 while (true) {
Jeff Hao23009dc2013-08-22 15:36:42 -0700288 usleep(interval_us);
Jeff Hao5ce4b172013-08-16 16:27:18 -0700289 ATRACE_BEGIN("Profile sampling");
Jeff Hao0abc72e2013-08-13 13:45:14 -0700290 Thread* self = Thread::Current();
291 Trace* the_trace;
292 {
293 MutexLock mu(self, *Locks::trace_lock_);
294 the_trace = the_trace_;
Andreas Gampe40da2862015-02-27 12:49:04 -0800295 if (the_trace == nullptr) {
Jeff Hao0abc72e2013-08-13 13:45:14 -0700296 break;
297 }
298 }
Jeff Hao0abc72e2013-08-13 13:45:14 -0700299 {
Mathieu Chartier4f55e222015-09-04 13:26:21 -0700300 ScopedSuspendAll ssa(__FUNCTION__);
Jeff Hao0abc72e2013-08-13 13:45:14 -0700301 MutexLock mu(self, *Locks::thread_list_lock_);
302 runtime->GetThreadList()->ForEach(GetSample, the_trace);
303 }
Jeff Hao5ce4b172013-08-16 16:27:18 -0700304 ATRACE_END();
Jeff Hao0abc72e2013-08-13 13:45:14 -0700305 }
306
307 runtime->DetachCurrentThread();
Andreas Gampe40da2862015-02-27 12:49:04 -0800308 return nullptr;
Jeff Hao0abc72e2013-08-13 13:45:14 -0700309}
310
Andreas Gampee34a42c2015-04-25 14:44:29 -0700311void Trace::Start(const char* trace_filename, int trace_fd, size_t buffer_size, int flags,
Andreas Gampe7e7e0f42015-03-29 15:26:23 -0700312 TraceOutputMode output_mode, TraceMode trace_mode, int interval_us) {
Ian Rogers62d6c772013-02-27 08:32:07 -0800313 Thread* self = Thread::Current();
314 {
315 MutexLock mu(self, *Locks::trace_lock_);
Andreas Gampe40da2862015-02-27 12:49:04 -0800316 if (the_trace_ != nullptr) {
Ian Rogers62d6c772013-02-27 08:32:07 -0800317 LOG(ERROR) << "Trace already in progress, ignoring this request";
318 return;
319 }
jeffhaoe343b762011-12-05 16:36:44 -0800320 }
Jeff Haod063d912014-09-08 09:38:18 -0700321
322 // Check interval if sampling is enabled
Andreas Gampe7e7e0f42015-03-29 15:26:23 -0700323 if (trace_mode == TraceMode::kSampling && interval_us <= 0) {
Jeff Haod063d912014-09-08 09:38:18 -0700324 LOG(ERROR) << "Invalid sampling interval: " << interval_us;
325 ScopedObjectAccess soa(self);
326 ThrowRuntimeException("Invalid sampling interval: %d", interval_us);
327 return;
328 }
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800329
jeffhao2692b572011-12-16 15:42:28 -0800330 // Open trace file if not going directly to ddms.
Ian Rogers700a4022014-05-19 16:49:03 -0700331 std::unique_ptr<File> trace_file;
Andreas Gampe7e7e0f42015-03-29 15:26:23 -0700332 if (output_mode != TraceOutputMode::kDDMS) {
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800333 if (trace_fd < 0) {
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700334 trace_file.reset(OS::CreateEmptyFile(trace_filename));
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800335 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -0800336 trace_file.reset(new File(trace_fd, "tracefile"));
Elliott Hughes76160052012-12-12 16:31:20 -0800337 trace_file->DisableAutoClose();
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800338 }
Andreas Gampe40da2862015-02-27 12:49:04 -0800339 if (trace_file.get() == nullptr) {
jeffhaob5e81852012-03-12 11:15:45 -0700340 PLOG(ERROR) << "Unable to open trace file '" << trace_filename << "'";
Ian Rogers62d6c772013-02-27 08:32:07 -0800341 ScopedObjectAccess soa(self);
342 ThrowRuntimeException("Unable to open trace file '%s'", trace_filename);
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800343 return;
344 }
345 }
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800346
Jeff Haod063d912014-09-08 09:38:18 -0700347 Runtime* runtime = Runtime::Current();
Mathieu Chartier9ef78b52014-09-25 17:03:12 -0700348
349 // Enable count of allocs if specified in the flags.
350 bool enable_stats = false;
351
jeffhao2692b572011-12-16 15:42:28 -0800352 // Create Trace object.
Ian Rogers62d6c772013-02-27 08:32:07 -0800353 {
Mathieu Chartieraa516822015-10-02 15:53:37 -0700354 // Required since EnableMethodTracing calls ConfigureStubs which visits class linker classes.
355 gc::ScopedGCCriticalSection gcs(self,
356 gc::kGcCauseInstrumentation,
357 gc::kCollectorTypeInstrumentation);
Mathieu Chartier4f55e222015-09-04 13:26:21 -0700358 ScopedSuspendAll ssa(__FUNCTION__);
Ian Rogers62d6c772013-02-27 08:32:07 -0800359 MutexLock mu(self, *Locks::trace_lock_);
Andreas Gampe40da2862015-02-27 12:49:04 -0800360 if (the_trace_ != nullptr) {
Ian Rogers62d6c772013-02-27 08:32:07 -0800361 LOG(ERROR) << "Trace already in progress, ignoring this request";
362 } else {
Mathieu Chartier9ef78b52014-09-25 17:03:12 -0700363 enable_stats = (flags && kTraceCountAllocs) != 0;
Andreas Gampe40da2862015-02-27 12:49:04 -0800364 the_trace_ = new Trace(trace_file.release(), trace_filename, buffer_size, flags, output_mode,
365 trace_mode);
Andreas Gampe7e7e0f42015-03-29 15:26:23 -0700366 if (trace_mode == TraceMode::kSampling) {
Andreas Gampe40da2862015-02-27 12:49:04 -0800367 CHECK_PTHREAD_CALL(pthread_create, (&sampling_pthread_, nullptr, &RunSamplingThread,
Jeff Hao23009dc2013-08-22 15:36:42 -0700368 reinterpret_cast<void*>(interval_us)),
369 "Sampling profiler thread");
Andreas Gampe40da2862015-02-27 12:49:04 -0800370 the_trace_->interval_us_ = interval_us;
Jeff Hao0abc72e2013-08-13 13:45:14 -0700371 } else {
372 runtime->GetInstrumentation()->AddListener(the_trace_,
373 instrumentation::Instrumentation::kMethodEntered |
374 instrumentation::Instrumentation::kMethodExited |
375 instrumentation::Instrumentation::kMethodUnwind);
Andreas Gampe40da2862015-02-27 12:49:04 -0800376 // TODO: In full-PIC mode, we don't need to fully deopt.
Sebastien Hertz0462c4c2015-04-01 16:34:17 +0200377 runtime->GetInstrumentation()->EnableMethodTracing(kTracerInstrumentationKey);
Jeff Hao0abc72e2013-08-13 13:45:14 -0700378 }
Ian Rogers62d6c772013-02-27 08:32:07 -0800379 }
jeffhao0791adc2012-04-04 11:14:32 -0700380 }
Jeff Haod063d912014-09-08 09:38:18 -0700381
Mathieu Chartier9ef78b52014-09-25 17:03:12 -0700382 // Can't call this when holding the mutator lock.
383 if (enable_stats) {
384 runtime->SetStatsEnabled(true);
385 }
jeffhao2692b572011-12-16 15:42:28 -0800386}
387
Andreas Gampe40da2862015-02-27 12:49:04 -0800388void Trace::StopTracing(bool finish_tracing, bool flush_file) {
Mathieu Chartier9ef78b52014-09-25 17:03:12 -0700389 bool stop_alloc_counting = false;
Mathieu Chartier02e5f162015-03-11 09:54:22 -0700390 Runtime* const runtime = Runtime::Current();
391 Trace* the_trace = nullptr;
Jeff Hao0abc72e2013-08-13 13:45:14 -0700392 pthread_t sampling_pthread = 0U;
Ian Rogers62d6c772013-02-27 08:32:07 -0800393 {
394 MutexLock mu(Thread::Current(), *Locks::trace_lock_);
Andreas Gampe40da2862015-02-27 12:49:04 -0800395 if (the_trace_ == nullptr) {
Ian Rogers62d6c772013-02-27 08:32:07 -0800396 LOG(ERROR) << "Trace stop requested, but no trace currently running";
397 } else {
398 the_trace = the_trace_;
Andreas Gampe40da2862015-02-27 12:49:04 -0800399 the_trace_ = nullptr;
Jeff Hao0abc72e2013-08-13 13:45:14 -0700400 sampling_pthread = sampling_pthread_;
Ian Rogers62d6c772013-02-27 08:32:07 -0800401 }
jeffhao2692b572011-12-16 15:42:28 -0800402 }
Mathieu Chartier02e5f162015-03-11 09:54:22 -0700403 // Make sure that we join before we delete the trace since we don't want to have
404 // the sampling thread access a stale pointer. This finishes since the sampling thread exits when
405 // the_trace_ is null.
406 if (sampling_pthread != 0U) {
Andreas Gampe40da2862015-02-27 12:49:04 -0800407 CHECK_PTHREAD_CALL(pthread_join, (sampling_pthread, nullptr), "sampling thread shutdown");
Mathieu Chartier02e5f162015-03-11 09:54:22 -0700408 sampling_pthread_ = 0U;
409 }
Andreas Gampe40da2862015-02-27 12:49:04 -0800410
Mathieu Chartier4f55e222015-09-04 13:26:21 -0700411 {
412 ScopedSuspendAll ssa(__FUNCTION__);
413 if (the_trace != nullptr) {
414 stop_alloc_counting = (the_trace->flags_ & Trace::kTraceCountAllocs) != 0;
415 if (finish_tracing) {
416 the_trace->FinishTracing();
417 }
Jeff Hao0abc72e2013-08-13 13:45:14 -0700418
Mathieu Chartier4f55e222015-09-04 13:26:21 -0700419 if (the_trace->trace_mode_ == TraceMode::kSampling) {
420 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
421 runtime->GetThreadList()->ForEach(ClearThreadStackTraceAndClockBase, nullptr);
Andreas Gampe40da2862015-02-27 12:49:04 -0800422 } else {
Mathieu Chartier4f55e222015-09-04 13:26:21 -0700423 runtime->GetInstrumentation()->DisableMethodTracing(kTracerInstrumentationKey);
424 runtime->GetInstrumentation()->RemoveListener(
425 the_trace, instrumentation::Instrumentation::kMethodEntered |
426 instrumentation::Instrumentation::kMethodExited |
427 instrumentation::Instrumentation::kMethodUnwind);
Andreas Gampe4303ba92014-11-06 01:00:46 -0800428 }
Mathieu Chartier4f55e222015-09-04 13:26:21 -0700429 if (the_trace->trace_file_.get() != nullptr) {
430 // Do not try to erase, so flush and close explicitly.
431 if (flush_file) {
432 if (the_trace->trace_file_->Flush() != 0) {
433 PLOG(WARNING) << "Could not flush trace file.";
434 }
435 } else {
436 the_trace->trace_file_->MarkUnchecked(); // Do not trigger guard.
437 }
438 if (the_trace->trace_file_->Close() != 0) {
439 PLOG(ERROR) << "Could not close trace file.";
440 }
Andreas Gampe4303ba92014-11-06 01:00:46 -0800441 }
Mathieu Chartier4f55e222015-09-04 13:26:21 -0700442 delete the_trace;
Andreas Gampe4303ba92014-11-06 01:00:46 -0800443 }
Ian Rogers62d6c772013-02-27 08:32:07 -0800444 }
Mathieu Chartier9ef78b52014-09-25 17:03:12 -0700445 if (stop_alloc_counting) {
446 // Can be racy since SetStatsEnabled is not guarded by any locks.
Mathieu Chartier02e5f162015-03-11 09:54:22 -0700447 runtime->SetStatsEnabled(false);
Jeff Hao0abc72e2013-08-13 13:45:14 -0700448 }
jeffhao2692b572011-12-16 15:42:28 -0800449}
450
Andreas Gampe40da2862015-02-27 12:49:04 -0800451void Trace::Abort() {
452 // Do not write anything anymore.
453 StopTracing(false, false);
454}
455
456void Trace::Stop() {
457 // Finish writing.
458 StopTracing(true, true);
459}
460
jeffhaob5e81852012-03-12 11:15:45 -0700461void Trace::Shutdown() {
Jeff Hao64caa7d2013-08-29 11:18:01 -0700462 if (GetMethodTracingMode() != kTracingInactive) {
Ian Rogers62d6c772013-02-27 08:32:07 -0800463 Stop();
jeffhaob5e81852012-03-12 11:15:45 -0700464 }
jeffhaob5e81852012-03-12 11:15:45 -0700465}
466
Andreas Gampe40da2862015-02-27 12:49:04 -0800467void Trace::Pause() {
468 bool stop_alloc_counting = false;
469 Runtime* runtime = Runtime::Current();
470 Trace* the_trace = nullptr;
471
Mathieu Chartieraa516822015-10-02 15:53:37 -0700472 Thread* const self = Thread::Current();
Andreas Gampe40da2862015-02-27 12:49:04 -0800473 pthread_t sampling_pthread = 0U;
474 {
Mathieu Chartieraa516822015-10-02 15:53:37 -0700475 MutexLock mu(self, *Locks::trace_lock_);
Andreas Gampe40da2862015-02-27 12:49:04 -0800476 if (the_trace_ == nullptr) {
477 LOG(ERROR) << "Trace pause requested, but no trace currently running";
478 return;
479 } else {
480 the_trace = the_trace_;
481 sampling_pthread = sampling_pthread_;
482 }
483 }
484
485 if (sampling_pthread != 0U) {
486 {
Mathieu Chartieraa516822015-10-02 15:53:37 -0700487 MutexLock mu(self, *Locks::trace_lock_);
Andreas Gampe40da2862015-02-27 12:49:04 -0800488 the_trace_ = nullptr;
489 }
490 CHECK_PTHREAD_CALL(pthread_join, (sampling_pthread, nullptr), "sampling thread shutdown");
491 sampling_pthread_ = 0U;
492 {
Mathieu Chartieraa516822015-10-02 15:53:37 -0700493 MutexLock mu(self, *Locks::trace_lock_);
Andreas Gampe40da2862015-02-27 12:49:04 -0800494 the_trace_ = the_trace;
495 }
496 }
497
498 if (the_trace != nullptr) {
Mathieu Chartieraa516822015-10-02 15:53:37 -0700499 gc::ScopedGCCriticalSection gcs(self,
500 gc::kGcCauseInstrumentation,
501 gc::kCollectorTypeInstrumentation);
Mathieu Chartier4f55e222015-09-04 13:26:21 -0700502 ScopedSuspendAll ssa(__FUNCTION__);
Andreas Gampe40da2862015-02-27 12:49:04 -0800503 stop_alloc_counting = (the_trace->flags_ & Trace::kTraceCountAllocs) != 0;
504
505 if (the_trace->trace_mode_ == TraceMode::kSampling) {
Mathieu Chartieraa516822015-10-02 15:53:37 -0700506 MutexLock mu(self, *Locks::thread_list_lock_);
Andreas Gampe40da2862015-02-27 12:49:04 -0800507 runtime->GetThreadList()->ForEach(ClearThreadStackTraceAndClockBase, nullptr);
508 } else {
Sebastien Hertz0462c4c2015-04-01 16:34:17 +0200509 runtime->GetInstrumentation()->DisableMethodTracing(kTracerInstrumentationKey);
Mathieu Chartier4f55e222015-09-04 13:26:21 -0700510 runtime->GetInstrumentation()->RemoveListener(
511 the_trace,
512 instrumentation::Instrumentation::kMethodEntered |
513 instrumentation::Instrumentation::kMethodExited |
514 instrumentation::Instrumentation::kMethodUnwind);
Andreas Gampe40da2862015-02-27 12:49:04 -0800515 }
Andreas Gampe40da2862015-02-27 12:49:04 -0800516 }
517
518 if (stop_alloc_counting) {
519 // Can be racy since SetStatsEnabled is not guarded by any locks.
520 Runtime::Current()->SetStatsEnabled(false);
521 }
522}
523
524void Trace::Resume() {
525 Thread* self = Thread::Current();
526 Trace* the_trace;
527 {
528 MutexLock mu(self, *Locks::trace_lock_);
529 if (the_trace_ == nullptr) {
530 LOG(ERROR) << "No trace to resume (or sampling mode), ignoring this request";
531 return;
532 }
533 the_trace = the_trace_;
534 }
535
536 Runtime* runtime = Runtime::Current();
537
538 // Enable count of allocs if specified in the flags.
539 bool enable_stats = (the_trace->flags_ && kTraceCountAllocs) != 0;
540
Mathieu Chartier4f55e222015-09-04 13:26:21 -0700541 {
Mathieu Chartieraa516822015-10-02 15:53:37 -0700542 gc::ScopedGCCriticalSection gcs(self,
543 gc::kGcCauseInstrumentation,
544 gc::kCollectorTypeInstrumentation);
Mathieu Chartier4f55e222015-09-04 13:26:21 -0700545 ScopedSuspendAll ssa(__FUNCTION__);
Andreas Gampe40da2862015-02-27 12:49:04 -0800546
Mathieu Chartier4f55e222015-09-04 13:26:21 -0700547 // Reenable.
548 if (the_trace->trace_mode_ == TraceMode::kSampling) {
549 CHECK_PTHREAD_CALL(pthread_create, (&sampling_pthread_, nullptr, &RunSamplingThread,
550 reinterpret_cast<void*>(the_trace->interval_us_)), "Sampling profiler thread");
551 } else {
552 runtime->GetInstrumentation()->AddListener(the_trace,
553 instrumentation::Instrumentation::kMethodEntered |
554 instrumentation::Instrumentation::kMethodExited |
555 instrumentation::Instrumentation::kMethodUnwind);
556 // TODO: In full-PIC mode, we don't need to fully deopt.
557 runtime->GetInstrumentation()->EnableMethodTracing(kTracerInstrumentationKey);
558 }
Andreas Gampe40da2862015-02-27 12:49:04 -0800559 }
560
Andreas Gampe40da2862015-02-27 12:49:04 -0800561 // Can't call this when holding the mutator lock.
562 if (enable_stats) {
563 runtime->SetStatsEnabled(true);
564 }
565}
566
Jeff Hao64caa7d2013-08-29 11:18:01 -0700567TracingMode Trace::GetMethodTracingMode() {
Ian Rogers62d6c772013-02-27 08:32:07 -0800568 MutexLock mu(Thread::Current(), *Locks::trace_lock_);
Andreas Gampe40da2862015-02-27 12:49:04 -0800569 if (the_trace_ == nullptr) {
Jeff Hao64caa7d2013-08-29 11:18:01 -0700570 return kTracingInactive;
Jeff Hao64caa7d2013-08-29 11:18:01 -0700571 } else {
Andreas Gampe7e7e0f42015-03-29 15:26:23 -0700572 switch (the_trace_->trace_mode_) {
573 case TraceMode::kSampling:
574 return kSampleProfilingActive;
575 case TraceMode::kMethodTracing:
576 return kMethodTracingActive;
577 }
578 LOG(FATAL) << "Unreachable";
579 UNREACHABLE();
Jeff Hao64caa7d2013-08-29 11:18:01 -0700580 }
Ian Rogers62d6c772013-02-27 08:32:07 -0800581}
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800582
Andreas Gampee34a42c2015-04-25 14:44:29 -0700583static constexpr size_t kMinBufSize = 18U; // Trace header is up to 18B.
Andreas Gampe40da2862015-02-27 12:49:04 -0800584
Andreas Gampee34a42c2015-04-25 14:44:29 -0700585Trace::Trace(File* trace_file, const char* trace_name, size_t buffer_size, int flags,
Andreas Gampe40da2862015-02-27 12:49:04 -0800586 TraceOutputMode output_mode, TraceMode trace_mode)
587 : trace_file_(trace_file),
Andreas Gampee34a42c2015-04-25 14:44:29 -0700588 buf_(new uint8_t[std::max(kMinBufSize, buffer_size)]()),
Andreas Gampe40da2862015-02-27 12:49:04 -0800589 flags_(flags), trace_output_mode_(output_mode), trace_mode_(trace_mode),
590 clock_source_(default_clock_source_),
Andreas Gampee34a42c2015-04-25 14:44:29 -0700591 buffer_size_(std::max(kMinBufSize, buffer_size)),
Andreas Gampe40da2862015-02-27 12:49:04 -0800592 start_time_(MicroTime()), clock_overhead_ns_(GetClockOverheadNanoSeconds()), cur_offset_(0),
Mathieu Chartier4d64cd42015-06-02 16:38:29 -0700593 overflow_(false), interval_us_(0), streaming_lock_(nullptr),
Andreas Gampe7526d782015-06-22 22:53:45 -0700594 unique_methods_lock_(new Mutex("unique methods lock", kTracingUniqueMethodsLock)) {
Ian Rogers62d6c772013-02-27 08:32:07 -0800595 uint16_t trace_version = GetTraceVersion(clock_source_);
Andreas Gampe40da2862015-02-27 12:49:04 -0800596 if (output_mode == TraceOutputMode::kStreaming) {
597 trace_version |= 0xF0U;
598 }
599 // Set up the beginning of the trace.
jeffhao2692b572011-12-16 15:42:28 -0800600 memset(buf_.get(), 0, kTraceHeaderLength);
601 Append4LE(buf_.get(), kTraceMagicValue);
Ian Rogers62d6c772013-02-27 08:32:07 -0800602 Append2LE(buf_.get() + 4, trace_version);
jeffhao2692b572011-12-16 15:42:28 -0800603 Append2LE(buf_.get() + 6, kTraceHeaderLength);
604 Append8LE(buf_.get() + 8, start_time_);
Ian Rogers62d6c772013-02-27 08:32:07 -0800605 if (trace_version >= kTraceVersionDualClock) {
606 uint16_t record_size = GetRecordSize(clock_source_);
607 Append2LE(buf_.get() + 16, record_size);
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800608 }
Andreas Gampee34a42c2015-04-25 14:44:29 -0700609 static_assert(18 <= kMinBufSize, "Minimum buffer size not large enough for trace header");
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800610
jeffhao2692b572011-12-16 15:42:28 -0800611 // Update current offset.
Ian Rogers8ab25ef2014-07-09 18:00:50 -0700612 cur_offset_.StoreRelaxed(kTraceHeaderLength);
Andreas Gampe40da2862015-02-27 12:49:04 -0800613
614 if (output_mode == TraceOutputMode::kStreaming) {
615 streaming_file_name_ = trace_name;
Andreas Gampe7526d782015-06-22 22:53:45 -0700616 streaming_lock_ = new Mutex("tracing lock", LockLevel::kTracingStreamingLock);
Andreas Gampe40da2862015-02-27 12:49:04 -0800617 seen_threads_.reset(new ThreadIDBitSet());
618 }
619}
620
621Trace::~Trace() {
622 delete streaming_lock_;
Andreas Gampe7526d782015-06-22 22:53:45 -0700623 delete unique_methods_lock_;
Ian Rogers62d6c772013-02-27 08:32:07 -0800624}
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800625
Mathieu Chartiere401d142015-04-22 13:56:20 -0700626static uint64_t ReadBytes(uint8_t* buf, size_t bytes) {
627 uint64_t ret = 0;
628 for (size_t i = 0; i < bytes; ++i) {
629 ret |= static_cast<uint64_t>(buf[i]) << (i * 8);
630 }
631 return ret;
632}
633
Mathieu Chartier4d64cd42015-06-02 16:38:29 -0700634void Trace::DumpBuf(uint8_t* buf, size_t buf_size, TraceClockSource clock_source) {
Ian Rogers62d6c772013-02-27 08:32:07 -0800635 uint8_t* ptr = buf + kTraceHeaderLength;
636 uint8_t* end = buf + buf_size;
637
638 while (ptr < end) {
Mathieu Chartier4d64cd42015-06-02 16:38:29 -0700639 uint32_t tmid = ReadBytes(ptr + 2, sizeof(tmid));
640 ArtMethod* method = DecodeTraceMethod(tmid);
Ian Rogers62d6c772013-02-27 08:32:07 -0800641 TraceAction action = DecodeTraceAction(tmid);
642 LOG(INFO) << PrettyMethod(method) << " " << static_cast<int>(action);
643 ptr += GetRecordSize(clock_source);
644 }
jeffhaoe343b762011-12-05 16:36:44 -0800645}
646
Andreas Gampe40da2862015-02-27 12:49:04 -0800647static void GetVisitedMethodsFromBitSets(
Andreas Gampe7526d782015-06-22 22:53:45 -0700648 const std::map<const DexFile*, DexIndexBitSet*>& seen_methods,
Mathieu Chartier90443472015-07-16 20:32:27 -0700649 std::set<ArtMethod*>* visited_methods) SHARED_REQUIRES(Locks::mutator_lock_) {
Andreas Gampe7526d782015-06-22 22:53:45 -0700650 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Mathieu Chartier673ed3d2015-08-28 14:56:43 -0700651 Thread* const self = Thread::Current();
Andreas Gampe40da2862015-02-27 12:49:04 -0800652 for (auto& e : seen_methods) {
653 DexIndexBitSet* bit_set = e.second;
Mathieu Chartier673ed3d2015-08-28 14:56:43 -0700654 // TODO: Visit trace methods as roots.
655 mirror::DexCache* dex_cache = class_linker->FindDexCache(self, *e.first, false);
Andreas Gampe40da2862015-02-27 12:49:04 -0800656 for (uint32_t i = 0; i < bit_set->size(); ++i) {
657 if ((*bit_set)[i]) {
Andreas Gampe7526d782015-06-22 22:53:45 -0700658 visited_methods->insert(dex_cache->GetResolvedMethod(i, sizeof(void*)));
Andreas Gampe40da2862015-02-27 12:49:04 -0800659 }
660 }
661 }
662}
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800663
Andreas Gampe40da2862015-02-27 12:49:04 -0800664void Trace::FinishTracing() {
665 size_t final_offset = 0;
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800666
Mathieu Chartiere401d142015-04-22 13:56:20 -0700667 std::set<ArtMethod*> visited_methods;
Andreas Gampe40da2862015-02-27 12:49:04 -0800668 if (trace_output_mode_ == TraceOutputMode::kStreaming) {
669 // Write the secondary file with all the method names.
670 GetVisitedMethodsFromBitSets(seen_methods_, &visited_methods);
671
672 // Clean up.
Mathieu Chartier4d64cd42015-06-02 16:38:29 -0700673 STLDeleteValues(&seen_methods_);
Andreas Gampe40da2862015-02-27 12:49:04 -0800674 } else {
675 final_offset = cur_offset_.LoadRelaxed();
676 GetVisitedMethods(final_offset, &visited_methods);
677 }
678
679 // Compute elapsed time.
680 uint64_t elapsed = MicroTime() - start_time_;
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800681
682 std::ostringstream os;
683
684 os << StringPrintf("%cversion\n", kTraceTokenChar);
Ian Rogers62d6c772013-02-27 08:32:07 -0800685 os << StringPrintf("%d\n", GetTraceVersion(clock_source_));
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800686 os << StringPrintf("data-file-overflow=%s\n", overflow_ ? "true" : "false");
687 if (UseThreadCpuClock()) {
688 if (UseWallClock()) {
689 os << StringPrintf("clock=dual\n");
690 } else {
691 os << StringPrintf("clock=thread-cpu\n");
692 }
693 } else {
694 os << StringPrintf("clock=wall\n");
695 }
Ian Rogersef7d42f2014-01-06 12:55:46 -0800696 os << StringPrintf("elapsed-time-usec=%" PRIu64 "\n", elapsed);
Andreas Gampe40da2862015-02-27 12:49:04 -0800697 if (trace_output_mode_ != TraceOutputMode::kStreaming) {
698 size_t num_records = (final_offset - kTraceHeaderLength) / GetRecordSize(clock_source_);
699 os << StringPrintf("num-method-calls=%zd\n", num_records);
700 }
Jeff Haoc5d824a2014-07-28 18:35:38 -0700701 os << StringPrintf("clock-call-overhead-nsec=%d\n", clock_overhead_ns_);
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800702 os << StringPrintf("vm=art\n");
John Reck0624a272015-03-26 15:47:54 -0700703 os << StringPrintf("pid=%d\n", getpid());
jeffhao0791adc2012-04-04 11:14:32 -0700704 if ((flags_ & kTraceCountAllocs) != 0) {
705 os << StringPrintf("alloc-count=%d\n", Runtime::Current()->GetStat(KIND_ALLOCATED_OBJECTS));
706 os << StringPrintf("alloc-size=%d\n", Runtime::Current()->GetStat(KIND_ALLOCATED_BYTES));
707 os << StringPrintf("gc-count=%d\n", Runtime::Current()->GetStat(KIND_GC_INVOCATIONS));
708 }
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800709 os << StringPrintf("%cthreads\n", kTraceTokenChar);
710 DumpThreadList(os);
711 os << StringPrintf("%cmethods\n", kTraceTokenChar);
Ian Rogers62d6c772013-02-27 08:32:07 -0800712 DumpMethodList(os, visited_methods);
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800713 os << StringPrintf("%cend\n", kTraceTokenChar);
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800714 std::string header(os.str());
Andreas Gampe40da2862015-02-27 12:49:04 -0800715
716 if (trace_output_mode_ == TraceOutputMode::kStreaming) {
717 File file;
718 if (!file.Open(streaming_file_name_ + ".sec", O_CREAT | O_WRONLY)) {
719 LOG(WARNING) << "Could not open secondary trace file!";
720 return;
Ian Rogers62d6c772013-02-27 08:32:07 -0800721 }
Andreas Gampe40da2862015-02-27 12:49:04 -0800722 if (!file.WriteFully(header.c_str(), header.length())) {
723 file.Erase();
Elliott Hughes7b9d9962012-04-20 18:48:18 -0700724 std::string detail(StringPrintf("Trace data write failed: %s", strerror(errno)));
725 PLOG(ERROR) << detail;
Ian Rogers62d6c772013-02-27 08:32:07 -0800726 ThrowRuntimeException("%s", detail.c_str());
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800727 }
Andreas Gampe40da2862015-02-27 12:49:04 -0800728 if (file.FlushCloseOrErase() != 0) {
729 PLOG(ERROR) << "Could not write secondary file";
730 }
731 } else {
732 if (trace_file_.get() == nullptr) {
733 iovec iov[2];
734 iov[0].iov_base = reinterpret_cast<void*>(const_cast<char*>(header.c_str()));
735 iov[0].iov_len = header.length();
736 iov[1].iov_base = buf_.get();
737 iov[1].iov_len = final_offset;
738 Dbg::DdmSendChunkV(CHUNK_TYPE("MPSE"), iov, 2);
739 const bool kDumpTraceInfo = false;
740 if (kDumpTraceInfo) {
741 LOG(INFO) << "Trace sent:\n" << header;
742 DumpBuf(buf_.get(), final_offset, clock_source_);
743 }
744 } else {
745 if (!trace_file_->WriteFully(header.c_str(), header.length()) ||
746 !trace_file_->WriteFully(buf_.get(), final_offset)) {
747 std::string detail(StringPrintf("Trace data write failed: %s", strerror(errno)));
748 PLOG(ERROR) << detail;
749 ThrowRuntimeException("%s", detail.c_str());
750 }
751 }
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800752 }
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800753}
754
Roland Levillain4b8f1ec2015-08-26 18:34:03 +0100755void Trace::DexPcMoved(Thread* thread ATTRIBUTE_UNUSED,
756 mirror::Object* this_object ATTRIBUTE_UNUSED,
757 ArtMethod* method,
758 uint32_t new_dex_pc) {
Ian Rogers62d6c772013-02-27 08:32:07 -0800759 // We're not recorded to listen to this kind of event, so complain.
760 LOG(ERROR) << "Unexpected dex PC event in tracing " << PrettyMethod(method) << " " << new_dex_pc;
Andreas Gampec8ccf682014-09-29 20:07:43 -0700761}
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800762
Roland Levillain4b8f1ec2015-08-26 18:34:03 +0100763void Trace::FieldRead(Thread* thread ATTRIBUTE_UNUSED,
764 mirror::Object* this_object ATTRIBUTE_UNUSED,
765 ArtMethod* method,
766 uint32_t dex_pc,
767 ArtField* field ATTRIBUTE_UNUSED)
Mathieu Chartier90443472015-07-16 20:32:27 -0700768 SHARED_REQUIRES(Locks::mutator_lock_) {
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +0200769 // We're not recorded to listen to this kind of event, so complain.
770 LOG(ERROR) << "Unexpected field read event in tracing " << PrettyMethod(method) << " " << dex_pc;
771}
772
Roland Levillain4b8f1ec2015-08-26 18:34:03 +0100773void Trace::FieldWritten(Thread* thread ATTRIBUTE_UNUSED,
774 mirror::Object* this_object ATTRIBUTE_UNUSED,
775 ArtMethod* method,
776 uint32_t dex_pc,
777 ArtField* field ATTRIBUTE_UNUSED,
778 const JValue& field_value ATTRIBUTE_UNUSED)
Mathieu Chartier90443472015-07-16 20:32:27 -0700779 SHARED_REQUIRES(Locks::mutator_lock_) {
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +0200780 // We're not recorded to listen to this kind of event, so complain.
781 LOG(ERROR) << "Unexpected field write event in tracing " << PrettyMethod(method) << " " << dex_pc;
782}
783
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700784void Trace::MethodEntered(Thread* thread, mirror::Object* this_object ATTRIBUTE_UNUSED,
Mathieu Chartiere401d142015-04-22 13:56:20 -0700785 ArtMethod* method, uint32_t dex_pc ATTRIBUTE_UNUSED) {
Jeff Haoc1ff4b72013-08-19 11:33:10 -0700786 uint32_t thread_clock_diff = 0;
787 uint32_t wall_clock_diff = 0;
788 ReadClocks(thread, &thread_clock_diff, &wall_clock_diff);
789 LogMethodTraceEvent(thread, method, instrumentation::Instrumentation::kMethodEntered,
790 thread_clock_diff, wall_clock_diff);
Ian Rogers62d6c772013-02-27 08:32:07 -0800791}
792
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700793void Trace::MethodExited(Thread* thread, mirror::Object* this_object ATTRIBUTE_UNUSED,
Mathieu Chartiere401d142015-04-22 13:56:20 -0700794 ArtMethod* method, uint32_t dex_pc ATTRIBUTE_UNUSED,
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700795 const JValue& return_value ATTRIBUTE_UNUSED) {
Jeff Haoc1ff4b72013-08-19 11:33:10 -0700796 uint32_t thread_clock_diff = 0;
797 uint32_t wall_clock_diff = 0;
798 ReadClocks(thread, &thread_clock_diff, &wall_clock_diff);
799 LogMethodTraceEvent(thread, method, instrumentation::Instrumentation::kMethodExited,
800 thread_clock_diff, wall_clock_diff);
Ian Rogers62d6c772013-02-27 08:32:07 -0800801}
802
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700803void Trace::MethodUnwind(Thread* thread, mirror::Object* this_object ATTRIBUTE_UNUSED,
Mathieu Chartiere401d142015-04-22 13:56:20 -0700804 ArtMethod* method, uint32_t dex_pc ATTRIBUTE_UNUSED) {
Jeff Haoc1ff4b72013-08-19 11:33:10 -0700805 uint32_t thread_clock_diff = 0;
806 uint32_t wall_clock_diff = 0;
807 ReadClocks(thread, &thread_clock_diff, &wall_clock_diff);
808 LogMethodTraceEvent(thread, method, instrumentation::Instrumentation::kMethodUnwind,
809 thread_clock_diff, wall_clock_diff);
Ian Rogers62d6c772013-02-27 08:32:07 -0800810}
811
Roland Levillain4b8f1ec2015-08-26 18:34:03 +0100812void Trace::ExceptionCaught(Thread* thread ATTRIBUTE_UNUSED,
813 mirror::Throwable* exception_object ATTRIBUTE_UNUSED)
Mathieu Chartier90443472015-07-16 20:32:27 -0700814 SHARED_REQUIRES(Locks::mutator_lock_) {
Ian Rogers62d6c772013-02-27 08:32:07 -0800815 LOG(ERROR) << "Unexpected exception caught event in tracing";
816}
817
Mathieu Chartiere401d142015-04-22 13:56:20 -0700818void Trace::BackwardBranch(Thread* /*thread*/, ArtMethod* method,
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800819 int32_t /*dex_pc_offset*/)
Mathieu Chartier90443472015-07-16 20:32:27 -0700820 SHARED_REQUIRES(Locks::mutator_lock_) {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800821 LOG(ERROR) << "Unexpected backward branch event in tracing" << PrettyMethod(method);
822}
823
Nicolas Geoffray5550ca82015-08-21 18:38:30 +0100824void Trace::InvokeVirtualOrInterface(Thread*,
825 mirror::Object*,
826 ArtMethod* method,
827 uint32_t dex_pc,
828 ArtMethod*) {
829 LOG(ERROR) << "Unexpected invoke event in tracing" << PrettyMethod(method)
830 << " " << dex_pc;
831}
832
Jeff Haoc1ff4b72013-08-19 11:33:10 -0700833void Trace::ReadClocks(Thread* thread, uint32_t* thread_clock_diff, uint32_t* wall_clock_diff) {
834 if (UseThreadCpuClock()) {
835 uint64_t clock_base = thread->GetTraceClockBase();
836 if (UNLIKELY(clock_base == 0)) {
837 // First event, record the base time in the map.
838 uint64_t time = thread->GetCpuMicroTime();
839 thread->SetTraceClockBase(time);
840 } else {
841 *thread_clock_diff = thread->GetCpuMicroTime() - clock_base;
842 }
843 }
844 if (UseWallClock()) {
845 *wall_clock_diff = MicroTime() - start_time_;
846 }
847}
848
Mathieu Chartiere401d142015-04-22 13:56:20 -0700849bool Trace::RegisterMethod(ArtMethod* method) {
Andreas Gampe40da2862015-02-27 12:49:04 -0800850 mirror::DexCache* dex_cache = method->GetDexCache();
Andreas Gampe7526d782015-06-22 22:53:45 -0700851 const DexFile* dex_file = dex_cache->GetDexFile();
Mathieu Chartiere401d142015-04-22 13:56:20 -0700852 auto* resolved_method = dex_cache->GetResolvedMethod(method->GetDexMethodIndex(), sizeof(void*));
853 if (resolved_method != method) {
854 DCHECK(resolved_method == nullptr);
855 dex_cache->SetResolvedMethod(method->GetDexMethodIndex(), method, sizeof(void*));
Andreas Gampe40da2862015-02-27 12:49:04 -0800856 }
Andreas Gampe7526d782015-06-22 22:53:45 -0700857 if (seen_methods_.find(dex_file) == seen_methods_.end()) {
858 seen_methods_.insert(std::make_pair(dex_file, new DexIndexBitSet()));
Andreas Gampe40da2862015-02-27 12:49:04 -0800859 }
Andreas Gampe7526d782015-06-22 22:53:45 -0700860 DexIndexBitSet* bit_set = seen_methods_.find(dex_file)->second;
Andreas Gampe40da2862015-02-27 12:49:04 -0800861 if (!(*bit_set)[method->GetDexMethodIndex()]) {
862 bit_set->set(method->GetDexMethodIndex());
863 return true;
864 }
865 return false;
866}
867
868bool Trace::RegisterThread(Thread* thread) {
869 pid_t tid = thread->GetTid();
870 CHECK_LT(0U, static_cast<uint32_t>(tid));
871 CHECK_LT(static_cast<uint32_t>(tid), 65536U);
872
873 if (!(*seen_threads_)[tid]) {
874 seen_threads_->set(tid);
875 return true;
876 }
877 return false;
878}
879
Mathieu Chartier4d64cd42015-06-02 16:38:29 -0700880std::string Trace::GetMethodLine(ArtMethod* method) {
Mathieu Chartiere3b034a2015-05-31 14:29:23 -0700881 method = method->GetInterfaceMethodIfProxy(sizeof(void*));
Mathieu Chartier4d64cd42015-06-02 16:38:29 -0700882 return StringPrintf("%p\t%s\t%s\t%s\t%s\n",
883 reinterpret_cast<void*>((EncodeTraceMethod(method) << TraceActionBits)),
Andreas Gampe40da2862015-02-27 12:49:04 -0800884 PrettyDescriptor(method->GetDeclaringClassDescriptor()).c_str(), method->GetName(),
885 method->GetSignature().ToString().c_str(), method->GetDeclaringClassSourceFile());
886}
887
888void Trace::WriteToBuf(const uint8_t* src, size_t src_size) {
889 int32_t old_offset = cur_offset_.LoadRelaxed();
890 int32_t new_offset = old_offset + static_cast<int32_t>(src_size);
Andreas Gampee34a42c2015-04-25 14:44:29 -0700891 if (dchecked_integral_cast<size_t>(new_offset) > buffer_size_) {
Andreas Gampe40da2862015-02-27 12:49:04 -0800892 // Flush buffer.
893 if (!trace_file_->WriteFully(buf_.get(), old_offset)) {
894 PLOG(WARNING) << "Failed streaming a tracing event.";
895 }
Andreas Gampee34a42c2015-04-25 14:44:29 -0700896
897 // Check whether the data is too large for the buffer, then write immediately.
898 if (src_size >= buffer_size_) {
899 if (!trace_file_->WriteFully(src, src_size)) {
900 PLOG(WARNING) << "Failed streaming a tracing event.";
901 }
902 cur_offset_.StoreRelease(0); // Buffer is empty now.
903 return;
904 }
905
Andreas Gampe40da2862015-02-27 12:49:04 -0800906 old_offset = 0;
907 new_offset = static_cast<int32_t>(src_size);
908 }
909 cur_offset_.StoreRelease(new_offset);
910 // Fill in data.
911 memcpy(buf_.get() + old_offset, src, src_size);
912}
913
Mathieu Chartiere401d142015-04-22 13:56:20 -0700914void Trace::LogMethodTraceEvent(Thread* thread, ArtMethod* method,
Jeff Haoc1ff4b72013-08-19 11:33:10 -0700915 instrumentation::Instrumentation::InstrumentationEvent event,
916 uint32_t thread_clock_diff, uint32_t wall_clock_diff) {
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800917 // Advance cur_offset_ atomically.
918 int32_t new_offset;
Andreas Gampe40da2862015-02-27 12:49:04 -0800919 int32_t old_offset = 0;
920
921 // We do a busy loop here trying to acquire the next offset.
922 if (trace_output_mode_ != TraceOutputMode::kStreaming) {
923 do {
924 old_offset = cur_offset_.LoadRelaxed();
925 new_offset = old_offset + GetRecordSize(clock_source_);
Andreas Gampee34a42c2015-04-25 14:44:29 -0700926 if (static_cast<size_t>(new_offset) > buffer_size_) {
Andreas Gampe40da2862015-02-27 12:49:04 -0800927 overflow_ = true;
928 return;
929 }
930 } while (!cur_offset_.CompareExchangeWeakSequentiallyConsistent(old_offset, new_offset));
931 }
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800932
Ian Rogers62d6c772013-02-27 08:32:07 -0800933 TraceAction action = kTraceMethodEnter;
934 switch (event) {
935 case instrumentation::Instrumentation::kMethodEntered:
936 action = kTraceMethodEnter;
937 break;
938 case instrumentation::Instrumentation::kMethodExited:
939 action = kTraceMethodExit;
940 break;
941 case instrumentation::Instrumentation::kMethodUnwind:
942 action = kTraceUnroll;
943 break;
944 default:
945 UNIMPLEMENTED(FATAL) << "Unexpected event: " << event;
946 }
947
Mathieu Chartier4d64cd42015-06-02 16:38:29 -0700948 uint32_t method_value = EncodeTraceMethodAndAction(method, action);
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800949
950 // Write data
Andreas Gampe40da2862015-02-27 12:49:04 -0800951 uint8_t* ptr;
Mathieu Chartier4d64cd42015-06-02 16:38:29 -0700952 static constexpr size_t kPacketSize = 14U; // The maximum size of data in a packet.
Andreas Gampe40da2862015-02-27 12:49:04 -0800953 uint8_t stack_buf[kPacketSize]; // Space to store a packet when in streaming mode.
954 if (trace_output_mode_ == TraceOutputMode::kStreaming) {
955 ptr = stack_buf;
956 } else {
957 ptr = buf_.get() + old_offset;
958 }
959
Ian Rogers62d6c772013-02-27 08:32:07 -0800960 Append2LE(ptr, thread->GetTid());
Mathieu Chartier4d64cd42015-06-02 16:38:29 -0700961 Append4LE(ptr + 2, method_value);
962 ptr += 6;
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800963
964 if (UseThreadCpuClock()) {
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800965 Append4LE(ptr, thread_clock_diff);
966 ptr += 4;
967 }
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800968 if (UseWallClock()) {
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800969 Append4LE(ptr, wall_clock_diff);
970 }
Mathieu Chartier4d64cd42015-06-02 16:38:29 -0700971 static_assert(kPacketSize == 2 + 4 + 4 + 4, "Packet size incorrect.");
Andreas Gampe40da2862015-02-27 12:49:04 -0800972
973 if (trace_output_mode_ == TraceOutputMode::kStreaming) {
974 MutexLock mu(Thread::Current(), *streaming_lock_); // To serialize writing.
975 if (RegisterMethod(method)) {
976 // Write a special block with the name.
977 std::string method_line(GetMethodLine(method));
978 uint8_t buf2[5];
979 Append2LE(buf2, 0);
980 buf2[2] = kOpNewMethod;
981 Append2LE(buf2 + 3, static_cast<uint16_t>(method_line.length()));
982 WriteToBuf(buf2, sizeof(buf2));
983 WriteToBuf(reinterpret_cast<const uint8_t*>(method_line.c_str()), method_line.length());
984 }
985 if (RegisterThread(thread)) {
986 // It might be better to postpone this. Threads might not have received names...
987 std::string thread_name;
988 thread->GetThreadName(thread_name);
989 uint8_t buf2[7];
990 Append2LE(buf2, 0);
991 buf2[2] = kOpNewThread;
992 Append2LE(buf2 + 3, static_cast<uint16_t>(thread->GetTid()));
993 Append2LE(buf2 + 5, static_cast<uint16_t>(thread_name.length()));
994 WriteToBuf(buf2, sizeof(buf2));
995 WriteToBuf(reinterpret_cast<const uint8_t*>(thread_name.c_str()), thread_name.length());
996 }
997 WriteToBuf(stack_buf, sizeof(stack_buf));
998 }
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800999}
1000
Ian Rogers62d6c772013-02-27 08:32:07 -08001001void Trace::GetVisitedMethods(size_t buf_size,
Mathieu Chartiere401d142015-04-22 13:56:20 -07001002 std::set<ArtMethod*>* visited_methods) {
jeffhao2692b572011-12-16 15:42:28 -08001003 uint8_t* ptr = buf_.get() + kTraceHeaderLength;
Ian Rogers62d6c772013-02-27 08:32:07 -08001004 uint8_t* end = buf_.get() + buf_size;
jeffhaoa9ef3fd2011-12-13 18:33:43 -08001005
1006 while (ptr < end) {
Mathieu Chartier4d64cd42015-06-02 16:38:29 -07001007 uint32_t tmid = ReadBytes(ptr + 2, sizeof(tmid));
1008 ArtMethod* method = DecodeTraceMethod(tmid);
Ian Rogers62d6c772013-02-27 08:32:07 -08001009 visited_methods->insert(method);
1010 ptr += GetRecordSize(clock_source_);
jeffhaoa9ef3fd2011-12-13 18:33:43 -08001011 }
1012}
1013
Mathieu Chartiere401d142015-04-22 13:56:20 -07001014void Trace::DumpMethodList(std::ostream& os, const std::set<ArtMethod*>& visited_methods) {
Mathieu Chartier02e25112013-08-14 16:14:24 -07001015 for (const auto& method : visited_methods) {
Andreas Gampe40da2862015-02-27 12:49:04 -08001016 os << GetMethodLine(method);
jeffhaoa9ef3fd2011-12-13 18:33:43 -08001017 }
jeffhaoa9ef3fd2011-12-13 18:33:43 -08001018}
1019
1020static void DumpThread(Thread* t, void* arg) {
Elliott Hughesffb465f2012-03-01 18:46:05 -08001021 std::ostream& os = *reinterpret_cast<std::ostream*>(arg);
1022 std::string name;
1023 t->GetThreadName(name);
1024 os << t->GetTid() << "\t" << name << "\n";
jeffhaoa9ef3fd2011-12-13 18:33:43 -08001025}
1026
1027void Trace::DumpThreadList(std::ostream& os) {
Ian Rogers81d425b2012-09-27 16:03:43 -07001028 Thread* self = Thread::Current();
Jeff Haoe094b872014-10-14 13:12:01 -07001029 for (auto it : exited_threads_) {
1030 os << it.first << "\t" << it.second << "\n";
1031 }
Ian Rogers81d425b2012-09-27 16:03:43 -07001032 Locks::thread_list_lock_->AssertNotHeld(self);
1033 MutexLock mu(self, *Locks::thread_list_lock_);
jeffhaoa9ef3fd2011-12-13 18:33:43 -08001034 Runtime::Current()->GetThreadList()->ForEach(DumpThread, &os);
jeffhaoe343b762011-12-05 16:36:44 -08001035}
1036
Jeff Haoe094b872014-10-14 13:12:01 -07001037void Trace::StoreExitingThreadInfo(Thread* thread) {
1038 MutexLock mu(thread, *Locks::trace_lock_);
1039 if (the_trace_ != nullptr) {
1040 std::string name;
1041 thread->GetThreadName(name);
Andreas Gampea1785c52014-11-25 20:40:08 -08001042 // The same thread/tid may be used multiple times. As SafeMap::Put does not allow to override
1043 // a previous mapping, use SafeMap::Overwrite.
1044 the_trace_->exited_threads_.Overwrite(thread->GetTid(), name);
Jeff Haoe094b872014-10-14 13:12:01 -07001045 }
1046}
1047
Andreas Gampe40da2862015-02-27 12:49:04 -08001048Trace::TraceOutputMode Trace::GetOutputMode() {
1049 MutexLock mu(Thread::Current(), *Locks::trace_lock_);
1050 CHECK(the_trace_ != nullptr) << "Trace output mode requested, but no trace currently running";
1051 return the_trace_->trace_output_mode_;
1052}
1053
1054Trace::TraceMode Trace::GetMode() {
1055 MutexLock mu(Thread::Current(), *Locks::trace_lock_);
1056 CHECK(the_trace_ != nullptr) << "Trace mode requested, but no trace currently running";
1057 return the_trace_->trace_mode_;
1058}
1059
Andreas Gampee34a42c2015-04-25 14:44:29 -07001060size_t Trace::GetBufferSize() {
1061 MutexLock mu(Thread::Current(), *Locks::trace_lock_);
1062 CHECK(the_trace_ != nullptr) << "Trace mode requested, but no trace currently running";
1063 return the_trace_->buffer_size_;
1064}
1065
Mathieu Chartier7778b882015-10-05 16:41:10 -07001066bool Trace::IsTracingEnabled() {
1067 MutexLock mu(Thread::Current(), *Locks::trace_lock_);
1068 return the_trace_ != nullptr;
1069}
1070
jeffhaoe343b762011-12-05 16:36:44 -08001071} // namespace art