1/*
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 */
16
17#ifndef ART_RUNTIME_TRACE_H_
18#define ART_RUNTIME_TRACE_H_
19
20#include <bitset>
21#include <map>
22#include <memory>
23#include <ostream>
24#include <set>
25#include <string>
26#include <unordered_map>
27#include <vector>
28
29#include "atomic.h"
30#include "base/macros.h"
31#include "globals.h"
32#include "instrumentation.h"
33#include "os.h"
34#include "safe_map.h"
35
36namespace art {
37
38class ArtField;
39class ArtMethod;
40class DexFile;
41class Thread;
42
43using DexIndexBitSet = std::bitset<65536>;
44using ThreadIDBitSet = std::bitset<65536>;
45
46enum TracingMode {
47  kTracingInactive,
48  kMethodTracingActive,
49  kSampleProfilingActive,
50};
51
52// File format:
53//     header
54//     record 0
55//     record 1
56//     ...
57//
58// Header format:
59//     u4  magic ('SLOW')
60//     u2  version
61//     u2  offset to data
62//     u8  start date/time in usec
63//     u2  record size in bytes (version >= 2 only)
64//     ... padding to 32 bytes
65//
66// Record format v1:
67//     u1  thread ID
68//     u4  method ID | method action
69//     u4  time delta since start, in usec
70//
71// Record format v2:
72//     u2  thread ID
73//     u4  method ID | method action
74//     u4  time delta since start, in usec
75//
76// Record format v3:
77//     u2  thread ID
78//     u4  method ID | method action
79//     u4  time delta since start, in usec
80//     u4  wall time since start, in usec (when clock == "dual" only)
81//
82// 32 bits of microseconds is 70 minutes.
83//
84// All values are stored in little-endian order.
85
86enum TraceAction {
87    kTraceMethodEnter = 0x00,       // method entry
88    kTraceMethodExit = 0x01,        // method exit
89    kTraceUnroll = 0x02,            // method exited by exception unrolling
90    // 0x03 currently unused
91    kTraceMethodActionMask = 0x03,  // two bits
92};
93
94class Trace FINAL : public instrumentation::InstrumentationListener {
95 public:
96  enum TraceFlag {
97    kTraceCountAllocs = 1,
98  };
99
100  enum class TraceOutputMode {
101    kFile,
102    kDDMS,
103    kStreaming
104  };
105
106  enum class TraceMode {
107    kMethodTracing,
108    kSampling
109  };
110
111  ~Trace();
112
113  static void SetDefaultClockSource(TraceClockSource clock_source);
114
115  static void Start(const char* trace_filename, int trace_fd, size_t buffer_size, int flags,
116                    TraceOutputMode output_mode, TraceMode trace_mode, int interval_us)
117      LOCKS_EXCLUDED(Locks::mutator_lock_,
118                     Locks::thread_list_lock_,
119                     Locks::thread_suspend_count_lock_,
120                     Locks::trace_lock_);
121  static void Pause() LOCKS_EXCLUDED(Locks::trace_lock_, Locks::thread_list_lock_);
122  static void Resume() LOCKS_EXCLUDED(Locks::trace_lock_);
123
124  // Stop tracing. This will finish the trace and write it to file/send it via DDMS.
125  static void Stop()
126      LOCKS_EXCLUDED(Locks::mutator_lock_,
127                     Locks::thread_list_lock_,
128                     Locks::trace_lock_);
129  // Abort tracing. This will just stop tracing and *not* write/send the collected data.
130  static void Abort()
131      LOCKS_EXCLUDED(Locks::mutator_lock_,
132                     Locks::thread_list_lock_,
133                     Locks::trace_lock_);
134  static void Shutdown()
135      LOCKS_EXCLUDED(Locks::mutator_lock_,
136                     Locks::thread_list_lock_,
137                     Locks::trace_lock_);
138  static TracingMode GetMethodTracingMode() LOCKS_EXCLUDED(Locks::trace_lock_);
139
140  bool UseWallClock();
141  bool UseThreadCpuClock();
142  void MeasureClockOverhead();
143  uint32_t GetClockOverheadNanoSeconds();
144
145  void CompareAndUpdateStackTrace(Thread* thread, std::vector<ArtMethod*>* stack_trace)
146      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
147
148  // InstrumentationListener implementation.
149  void MethodEntered(Thread* thread, mirror::Object* this_object,
150                     ArtMethod* method, uint32_t dex_pc)
151      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) OVERRIDE;
152  void MethodExited(Thread* thread, mirror::Object* this_object,
153                    ArtMethod* method, uint32_t dex_pc,
154                    const JValue& return_value)
155      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) OVERRIDE;
156  void MethodUnwind(Thread* thread, mirror::Object* this_object,
157                    ArtMethod* method, uint32_t dex_pc)
158      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) OVERRIDE;
159  void DexPcMoved(Thread* thread, mirror::Object* this_object,
160                  ArtMethod* method, uint32_t new_dex_pc)
161      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) OVERRIDE;
162  void FieldRead(Thread* thread, mirror::Object* this_object,
163                 ArtMethod* method, uint32_t dex_pc, ArtField* field)
164      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) OVERRIDE;
165  void FieldWritten(Thread* thread, mirror::Object* this_object,
166                    ArtMethod* method, uint32_t dex_pc, ArtField* field,
167                    const JValue& field_value)
168      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) OVERRIDE;
169  void ExceptionCaught(Thread* thread, mirror::Throwable* exception_object)
170      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) OVERRIDE;
171  void BackwardBranch(Thread* thread, ArtMethod* method, int32_t dex_pc_offset)
172      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) OVERRIDE;
173  // Reuse an old stack trace if it exists, otherwise allocate a new one.
174  static std::vector<ArtMethod*>* AllocStackTrace();
175  // Clear and store an old stack trace for later use.
176  static void FreeStackTrace(std::vector<ArtMethod*>* stack_trace);
177  // Save id and name of a thread before it exits.
178  static void StoreExitingThreadInfo(Thread* thread);
179
180  static TraceOutputMode GetOutputMode() LOCKS_EXCLUDED(Locks::trace_lock_);
181  static TraceMode GetMode() LOCKS_EXCLUDED(Locks::trace_lock_);
182  static size_t GetBufferSize() LOCKS_EXCLUDED(Locks::trace_lock_);
183
184 private:
185  Trace(File* trace_file, const char* trace_name, size_t buffer_size, int flags,
186        TraceOutputMode output_mode, TraceMode trace_mode);
187
188  // The sampling interval in microseconds is passed as an argument.
189  static void* RunSamplingThread(void* arg) LOCKS_EXCLUDED(Locks::trace_lock_);
190
191  static void StopTracing(bool finish_tracing, bool flush_file)
192      LOCKS_EXCLUDED(Locks::mutator_lock_,
193                     Locks::thread_list_lock_,
194                     Locks::trace_lock_);
195  void FinishTracing() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
196
197  void ReadClocks(Thread* thread, uint32_t* thread_clock_diff, uint32_t* wall_clock_diff);
198
199  void LogMethodTraceEvent(Thread* thread, ArtMethod* method,
200                           instrumentation::Instrumentation::InstrumentationEvent event,
201                           uint32_t thread_clock_diff, uint32_t wall_clock_diff)
202      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
203
204  // Methods to output traced methods and threads.
205  void GetVisitedMethods(size_t end_offset, std::set<ArtMethod*>* visited_methods);
206  void DumpMethodList(std::ostream& os, const std::set<ArtMethod*>& visited_methods)
207      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
208  void DumpThreadList(std::ostream& os) LOCKS_EXCLUDED(Locks::thread_list_lock_);
209
210  // Methods to register seen entitites in streaming mode. The methods return true if the entity
211  // is newly discovered.
212  bool RegisterMethod(ArtMethod* method)
213      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) EXCLUSIVE_LOCKS_REQUIRED(streaming_lock_);
214  bool RegisterThread(Thread* thread)
215      EXCLUSIVE_LOCKS_REQUIRED(streaming_lock_);
216
217  // Copy a temporary buffer to the main buffer. Used for streaming. Exposed here for lock
218  // annotation.
219  void WriteToBuf(const uint8_t* src, size_t src_size)
220      EXCLUSIVE_LOCKS_REQUIRED(streaming_lock_);
221
222  uint32_t EncodeTraceMethod(ArtMethod* method) LOCKS_EXCLUDED(unique_methods_lock_);
223  uint32_t EncodeTraceMethodAndAction(ArtMethod* method, TraceAction action)
224      LOCKS_EXCLUDED(unique_methods_lock_);
225  ArtMethod* DecodeTraceMethod(uint32_t tmid) LOCKS_EXCLUDED(unique_methods_lock_);
226  std::string GetMethodLine(ArtMethod* method) LOCKS_EXCLUDED(unique_methods_lock_)
227      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
228
229  void DumpBuf(uint8_t* buf, size_t buf_size, TraceClockSource clock_source)
230      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
231
232  // Singleton instance of the Trace or null when no method tracing is active.
233  static Trace* volatile the_trace_ GUARDED_BY(Locks::trace_lock_);
234
235  // The default profiler clock source.
236  static TraceClockSource default_clock_source_;
237
238  // Sampling thread, non-zero when sampling.
239  static pthread_t sampling_pthread_;
240
241  // Used to remember an unused stack trace to avoid re-allocation during sampling.
242  static std::unique_ptr<std::vector<ArtMethod*>> temp_stack_trace_;
243
244  // File to write trace data out to, null if direct to ddms.
245  std::unique_ptr<File> trace_file_;
246
247  // Buffer to store trace data.
248  std::unique_ptr<uint8_t[]> buf_;
249
250  // Flags enabling extra tracing of things such as alloc counts.
251  const int flags_;
252
253  // The kind of output for this tracing.
254  const TraceOutputMode trace_output_mode_;
255
256  // The tracing method.
257  const TraceMode trace_mode_;
258
259  const TraceClockSource clock_source_;
260
261  // Size of buf_.
262  const size_t buffer_size_;
263
264  // Time trace was created.
265  const uint64_t start_time_;
266
267  // Clock overhead.
268  const uint32_t clock_overhead_ns_;
269
270  // Offset into buf_.
271  AtomicInteger cur_offset_;
272
273  // Did we overflow the buffer recording traces?
274  bool overflow_;
275
276  // Map of thread ids and names that have already exited.
277  SafeMap<pid_t, std::string> exited_threads_;
278
279  // Sampling profiler sampling interval.
280  int interval_us_;
281
282  // Streaming mode data.
283  std::string streaming_file_name_;
284  Mutex* streaming_lock_;
285  std::map<const DexFile*, DexIndexBitSet*> seen_methods_;
286  std::unique_ptr<ThreadIDBitSet> seen_threads_;
287
288  // Bijective map from ArtMethod* to index.
289  // Map from ArtMethod* to index in unique_methods_;
290  Mutex* unique_methods_lock_ ACQUIRED_AFTER(streaming_lock_);
291  std::unordered_map<ArtMethod*, uint32_t> art_method_id_map_ GUARDED_BY(unique_methods_lock_);
292  std::vector<ArtMethod*> unique_methods_ GUARDED_BY(unique_methods_lock_);
293
294  DISALLOW_COPY_AND_ASSIGN(Trace);
295};
296
297}  // namespace art
298
299#endif  // ART_RUNTIME_TRACE_H_
300