Mercurial > hg > truffle
annotate src/share/vm/runtime/fprofiler.hpp @ 1721:413ad0331a0c
6977924: Changes for 6975078 produce build error with certain gcc versions
Summary: The changes introduced for 6975078 assign badHeapOopVal to the _allocation field in the ResourceObj class. In 32 bit linux builds with certain versions of gcc this assignment will be flagged as an error while compiling allocation.cpp. In 32 bit builds the constant value badHeapOopVal (which is cast to an intptr_t) is negative. The _allocation field is typed as an unsigned intptr_t and gcc catches this as an error.
Reviewed-by: jcoomes, ysr, phh
author | johnc |
---|---|
date | Wed, 18 Aug 2010 10:59:06 -0700 |
parents | c18cbe5936b8 |
children | f95d63e2154a |
rev | line source |
---|---|
0 | 1 /* |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
196
diff
changeset
|
2 * Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved. |
0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
18 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
196
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
196
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
196
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
25 // a simple flat profiler for Java | |
26 | |
27 | |
28 // Forward declaration of classes defined in this header file | |
29 class ThreadProfiler; | |
30 class ThreadProfilerMark; | |
31 class FlatProfiler; | |
32 class IntervalData; | |
33 | |
34 // Declarations of classes defined only in the implementation. | |
35 class ProfilerNode; | |
36 class FlatProfilerTask; | |
37 | |
38 enum TickPosition { | |
39 tp_code, | |
40 tp_native | |
41 }; | |
42 | |
43 // One of these guys is constructed as we enter interesting regions | |
44 // and destructed as we exit the region. While we are in the region | |
45 // ticks are allotted to the region. | |
46 class ThreadProfilerMark: public StackObj { | |
47 public: | |
48 // For now, the only thread-specific region is the class loader. | |
49 enum Region { noRegion, classLoaderRegion, extraRegion, maxRegion }; | |
50 | |
51 ThreadProfilerMark(Region) KERNEL_RETURN; | |
52 ~ThreadProfilerMark() KERNEL_RETURN; | |
53 | |
54 private: | |
55 ThreadProfiler* _pp; | |
56 Region _r; | |
57 }; | |
58 | |
59 #ifndef FPROF_KERNEL | |
60 | |
61 class IntervalData VALUE_OBJ_CLASS_SPEC { | |
62 // Just to keep these things all together | |
63 private: | |
64 int _interpreted; | |
65 int _compiled; | |
66 int _native; | |
67 int _compiling; | |
68 public: | |
69 int interpreted() { | |
70 return _interpreted; | |
71 } | |
72 int compiled() { | |
73 return _compiled; | |
74 } | |
75 int native() { | |
76 return _native; | |
77 } | |
78 int compiling() { | |
79 return _compiling; | |
80 } | |
81 int total() { | |
82 return (interpreted() + compiled() + native() + compiling()); | |
83 } | |
84 void inc_interpreted() { | |
85 _interpreted += 1; | |
86 } | |
87 void inc_compiled() { | |
88 _compiled += 1; | |
89 } | |
90 void inc_native() { | |
91 _native += 1; | |
92 } | |
93 void inc_compiling() { | |
94 _compiling += 1; | |
95 } | |
96 void reset() { | |
97 _interpreted = 0; | |
98 _compiled = 0; | |
99 _native = 0; | |
100 _compiling = 0; | |
101 } | |
102 static void print_header(outputStream* st); | |
103 void print_data(outputStream* st); | |
104 }; | |
105 #endif // FPROF_KERNEL | |
106 | |
107 class ThreadProfiler: public CHeapObj { | |
108 public: | |
109 ThreadProfiler() KERNEL_RETURN; | |
110 ~ThreadProfiler() KERNEL_RETURN; | |
111 | |
112 // Resets the profiler | |
113 void reset() KERNEL_RETURN; | |
114 | |
115 // Activates the profiler for a certain thread | |
116 void engage() KERNEL_RETURN; | |
117 | |
118 // Deactivates the profiler | |
119 void disengage() KERNEL_RETURN; | |
120 | |
121 // Prints the collected profiling information | |
122 void print(const char* thread_name) KERNEL_RETURN; | |
123 | |
124 // Garbage Collection Support | |
125 void oops_do(OopClosure* f) KERNEL_RETURN; | |
126 | |
127 #ifndef FPROF_KERNEL | |
128 private: | |
129 // for recording ticks. | |
130 friend class ProfilerNode; | |
131 char* area_bottom; // preallocated area for pnodes | |
132 char* area_top; | |
133 char* area_limit; | |
134 static int table_size; | |
135 ProfilerNode** table; | |
136 | |
137 private: | |
107
93b6525e3b82
6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on
sgoldman
parents:
0
diff
changeset
|
138 void record_interpreted_tick(JavaThread* thread, frame fr, TickPosition where, int* ticks); |
0 | 139 void record_compiled_tick (JavaThread* thread, frame fr, TickPosition where); |
140 void interpreted_update(methodOop method, TickPosition where); | |
141 void compiled_update (methodOop method, TickPosition where); | |
142 void stub_update (methodOop method, const char* name, TickPosition where); | |
143 void adapter_update (TickPosition where); | |
144 | |
145 void runtime_stub_update(const CodeBlob* stub, const char* name, TickPosition where); | |
146 void unknown_compiled_update (const CodeBlob* cb, TickPosition where); | |
147 | |
148 void vm_update (TickPosition where); | |
149 void vm_update (const char* name, TickPosition where); | |
150 | |
151 void record_tick_for_running_frame(JavaThread* thread, frame fr); | |
152 void record_tick_for_calling_frame(JavaThread* thread, frame fr); | |
153 | |
154 void initialize(); | |
155 | |
156 static int entry(int value); | |
157 | |
158 | |
159 private: | |
160 friend class FlatProfiler; | |
161 void record_tick(JavaThread* thread); | |
162 bool engaged; | |
163 // so we can do percentages for this thread, and quick checks for activity | |
164 int thread_ticks; | |
165 int compiler_ticks; | |
166 int interpreter_ticks; | |
167 | |
168 public: | |
169 void inc_thread_ticks() { thread_ticks += 1; } | |
170 | |
171 private: | |
172 friend class ThreadProfilerMark; | |
173 // counters for thread-specific regions | |
174 bool region_flag[ThreadProfilerMark::maxRegion]; | |
175 int class_loader_ticks; | |
176 int extra_ticks; | |
177 | |
178 private: | |
179 // other thread-specific regions | |
180 int blocked_ticks; | |
181 enum UnknownTickSites { | |
182 ut_null_method, | |
183 ut_vtable_stubs, | |
184 ut_running_frame, | |
185 ut_calling_frame, | |
186 ut_no_pc, | |
187 ut_no_last_Java_frame, | |
188 ut_unknown_thread_state, | |
189 ut_end | |
190 }; | |
191 int unknown_ticks_array[ut_end]; | |
192 int unknown_ticks() { | |
193 int result = 0; | |
194 for (int ut = 0; ut < ut_end; ut += 1) { | |
195 result += unknown_ticks_array[ut]; | |
196 } | |
197 return result; | |
198 } | |
199 | |
200 elapsedTimer timer; | |
201 | |
202 // For interval timing | |
203 private: | |
204 IntervalData _interval_data; | |
205 IntervalData interval_data() { | |
206 return _interval_data; | |
207 } | |
208 IntervalData* interval_data_ref() { | |
209 return &_interval_data; | |
210 } | |
211 #endif // FPROF_KERNEL | |
212 }; | |
213 | |
214 class FlatProfiler: AllStatic { | |
215 public: | |
216 static void reset() KERNEL_RETURN ; | |
217 static void engage(JavaThread* mainThread, bool fullProfile) KERNEL_RETURN ; | |
218 static void disengage() KERNEL_RETURN ; | |
219 static void print(int unused) KERNEL_RETURN ; | |
220 static bool is_active() KERNEL_RETURN_(return false;) ; | |
221 | |
222 // This is NULL if each thread has its own thread profiler, | |
223 // else this is the single thread profiler used by all threads. | |
224 // In particular it makes a difference during garbage collection, | |
225 // where you only want to traverse each thread profiler once. | |
226 static ThreadProfiler* get_thread_profiler() KERNEL_RETURN_(return NULL;); | |
227 | |
228 // Garbage Collection Support | |
229 static void oops_do(OopClosure* f) KERNEL_RETURN ; | |
230 | |
231 // Support for disassembler to inspect the PCRecorder | |
232 | |
233 // Returns the start address for a given pc | |
234 // NULL is returned if the PCRecorder is inactive | |
235 static address bucket_start_for(address pc) KERNEL_RETURN_(return NULL;); | |
236 | |
237 enum { MillisecsPerTick = 10 }; // ms per profiling ticks | |
238 | |
239 // Returns the number of ticks recorded for the bucket | |
240 // pc belongs to. | |
241 static int bucket_count_for(address pc) KERNEL_RETURN_(return 0;); | |
242 | |
243 #ifndef FPROF_KERNEL | |
244 | |
245 private: | |
246 static bool full_profile() { | |
247 return full_profile_flag; | |
248 } | |
249 | |
250 friend class ThreadProfiler; | |
251 // the following group of ticks cover everything that's not attributed to individual Java methods | |
252 static int received_gc_ticks; // ticks during which gc was active | |
253 static int vm_operation_ticks; // total ticks in vm_operations other than GC | |
254 static int threads_lock_ticks; // the number of times we couldn't get the Threads_lock without blocking | |
255 static int blocked_ticks; // ticks when the thread was blocked. | |
256 static int class_loader_ticks; // total ticks in class loader | |
257 static int extra_ticks; // total ticks an extra temporary measuring | |
258 static int compiler_ticks; // total ticks in compilation | |
259 static int interpreter_ticks; // ticks in unknown interpreted method | |
260 static int deopt_ticks; // ticks in deoptimization | |
261 static int unknown_ticks; // ticks that cannot be categorized | |
262 static int received_ticks; // ticks that were received by task | |
263 static int delivered_ticks; // ticks that were delivered by task | |
264 static int non_method_ticks() { | |
265 return | |
266 ( received_gc_ticks | |
267 + vm_operation_ticks | |
268 + deopt_ticks | |
269 + threads_lock_ticks | |
270 + blocked_ticks | |
271 + compiler_ticks | |
272 + interpreter_ticks | |
273 + unknown_ticks ); | |
274 } | |
275 static elapsedTimer timer; | |
276 | |
277 // Counts of each of the byte codes | |
278 static int* bytecode_ticks; | |
279 static int* bytecode_ticks_stub; | |
280 static void print_byte_code_statistics(); | |
281 | |
282 // the ticks below are for continuous profiling (to adjust recompilation, etc.) | |
283 static int all_ticks; // total count of ticks received so far | |
284 static int all_int_ticks; // ticks in interpreter | |
285 static int all_comp_ticks; // ticks in compiled code (+ native) | |
286 static bool full_profile_flag; // collecting full profile? | |
287 | |
288 // to accumulate thread-specific data | |
289 // if we aren't profiling individual threads. | |
290 static ThreadProfiler* thread_profiler; | |
291 static ThreadProfiler* vm_thread_profiler; | |
292 | |
293 static void allocate_table(); | |
294 | |
295 // The task that periodically interrupts things. | |
296 friend class FlatProfilerTask; | |
297 static FlatProfilerTask* task; | |
298 static void record_vm_operation(); | |
299 static void record_vm_tick(); | |
300 static void record_thread_ticks(); | |
301 | |
302 // For interval analysis | |
303 private: | |
304 static int interval_ticks_previous; // delivered_ticks from the last interval | |
305 static void interval_record_thread(ThreadProfiler* tp); // extract ticks from ThreadProfiler. | |
306 static void interval_print(); // print interval data. | |
307 static void interval_reset(); // reset interval data. | |
308 enum {interval_print_size = 10}; | |
309 static IntervalData* interval_data; | |
310 #endif // FPROF_KERNEL | |
311 }; |