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