1 /* 2 * Copyright (C) 2008 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 /* 18 * Android's method call profiling goodies. 19 */ 20 #ifndef _DALVIK_PROFILE 21 #define _DALVIK_PROFILE 22 23 #ifndef NOT_VM /* for utilities that sneakily include this file */ 24 25 #include <stdio.h> 26 27 /* External allocations are hackish enough that it's worthwhile 28 * separating them for possible removal later. 29 */ 30 #define PROFILE_EXTERNAL_ALLOCATIONS 1 31 32 struct Thread; // extern 33 34 35 /* boot init */ 36 bool dvmProfilingStartup(void); 37 void dvmProfilingShutdown(void); 38 39 /* 40 * Method trace state. This is currently global. In theory we could make 41 * most of this per-thread. 42 */ 43 typedef struct MethodTraceState { 44 /* these are set during VM init */ 45 Method* gcMethod; 46 Method* classPrepMethod; 47 48 /* active state */ 49 pthread_mutex_t startStopLock; 50 pthread_cond_t threadExitCond; 51 FILE* traceFile; 52 bool directToDdms; 53 int bufferSize; 54 int flags; 55 56 bool traceEnabled; 57 u1* buf; 58 volatile int curOffset; 59 u8 startWhen; 60 int overflow; 61 } MethodTraceState; 62 63 /* 64 * Memory allocation profiler state. This is used both globally and 65 * per-thread. 66 * 67 * If you add a field here, zero it out in dvmStartAllocCounting(). 68 */ 69 typedef struct AllocProfState { 70 bool enabled; // is allocation tracking enabled? 71 72 int allocCount; // #of objects allocated 73 int allocSize; // cumulative size of objects 74 75 int failedAllocCount; // #of times an allocation failed 76 int failedAllocSize; // cumulative size of failed allocations 77 78 int freeCount; // #of objects freed 79 int freeSize; // cumulative size of freed objects 80 81 int gcCount; // #of times an allocation triggered a GC 82 83 int classInitCount; // #of initialized classes 84 u8 classInitTime; // cumulative time spent in class init (nsec) 85 86 #if PROFILE_EXTERNAL_ALLOCATIONS 87 int externalAllocCount; // #of calls to dvmTrackExternalAllocation() 88 int externalAllocSize; // #of bytes passed to ...ExternalAllocation() 89 90 int failedExternalAllocCount; // #of times an allocation failed 91 int failedExternalAllocSize; // cumulative size of failed allocations 92 93 int externalFreeCount; // #of calls to dvmTrackExternalFree() 94 int externalFreeSize; // #of bytes passed to ...ExternalFree() 95 #endif // PROFILE_EXTERNAL_ALLOCATIONS 96 } AllocProfState; 97 98 99 /* 100 * Start/stop method tracing. 101 */ 102 void dvmMethodTraceStart(const char* traceFileName, int traceFd, int bufferSize, 103 int flags, bool directToDdms); 104 bool dvmIsMethodTraceActive(void); 105 void dvmMethodTraceStop(void); 106 107 /* 108 * Start/stop emulator tracing. 109 */ 110 void dvmEmulatorTraceStart(void); 111 void dvmEmulatorTraceStop(void); 112 113 /* 114 * Start/stop Dalvik instruction counting. 115 */ 116 void dvmStartInstructionCounting(); 117 void dvmStopInstructionCounting(); 118 119 /* 120 * Bit flags for dvmMethodTraceStart "flags" argument. These must match 121 * the values in android.os.Debug. 122 */ 123 enum { 124 TRACE_ALLOC_COUNTS = 0x01, 125 }; 126 127 /* 128 * Call these when a method enters or exits. 129 */ 130 #ifdef WITH_PROFILER 131 # define TRACE_METHOD_ENTER(_self, _method) \ 132 do { \ 133 if (gDvm.activeProfilers != 0) { \ 134 if (gDvm.methodTrace.traceEnabled) \ 135 dvmMethodTraceAdd(_self, _method, METHOD_TRACE_ENTER); \ 136 if (gDvm.emulatorTraceEnableCount != 0) \ 137 dvmEmitEmulatorTrace(_method, METHOD_TRACE_ENTER); \ 138 } \ 139 } while(0); 140 # define TRACE_METHOD_EXIT(_self, _method) \ 141 do { \ 142 if (gDvm.activeProfilers != 0) { \ 143 if (gDvm.methodTrace.traceEnabled) \ 144 dvmMethodTraceAdd(_self, _method, METHOD_TRACE_EXIT); \ 145 if (gDvm.emulatorTraceEnableCount != 0) \ 146 dvmEmitEmulatorTrace(_method, METHOD_TRACE_EXIT); \ 147 } \ 148 } while(0); 149 # define TRACE_METHOD_UNROLL(_self, _method) \ 150 do { \ 151 if (gDvm.activeProfilers != 0) { \ 152 if (gDvm.methodTrace.traceEnabled) \ 153 dvmMethodTraceAdd(_self, _method, METHOD_TRACE_UNROLL); \ 154 if (gDvm.emulatorTraceEnableCount != 0) \ 155 dvmEmitEmulatorTrace(_method, METHOD_TRACE_UNROLL); \ 156 } \ 157 } while(0); 158 #else 159 # define TRACE_METHOD_ENTER(_self, _method) ((void) 0) 160 # define TRACE_METHOD_EXIT(_self, _method) ((void) 0) 161 # define TRACE_METHOD_UNROLL(_self, _method) ((void) 0) 162 #endif 163 164 void dvmMethodTraceAdd(struct Thread* self, const Method* method, int action); 165 void dvmEmitEmulatorTrace(const Method* method, int action); 166 167 void dvmMethodTraceGCBegin(void); 168 void dvmMethodTraceGCEnd(void); 169 void dvmMethodTraceClassPrepBegin(void); 170 void dvmMethodTraceClassPrepEnd(void); 171 172 /* 173 * Start/stop alloc counting. 174 */ 175 void dvmStartAllocCounting(void); 176 void dvmStopAllocCounting(void); 177 178 #endif 179 180 181 /* 182 * Enumeration for the two "action" bits. 183 */ 184 enum { 185 METHOD_TRACE_ENTER = 0x00, // method entry 186 METHOD_TRACE_EXIT = 0x01, // method exit 187 METHOD_TRACE_UNROLL = 0x02, // method exited by exception unrolling 188 // 0x03 currently unused 189 }; 190 191 #define TOKEN_CHAR '*' 192 #define TRACE_VERSION 1 193 194 /* 195 * Common definitions, shared with the dump tool. 196 */ 197 #define METHOD_ACTION_MASK 0x03 /* two bits */ 198 #define METHOD_ID(_method) ((_method) & (~METHOD_ACTION_MASK)) 199 #define METHOD_ACTION(_method) (((unsigned int)(_method)) & METHOD_ACTION_MASK) 200 #define METHOD_COMBINE(_method, _action) ((_method) | (_action)) 201 202 #endif /*_DALVIK_PROFILE*/ 203
