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
32struct Thread;      // extern
33
34
35/* boot init */
36bool dvmProfilingStartup(void);
37void dvmProfilingShutdown(void);
38
39/*
40 * Method trace state.  This is currently global.  In theory we could make
41 * most of this per-thread.
42 */
43typedef 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    int     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 */
69typedef 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 */
102void dvmMethodTraceStart(const char* traceFileName, int traceFd, int bufferSize,
103        int flags, bool directToDdms);
104bool dvmIsMethodTraceActive(void);
105void dvmMethodTraceStop(void);
106
107/*
108 * Start/stop emulator tracing.
109 */
110void dvmEmulatorTraceStart(void);
111void dvmEmulatorTraceStop(void);
112
113/*
114 * Start/stop Dalvik instruction counting.
115 */
116void dvmStartInstructionCounting();
117void dvmStopInstructionCounting();
118
119/*
120 * Bit flags for dvmMethodTraceStart "flags" argument.  These must match
121 * the values in android.os.Debug.
122 */
123enum {
124    TRACE_ALLOC_COUNTS      = 0x01,
125};
126
127/*
128 * Call these when a method enters or exits.
129 */
130#define TRACE_METHOD_ENTER(_self, _method)                                 \
131    do {                                                                    \
132        if (gDvm.activeProfilers != 0) {                                    \
133            if (gDvm.methodTrace.traceEnabled)                              \
134                dvmMethodTraceAdd(_self, _method, METHOD_TRACE_ENTER);      \
135            if (gDvm.emulatorTraceEnableCount != 0)                         \
136                dvmEmitEmulatorTrace(_method, METHOD_TRACE_ENTER);          \
137        }                                                                   \
138    } while(0);
139#define TRACE_METHOD_EXIT(_self, _method)                                  \
140    do {                                                                    \
141        if (gDvm.activeProfilers != 0) {                                    \
142            if (gDvm.methodTrace.traceEnabled)                              \
143                dvmMethodTraceAdd(_self, _method, METHOD_TRACE_EXIT);       \
144            if (gDvm.emulatorTraceEnableCount != 0)                         \
145                dvmEmitEmulatorTrace(_method, METHOD_TRACE_EXIT);           \
146        }                                                                   \
147    } while(0);
148#define TRACE_METHOD_UNROLL(_self, _method)                                \
149    do {                                                                    \
150        if (gDvm.activeProfilers != 0) {                                    \
151            if (gDvm.methodTrace.traceEnabled)                              \
152                dvmMethodTraceAdd(_self, _method, METHOD_TRACE_UNROLL);     \
153            if (gDvm.emulatorTraceEnableCount != 0)                         \
154                dvmEmitEmulatorTrace(_method, METHOD_TRACE_UNROLL);         \
155        }                                                                   \
156    } while(0);
157
158void dvmMethodTraceAdd(struct Thread* self, const Method* method, int action);
159void dvmEmitEmulatorTrace(const Method* method, int action);
160
161void dvmMethodTraceGCBegin(void);
162void dvmMethodTraceGCEnd(void);
163void dvmMethodTraceClassPrepBegin(void);
164void dvmMethodTraceClassPrepEnd(void);
165
166/*
167 * Start/stop alloc counting.
168 */
169void dvmStartAllocCounting(void);
170void dvmStopAllocCounting(void);
171
172#endif
173
174
175/*
176 * Enumeration for the two "action" bits.
177 */
178enum {
179    METHOD_TRACE_ENTER = 0x00,      // method entry
180    METHOD_TRACE_EXIT = 0x01,       // method exit
181    METHOD_TRACE_UNROLL = 0x02,     // method exited by exception unrolling
182    // 0x03 currently unused
183};
184
185#define TOKEN_CHAR      '*'
186#define TRACE_VERSION   1
187
188/*
189 * Common definitions, shared with the dump tool.
190 */
191#define METHOD_ACTION_MASK      0x03            /* two bits */
192#define METHOD_ID(_method)      ((_method) & (~METHOD_ACTION_MASK))
193#define METHOD_ACTION(_method)  (((unsigned int)(_method)) & METHOD_ACTION_MASK)
194#define METHOD_COMBINE(_method, _action)    ((_method) | (_action))
195
196#endif /*_DALVIK_PROFILE*/
197