• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "base/atomic.h"
30 #include "base/locks.h"
31 #include "base/macros.h"
32 #include "base/os.h"
33 #include "base/safe_map.h"
34 #include "instrumentation.h"
35 #include "runtime_globals.h"
36 
37 namespace unix_file {
38 class FdFile;
39 }  // namespace unix_file
40 
41 namespace art {
42 
43 class ArtField;
44 class ArtMethod;
45 class DexFile;
46 class LOCKABLE Mutex;
47 class ShadowFrame;
48 class Thread;
49 
50 using DexIndexBitSet = std::bitset<65536>;
51 
52 constexpr size_t kMaxThreadIdNumber = kIsTargetBuild ? 65536U : 1048576U;
53 using ThreadIDBitSet = std::bitset<kMaxThreadIdNumber>;
54 
55 enum TracingMode {
56   kTracingInactive,
57   kMethodTracingActive,  // Trace activity synchronous with method progress.
58   kSampleProfilingActive,  // Trace activity captured by sampling thread.
59 };
60 std::ostream& operator<<(std::ostream& os, TracingMode rhs);
61 
62 // File format:
63 //     header
64 //     record 0
65 //     record 1
66 //     ...
67 //
68 // Header format:
69 //     u4  magic ('SLOW')
70 //     u2  version
71 //     u2  offset to data
72 //     u8  start date/time in usec
73 //     u2  record size in bytes (version >= 2 only)
74 //     ... padding to 32 bytes
75 //
76 // Record format v1:
77 //     u1  thread ID
78 //     u4  method ID | method action
79 //     u4  time delta since start, in usec
80 //
81 // Record format v2:
82 //     u2  thread ID
83 //     u4  method ID | method action
84 //     u4  time delta since start, in usec
85 //
86 // Record format v3:
87 //     u2  thread ID
88 //     u4  method ID | method action
89 //     u4  time delta since start, in usec
90 //     u4  wall time since start, in usec (when clock == "dual" only)
91 //
92 // 32 bits of microseconds is 70 minutes.
93 //
94 // All values are stored in little-endian order.
95 
96 enum TraceAction {
97     kTraceMethodEnter = 0x00,       // method entry
98     kTraceMethodExit = 0x01,        // method exit
99     kTraceUnroll = 0x02,            // method exited by exception unrolling
100     // 0x03 currently unused
101     kTraceMethodActionMask = 0x03,  // two bits
102 };
103 
104 // Class for recording event traces. Trace data is either collected
105 // synchronously during execution (TracingMode::kMethodTracingActive),
106 // or by a separate sampling thread (TracingMode::kSampleProfilingActive).
107 class Trace final : public instrumentation::InstrumentationListener {
108  public:
109   enum TraceFlag {
110     kTraceCountAllocs = 1,
111   };
112 
113   enum class TraceOutputMode {
114     kFile,
115     kDDMS,
116     kStreaming
117   };
118 
119   enum class TraceMode {
120     kMethodTracing,
121     kSampling
122   };
123 
124   ~Trace();
125 
126   static void SetDefaultClockSource(TraceClockSource clock_source);
127 
128   static void Start(const char* trace_filename,
129                     size_t buffer_size,
130                     int flags,
131                     TraceOutputMode output_mode,
132                     TraceMode trace_mode,
133                     int interval_us)
134       REQUIRES(!Locks::mutator_lock_, !Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_,
135                !Locks::trace_lock_);
136   static void Start(int trace_fd,
137                     size_t buffer_size,
138                     int flags,
139                     TraceOutputMode output_mode,
140                     TraceMode trace_mode,
141                     int interval_us)
142       REQUIRES(!Locks::mutator_lock_, !Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_,
143                !Locks::trace_lock_);
144   static void Start(std::unique_ptr<unix_file::FdFile>&& file,
145                     size_t buffer_size,
146                     int flags,
147                     TraceOutputMode output_mode,
148                     TraceMode trace_mode,
149                     int interval_us)
150       REQUIRES(!Locks::mutator_lock_, !Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_,
151                !Locks::trace_lock_);
152   static void StartDDMS(size_t buffer_size,
153                         int flags,
154                         TraceMode trace_mode,
155                         int interval_us)
156       REQUIRES(!Locks::mutator_lock_, !Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_,
157                !Locks::trace_lock_);
158 
159   // Stop tracing. This will finish the trace and write it to file/send it via DDMS.
160   static void Stop()
161       REQUIRES(!Locks::mutator_lock_, !Locks::thread_list_lock_, !Locks::trace_lock_);
162   // Abort tracing. This will just stop tracing and *not* write/send the collected data.
163   static void Abort()
164       REQUIRES(!Locks::mutator_lock_, !Locks::thread_list_lock_, !Locks::trace_lock_);
165   static void Shutdown()
166       REQUIRES(!Locks::mutator_lock_, !Locks::thread_list_lock_, !Locks::trace_lock_);
167   static TracingMode GetMethodTracingMode() REQUIRES(!Locks::trace_lock_);
168 
169   bool UseWallClock();
170   bool UseThreadCpuClock();
171   void MeasureClockOverhead();
172   uint32_t GetClockOverheadNanoSeconds();
173 
174   void CompareAndUpdateStackTrace(Thread* thread, std::vector<ArtMethod*>* stack_trace)
175       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!unique_methods_lock_, !streaming_lock_);
176 
177   // InstrumentationListener implementation.
178   void MethodEntered(Thread* thread,
179                      Handle<mirror::Object> this_object,
180                      ArtMethod* method,
181                      uint32_t dex_pc)
182       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!unique_methods_lock_, !streaming_lock_)
183       override;
184   void MethodExited(Thread* thread,
185                     Handle<mirror::Object> this_object,
186                     ArtMethod* method,
187                     uint32_t dex_pc,
188                     instrumentation::OptionalFrame frame,
189                     JValue& return_value)
190       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!unique_methods_lock_, !streaming_lock_)
191       override;
192   void MethodUnwind(Thread* thread,
193                     Handle<mirror::Object> this_object,
194                     ArtMethod* method,
195                     uint32_t dex_pc)
196       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!unique_methods_lock_, !streaming_lock_)
197       override;
198   void DexPcMoved(Thread* thread,
199                   Handle<mirror::Object> this_object,
200                   ArtMethod* method,
201                   uint32_t new_dex_pc)
202       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!unique_methods_lock_, !streaming_lock_)
203       override;
204   void FieldRead(Thread* thread,
205                  Handle<mirror::Object> this_object,
206                  ArtMethod* method,
207                  uint32_t dex_pc,
208                  ArtField* field)
209       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!unique_methods_lock_) override;
210   void FieldWritten(Thread* thread,
211                     Handle<mirror::Object> this_object,
212                     ArtMethod* method,
213                     uint32_t dex_pc,
214                     ArtField* field,
215                     const JValue& field_value)
216       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!unique_methods_lock_) override;
217   void ExceptionThrown(Thread* thread,
218                        Handle<mirror::Throwable> exception_object)
219       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!unique_methods_lock_) override;
220   void ExceptionHandled(Thread* thread, Handle<mirror::Throwable> exception_object)
221       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!unique_methods_lock_) override;
222   void Branch(Thread* thread,
223               ArtMethod* method,
224               uint32_t dex_pc,
225               int32_t dex_pc_offset)
226       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!unique_methods_lock_) override;
227   void WatchedFramePop(Thread* thread, const ShadowFrame& frame)
228       REQUIRES_SHARED(Locks::mutator_lock_) override;
229   // Reuse an old stack trace if it exists, otherwise allocate a new one.
230   static std::vector<ArtMethod*>* AllocStackTrace();
231   // Clear and store an old stack trace for later use.
232   static void FreeStackTrace(std::vector<ArtMethod*>* stack_trace);
233   // Save id and name of a thread before it exits.
234   static void StoreExitingThreadInfo(Thread* thread);
235 
236   static TraceOutputMode GetOutputMode() REQUIRES(!Locks::trace_lock_);
237   static TraceMode GetMode() REQUIRES(!Locks::trace_lock_);
238   static size_t GetBufferSize() REQUIRES(!Locks::trace_lock_);
239 
240   // Used by class linker to prevent class unloading.
241   static bool IsTracingEnabled() REQUIRES(!Locks::trace_lock_);
242 
243  private:
244   Trace(File* trace_file,
245         size_t buffer_size,
246         int flags,
247         TraceOutputMode output_mode,
248         TraceMode trace_mode);
249 
250   // The sampling interval in microseconds is passed as an argument.
251   static void* RunSamplingThread(void* arg) REQUIRES(!Locks::trace_lock_);
252 
253   static void StopTracing(bool finish_tracing, bool flush_file)
254       REQUIRES(!Locks::mutator_lock_, !Locks::thread_list_lock_, !Locks::trace_lock_)
255       // There is an annoying issue with static functions that create a new object and call into
256       // that object that causes them to not be able to tell that we don't currently hold the lock.
257       // This causes the negative annotations to incorrectly have a false positive. TODO: Figure out
258       // how to annotate this.
259       NO_THREAD_SAFETY_ANALYSIS;
260   void FinishTracing()
261       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!unique_methods_lock_, !streaming_lock_);
262 
263   void ReadClocks(Thread* thread, uint32_t* thread_clock_diff, uint32_t* wall_clock_diff);
264 
265   void LogMethodTraceEvent(Thread* thread, ArtMethod* method,
266                            instrumentation::Instrumentation::InstrumentationEvent event,
267                            uint32_t thread_clock_diff, uint32_t wall_clock_diff)
268       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!unique_methods_lock_, !streaming_lock_);
269 
270   // Methods to output traced methods and threads.
271   void GetVisitedMethods(size_t end_offset, std::set<ArtMethod*>* visited_methods)
272       REQUIRES(!unique_methods_lock_);
273   void DumpMethodList(std::ostream& os, const std::set<ArtMethod*>& visited_methods)
274       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!unique_methods_lock_);
275   void DumpThreadList(std::ostream& os) REQUIRES(!Locks::thread_list_lock_);
276 
277   // Methods to register seen entitites in streaming mode. The methods return true if the entity
278   // is newly discovered.
279   bool RegisterMethod(ArtMethod* method)
280       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(streaming_lock_);
281   bool RegisterThread(Thread* thread)
282       REQUIRES(streaming_lock_);
283 
284   // Copy a temporary buffer to the main buffer. Used for streaming. Exposed here for lock
285   // annotation.
286   void WriteToBuf(const uint8_t* src, size_t src_size)
287       REQUIRES(streaming_lock_);
288   // Flush the main buffer to file. Used for streaming. Exposed here for lock annotation.
289   void FlushBuf()
290       REQUIRES(streaming_lock_);
291 
292   uint32_t EncodeTraceMethod(ArtMethod* method) REQUIRES(!unique_methods_lock_);
293   uint32_t EncodeTraceMethodAndAction(ArtMethod* method, TraceAction action)
294       REQUIRES(!unique_methods_lock_);
295   ArtMethod* DecodeTraceMethod(uint32_t tmid) REQUIRES(!unique_methods_lock_);
296   std::string GetMethodLine(ArtMethod* method) REQUIRES(!unique_methods_lock_)
297       REQUIRES_SHARED(Locks::mutator_lock_);
298 
299   void DumpBuf(uint8_t* buf, size_t buf_size, TraceClockSource clock_source)
300       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!unique_methods_lock_);
301 
302   // Singleton instance of the Trace or null when no method tracing is active.
303   static Trace* volatile the_trace_ GUARDED_BY(Locks::trace_lock_);
304 
305   // The default profiler clock source.
306   static TraceClockSource default_clock_source_;
307 
308   // Sampling thread, non-zero when sampling.
309   static pthread_t sampling_pthread_;
310 
311   // Used to remember an unused stack trace to avoid re-allocation during sampling.
312   static std::unique_ptr<std::vector<ArtMethod*>> temp_stack_trace_;
313 
314   // File to write trace data out to, null if direct to ddms.
315   std::unique_ptr<File> trace_file_;
316 
317   // Buffer to store trace data. In streaming mode, this is protected
318   // by the streaming_lock_. In non-streaming mode, reserved regions
319   // are atomically allocated (using cur_offset_) for log entries to
320   // be written.
321   std::unique_ptr<uint8_t[]> buf_;
322 
323   // Flags enabling extra tracing of things such as alloc counts.
324   const int flags_;
325 
326   // The kind of output for this tracing.
327   const TraceOutputMode trace_output_mode_;
328 
329   // The tracing method.
330   const TraceMode trace_mode_;
331 
332   const TraceClockSource clock_source_;
333 
334   // Size of buf_.
335   const size_t buffer_size_;
336 
337   // Time trace was created.
338   const uint64_t start_time_;
339 
340   // Clock overhead.
341   const uint32_t clock_overhead_ns_;
342 
343   // Offset into buf_. The field is atomic to allow multiple writers
344   // to concurrently reserve space in the buffer. The newly written
345   // buffer contents are not read without some other form of thread
346   // synchronization, such as suspending all potential writers or
347   // acquiring *streaming_lock_. Reading cur_offset_ is thus never
348   // used to ensure visibility of any other objects, and all accesses
349   // are memory_order_relaxed.
350   //
351   // All accesses to buf_ in streaming mode occur whilst holding the
352   // streaming lock. In streaming mode, the buffer may be written out
353   // so cur_offset_ can move forwards and backwards.
354   //
355   // When not in streaming mode, the buf_ writes can come from
356   // multiple threads when the trace mode is kMethodTracing. When
357   // trace mode is kSampling, writes only come from the sampling
358   // thread.
359   //
360   // Reads to the buffer happen after the event sources writing to the
361   // buffer have been shutdown and all stores have completed. The
362   // stores are made visible in StopTracing() when execution leaves
363   // the ScopedSuspendAll block.
364   AtomicInteger cur_offset_;
365 
366   // Did we overflow the buffer recording traces?
367   bool overflow_;
368 
369   // Map of thread ids and names that have already exited.
370   SafeMap<pid_t, std::string> exited_threads_;
371 
372   // Sampling profiler sampling interval.
373   int interval_us_;
374 
375   // Streaming mode data.
376   Mutex* streaming_lock_;
377   std::map<const DexFile*, DexIndexBitSet*> seen_methods_ GUARDED_BY(streaming_lock_);
378   std::unique_ptr<ThreadIDBitSet> seen_threads_ GUARDED_BY(streaming_lock_);
379 
380   // Bijective map from ArtMethod* to index.
381   // Map from ArtMethod* to index in unique_methods_;
382   Mutex* unique_methods_lock_ ACQUIRED_AFTER(streaming_lock_);
383   std::unordered_map<ArtMethod*, uint32_t> art_method_id_map_ GUARDED_BY(unique_methods_lock_);
384   std::vector<ArtMethod*> unique_methods_ GUARDED_BY(unique_methods_lock_);
385 
386   DISALLOW_COPY_AND_ASSIGN(Trace);
387 };
388 
389 }  // namespace art
390 
391 #endif  // ART_RUNTIME_TRACE_H_
392