Profile.h revision 949c3ec207a7720fb47f7b3ca1f84dfcfd70aaa9 
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_H_
21#define DALVIK_PROFILE_H_
22
23#ifndef NOT_VM      /* for utilities that sneakily include this file */
24
25#include <stdio.h>
26
27struct Thread;      // extern
28
29
30/* boot init */
31bool dvmProfilingStartup(void);
32void dvmProfilingShutdown(void);
33
34/*
35 * Method trace state.  This is currently global.  In theory we could make
36 * most of this per-thread.
37 */
38struct MethodTraceState {
39    /* active state */
40    pthread_mutex_t startStopLock;
41    pthread_cond_t  threadExitCond;
42    FILE*   traceFile;
43    bool    directToDdms;
44    int     bufferSize;
45    int     flags;
46
47    int     traceEnabled;
48    u1*     buf;
49    volatile int curOffset;
50    u8      startWhen;
51    int     overflow;
52
53    int     traceVersion;
54    size_t  recordSize;
55};
56
57/*
58 * Memory allocation profiler state.  This is used both globally and
59 * per-thread.
60 *
61 * If you add a field here, zero it out in dvmStartAllocCounting().
62 */
63struct AllocProfState {
64    bool    enabled;            // is allocation tracking enabled?
65
66    int     allocCount;         // #of objects allocated
67    int     allocSize;          // cumulative size of objects
68
69    int     failedAllocCount;   // #of times an allocation failed
70    int     failedAllocSize;    // cumulative size of failed allocations
71
72    int     freeCount;          // #of objects freed
73    int     freeSize;           // cumulative size of freed objects
74
75    int     gcCount;            // #of times an allocation triggered a GC
76
77    int     classInitCount;     // #of initialized classes
78    u8      classInitTime;      // cumulative time spent in class init (nsec)
79};
80
81
82/*
83 * Start/stop method tracing.
84 */
85void dvmMethodTraceStart(const char* traceFileName, int traceFd, int bufferSize,
86        int flags, bool directToDdms);
87bool dvmIsMethodTraceActive(void);
88void dvmMethodTraceStop(void);
89
90/*
91 * Start/stop emulator tracing.
92 */
93void dvmEmulatorTraceStart(void);
94void dvmEmulatorTraceStop(void);
95
96/*
97 * Start/stop Dalvik instruction counting.
98 */
99void dvmStartInstructionCounting();
100void dvmStopInstructionCounting();
101
102/*
103 * Bit flags for dvmMethodTraceStart "flags" argument.  These must match
104 * the values in android.os.Debug.
105 */
106enum {
107    TRACE_ALLOC_COUNTS      = 0x01,
108};
109
110/*
111 * Call these when a method enters or exits.
112 */
113#define TRACE_METHOD_ENTER(_self, _method)                                  \
114    do {                                                                    \
115        if (_self->interpBreak.ctl.subMode & kSubModeMethodTrace)           \
116            dvmMethodTraceAdd(_self, _method, METHOD_TRACE_ENTER);          \
117        if (_self->interpBreak.ctl.subMode & kSubModeEmulatorTrace)         \
118            dvmEmitEmulatorTrace(_method, METHOD_TRACE_ENTER);              \
119    } while(0);
120#define TRACE_METHOD_EXIT(_self, _method)                                   \
121    do {                                                                    \
122        if (_self->interpBreak.ctl.subMode & kSubModeMethodTrace)           \
123            dvmMethodTraceAdd(_self, _method, METHOD_TRACE_EXIT);           \
124        if (_self->interpBreak.ctl.subMode & kSubModeEmulatorTrace)         \
125            dvmEmitEmulatorTrace(_method, METHOD_TRACE_EXIT);               \
126    } while(0);
127#define TRACE_METHOD_UNROLL(_self, _method)                                 \
128    do {                                                                    \
129        if (_self->interpBreak.ctl.subMode & kSubModeMethodTrace)           \
130            dvmMethodTraceAdd(_self, _method, METHOD_TRACE_UNROLL);         \
131        if (_self->interpBreak.ctl.subMode & kSubModeEmulatorTrace)         \
132            dvmEmitEmulatorTrace(_method, METHOD_TRACE_UNROLL);             \
133    } while(0);
134
135void dvmMethodTraceAdd(struct Thread* self, const Method* method, int action);
136void dvmEmitEmulatorTrace(const Method* method, int action);
137
138void dvmMethodTraceGCBegin(void);
139void dvmMethodTraceGCEnd(void);
140void dvmMethodTraceClassPrepBegin(void);
141void dvmMethodTraceClassPrepEnd(void);
142
143extern "C" void dvmFastMethodTraceEnter(const Method* method, struct Thread* self);
144extern "C" void dvmFastMethodTraceExit(struct Thread* self);
145extern "C" void dvmFastNativeMethodTraceExit(const Method* method, struct Thread* self);
146
147/*
148 * Start/stop alloc counting.
149 */
150void dvmStartAllocCounting(void);
151void dvmStopAllocCounting(void);
152
153#endif
154
155
156/*
157 * Enumeration for the two "action" bits.
158 */
159enum {
160    METHOD_TRACE_ENTER = 0x00,      // method entry
161    METHOD_TRACE_EXIT = 0x01,       // method exit
162    METHOD_TRACE_UNROLL = 0x02,     // method exited by exception unrolling
163    // 0x03 currently unused
164};
165
166#define TOKEN_CHAR      '*'
167
168/*
169 * Common definitions, shared with the dump tool.
170 */
171#define METHOD_ACTION_MASK      0x03            /* two bits */
172#define METHOD_ID(_method)      ((_method) & (~METHOD_ACTION_MASK))
173#define METHOD_ACTION(_method)  (((unsigned int)(_method)) & METHOD_ACTION_MASK)
174#define METHOD_COMBINE(_method, _action)    ((_method) | (_action))
175
176#endif  // DALVIK_PROFILE_H_
177