Mercurial > hg > truffle
annotate src/share/vm/oops/methodDataOop.hpp @ 4181:319860ae697a
Simplify FrameMap: make offsets of spill slots and outgoing parameters independent so that they can be allocated at the same time, eliminating the separate phases. This makes the separate StackBlock unnecesary. Change CiStackSlot to use byte offsets instead of spill slot index. This makes CiTarget.spillSlotSize unnecessary.
| author | Christian Wimmer <Christian.Wimmer@Oracle.com> |
|---|---|
| date | Mon, 02 Jan 2012 14:16:08 -0800 |
| parents | c26de9aef2ed |
| children | f7251c729b31 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2227 | 2 * Copyright (c) 2000, 2011, 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:
1251
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1251
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:
1251
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_OOPS_METHODDATAOOP_HPP |
| 26 #define SHARE_VM_OOPS_METHODDATAOOP_HPP | |
| 27 | |
| 28 #include "interpreter/bytecodes.hpp" | |
| 29 #include "memory/universe.hpp" | |
| 30 #include "oops/methodOop.hpp" | |
| 31 #include "oops/oop.hpp" | |
| 32 #include "runtime/orderAccess.hpp" | |
| 33 | |
| 0 | 34 class BytecodeStream; |
| 35 | |
| 36 // The MethodData object collects counts and other profile information | |
| 37 // during zeroth-tier (interpretive) and first-tier execution. | |
| 38 // The profile is used later by compilation heuristics. Some heuristics | |
| 39 // enable use of aggressive (or "heroic") optimizations. An aggressive | |
| 40 // optimization often has a down-side, a corner case that it handles | |
| 41 // poorly, but which is thought to be rare. The profile provides | |
| 42 // evidence of this rarity for a given method or even BCI. It allows | |
| 43 // the compiler to back out of the optimization at places where it | |
| 44 // has historically been a poor choice. Other heuristics try to use | |
| 45 // specific information gathered about types observed at a given site. | |
| 46 // | |
| 47 // All data in the profile is approximate. It is expected to be accurate | |
| 48 // on the whole, but the system expects occasional inaccuraces, due to | |
| 49 // counter overflow, multiprocessor races during data collection, space | |
| 50 // limitations, missing MDO blocks, etc. Bad or missing data will degrade | |
| 51 // optimization quality but will not affect correctness. Also, each MDO | |
| 52 // is marked with its birth-date ("creation_mileage") which can be used | |
| 53 // to assess the quality ("maturity") of its data. | |
| 54 // | |
| 55 // Short (<32-bit) counters are designed to overflow to a known "saturated" | |
| 56 // state. Also, certain recorded per-BCI events are given one-bit counters | |
| 57 // which overflow to a saturated state which applied to all counters at | |
| 58 // that BCI. In other words, there is a small lattice which approximates | |
| 59 // the ideal of an infinite-precision counter for each event at each BCI, | |
| 60 // and the lattice quickly "bottoms out" in a state where all counters | |
| 61 // are taken to be indefinitely large. | |
| 62 // | |
| 63 // The reader will find many data races in profile gathering code, starting | |
| 64 // with invocation counter incrementation. None of these races harm correct | |
| 65 // execution of the compiled code. | |
| 66 | |
| 941 | 67 // forward decl |
| 68 class ProfileData; | |
| 69 | |
| 0 | 70 // DataLayout |
| 71 // | |
| 72 // Overlay for generic profiling data. | |
| 73 class DataLayout VALUE_OBJ_CLASS_SPEC { | |
| 74 private: | |
| 75 // Every data layout begins with a header. This header | |
| 76 // contains a tag, which is used to indicate the size/layout | |
| 77 // of the data, 4 bits of flags, which can be used in any way, | |
| 78 // 4 bits of trap history (none/one reason/many reasons), | |
| 79 // and a bci, which is used to tie this piece of data to a | |
| 80 // specific bci in the bytecodes. | |
| 81 union { | |
| 82 intptr_t _bits; | |
| 83 struct { | |
| 84 u1 _tag; | |
| 85 u1 _flags; | |
| 86 u2 _bci; | |
| 87 } _struct; | |
| 88 } _header; | |
| 89 | |
| 90 // The data layout has an arbitrary number of cells, each sized | |
| 91 // to accomodate a pointer or an integer. | |
| 92 intptr_t _cells[1]; | |
| 93 | |
| 94 // Some types of data layouts need a length field. | |
| 95 static bool needs_array_len(u1 tag); | |
| 96 | |
| 97 public: | |
| 98 enum { | |
| 99 counter_increment = 1 | |
| 100 }; | |
| 101 | |
| 102 enum { | |
| 103 cell_size = sizeof(intptr_t) | |
| 104 }; | |
| 105 | |
| 106 // Tag values | |
| 107 enum { | |
| 108 no_tag, | |
| 109 bit_data_tag, | |
| 110 counter_data_tag, | |
| 111 jump_data_tag, | |
| 112 receiver_type_data_tag, | |
| 113 virtual_call_data_tag, | |
| 114 ret_data_tag, | |
| 115 branch_data_tag, | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
116 multi_branch_data_tag, |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
117 arg_info_data_tag |
| 0 | 118 }; |
| 119 | |
| 120 enum { | |
| 121 // The _struct._flags word is formatted as [trap_state:4 | flags:4]. | |
| 122 // The trap state breaks down further as [recompile:1 | reason:3]. | |
| 123 // This further breakdown is defined in deoptimization.cpp. | |
| 124 // See Deoptimization::trap_state_reason for an assert that | |
| 125 // trap_bits is big enough to hold reasons < Reason_RECORDED_LIMIT. | |
| 126 // | |
| 127 // The trap_state is collected only if ProfileTraps is true. | |
| 128 trap_bits = 1+3, // 3: enough to distinguish [0..Reason_RECORDED_LIMIT]. | |
| 129 trap_shift = BitsPerByte - trap_bits, | |
| 130 trap_mask = right_n_bits(trap_bits), | |
| 131 trap_mask_in_place = (trap_mask << trap_shift), | |
| 132 flag_limit = trap_shift, | |
| 133 flag_mask = right_n_bits(flag_limit), | |
| 134 first_flag = 0 | |
| 135 }; | |
| 136 | |
| 137 // Size computation | |
| 138 static int header_size_in_bytes() { | |
| 139 return cell_size; | |
| 140 } | |
| 141 static int header_size_in_cells() { | |
| 142 return 1; | |
| 143 } | |
| 144 | |
| 145 static int compute_size_in_bytes(int cell_count) { | |
| 146 return header_size_in_bytes() + cell_count * cell_size; | |
| 147 } | |
| 148 | |
| 149 // Initialization | |
| 150 void initialize(u1 tag, u2 bci, int cell_count); | |
| 151 | |
| 152 // Accessors | |
| 153 u1 tag() { | |
| 154 return _header._struct._tag; | |
| 155 } | |
| 156 | |
| 157 // Return a few bits of trap state. Range is [0..trap_mask]. | |
| 158 // The state tells if traps with zero, one, or many reasons have occurred. | |
| 159 // It also tells whether zero or many recompilations have occurred. | |
| 160 // The associated trap histogram in the MDO itself tells whether | |
| 161 // traps are common or not. If a BCI shows that a trap X has | |
| 162 // occurred, and the MDO shows N occurrences of X, we make the | |
| 163 // simplifying assumption that all N occurrences can be blamed | |
| 164 // on that BCI. | |
| 165 int trap_state() { | |
| 166 return ((_header._struct._flags >> trap_shift) & trap_mask); | |
| 167 } | |
| 168 | |
| 169 void set_trap_state(int new_state) { | |
| 170 assert(ProfileTraps, "used only under +ProfileTraps"); | |
| 171 uint old_flags = (_header._struct._flags & flag_mask); | |
| 172 _header._struct._flags = (new_state << trap_shift) | old_flags; | |
| 173 } | |
| 174 | |
| 175 u1 flags() { | |
| 176 return _header._struct._flags; | |
| 177 } | |
| 178 | |
| 179 u2 bci() { | |
| 180 return _header._struct._bci; | |
| 181 } | |
| 182 | |
| 183 void set_header(intptr_t value) { | |
| 184 _header._bits = value; | |
| 185 } | |
| 186 void release_set_header(intptr_t value) { | |
| 187 OrderAccess::release_store_ptr(&_header._bits, value); | |
| 188 } | |
| 189 intptr_t header() { | |
| 190 return _header._bits; | |
| 191 } | |
| 192 void set_cell_at(int index, intptr_t value) { | |
| 193 _cells[index] = value; | |
| 194 } | |
| 195 void release_set_cell_at(int index, intptr_t value) { | |
| 196 OrderAccess::release_store_ptr(&_cells[index], value); | |
| 197 } | |
| 198 intptr_t cell_at(int index) { | |
| 199 return _cells[index]; | |
| 200 } | |
| 201 intptr_t* adr_cell_at(int index) { | |
| 202 return &_cells[index]; | |
| 203 } | |
| 204 oop* adr_oop_at(int index) { | |
| 205 return (oop*)&(_cells[index]); | |
| 206 } | |
| 207 | |
| 208 void set_flag_at(int flag_number) { | |
| 209 assert(flag_number < flag_limit, "oob"); | |
| 210 _header._struct._flags |= (0x1 << flag_number); | |
| 211 } | |
| 212 bool flag_at(int flag_number) { | |
| 213 assert(flag_number < flag_limit, "oob"); | |
| 214 return (_header._struct._flags & (0x1 << flag_number)) != 0; | |
| 215 } | |
| 216 | |
| 217 // Low-level support for code generation. | |
| 218 static ByteSize header_offset() { | |
| 219 return byte_offset_of(DataLayout, _header); | |
| 220 } | |
| 221 static ByteSize tag_offset() { | |
| 222 return byte_offset_of(DataLayout, _header._struct._tag); | |
| 223 } | |
| 224 static ByteSize flags_offset() { | |
| 225 return byte_offset_of(DataLayout, _header._struct._flags); | |
| 226 } | |
| 227 static ByteSize bci_offset() { | |
| 228 return byte_offset_of(DataLayout, _header._struct._bci); | |
| 229 } | |
| 230 static ByteSize cell_offset(int index) { | |
|
2333
f767174aac14
7021653: Parfait issue in hotspot/src/share/vm/oops/methodDataOops.hpp
coleenp
parents:
2264
diff
changeset
|
231 return byte_offset_of(DataLayout, _cells) + in_ByteSize(index * cell_size); |
| 0 | 232 } |
| 233 // Return a value which, when or-ed as a byte into _flags, sets the flag. | |
| 234 static int flag_number_to_byte_constant(int flag_number) { | |
| 235 assert(0 <= flag_number && flag_number < flag_limit, "oob"); | |
| 236 DataLayout temp; temp.set_header(0); | |
| 237 temp.set_flag_at(flag_number); | |
| 238 return temp._header._struct._flags; | |
| 239 } | |
| 240 // Return a value which, when or-ed as a word into _header, sets the flag. | |
| 241 static intptr_t flag_mask_to_header_mask(int byte_constant) { | |
| 242 DataLayout temp; temp.set_header(0); | |
| 243 temp._header._struct._flags = byte_constant; | |
| 244 return temp._header._bits; | |
| 245 } | |
| 941 | 246 |
| 247 // GC support | |
| 248 ProfileData* data_in(); | |
| 249 void follow_weak_refs(BoolObjectClosure* cl); | |
| 0 | 250 }; |
| 251 | |
| 252 | |
| 253 // ProfileData class hierarchy | |
| 254 class ProfileData; | |
| 255 class BitData; | |
| 256 class CounterData; | |
| 257 class ReceiverTypeData; | |
| 258 class VirtualCallData; | |
| 259 class RetData; | |
| 260 class JumpData; | |
| 261 class BranchData; | |
| 262 class ArrayData; | |
| 263 class MultiBranchData; | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
264 class ArgInfoData; |
| 0 | 265 |
| 266 | |
| 267 // ProfileData | |
| 268 // | |
| 269 // A ProfileData object is created to refer to a section of profiling | |
| 270 // data in a structured way. | |
| 271 class ProfileData : public ResourceObj { | |
| 272 private: | |
| 273 #ifndef PRODUCT | |
| 274 enum { | |
| 275 tab_width_one = 16, | |
| 276 tab_width_two = 36 | |
| 277 }; | |
| 278 #endif // !PRODUCT | |
| 279 | |
| 280 // This is a pointer to a section of profiling data. | |
| 281 DataLayout* _data; | |
| 282 | |
| 283 protected: | |
| 284 DataLayout* data() { return _data; } | |
| 285 | |
| 286 enum { | |
| 287 cell_size = DataLayout::cell_size | |
| 288 }; | |
| 289 | |
| 290 public: | |
| 291 // How many cells are in this? | |
| 292 virtual int cell_count() { | |
| 293 ShouldNotReachHere(); | |
| 294 return -1; | |
| 295 } | |
| 296 | |
| 297 // Return the size of this data. | |
| 298 int size_in_bytes() { | |
| 299 return DataLayout::compute_size_in_bytes(cell_count()); | |
| 300 } | |
| 301 | |
| 302 protected: | |
| 303 // Low-level accessors for underlying data | |
| 304 void set_intptr_at(int index, intptr_t value) { | |
| 305 assert(0 <= index && index < cell_count(), "oob"); | |
| 306 data()->set_cell_at(index, value); | |
| 307 } | |
| 308 void release_set_intptr_at(int index, intptr_t value) { | |
| 309 assert(0 <= index && index < cell_count(), "oob"); | |
| 310 data()->release_set_cell_at(index, value); | |
| 311 } | |
| 312 intptr_t intptr_at(int index) { | |
| 313 assert(0 <= index && index < cell_count(), "oob"); | |
| 314 return data()->cell_at(index); | |
| 315 } | |
| 316 void set_uint_at(int index, uint value) { | |
| 317 set_intptr_at(index, (intptr_t) value); | |
| 318 } | |
| 319 void release_set_uint_at(int index, uint value) { | |
| 320 release_set_intptr_at(index, (intptr_t) value); | |
| 321 } | |
| 322 uint uint_at(int index) { | |
| 323 return (uint)intptr_at(index); | |
| 324 } | |
| 325 void set_int_at(int index, int value) { | |
| 326 set_intptr_at(index, (intptr_t) value); | |
| 327 } | |
| 328 void release_set_int_at(int index, int value) { | |
| 329 release_set_intptr_at(index, (intptr_t) value); | |
| 330 } | |
| 331 int int_at(int index) { | |
| 332 return (int)intptr_at(index); | |
| 333 } | |
| 334 int int_at_unchecked(int index) { | |
| 335 return (int)data()->cell_at(index); | |
| 336 } | |
| 337 void set_oop_at(int index, oop value) { | |
| 338 set_intptr_at(index, (intptr_t) value); | |
| 339 } | |
| 340 oop oop_at(int index) { | |
| 341 return (oop)intptr_at(index); | |
| 342 } | |
| 343 oop* adr_oop_at(int index) { | |
| 344 assert(0 <= index && index < cell_count(), "oob"); | |
| 345 return data()->adr_oop_at(index); | |
| 346 } | |
| 347 | |
| 348 void set_flag_at(int flag_number) { | |
| 349 data()->set_flag_at(flag_number); | |
| 350 } | |
| 351 bool flag_at(int flag_number) { | |
| 352 return data()->flag_at(flag_number); | |
| 353 } | |
| 354 | |
| 355 // two convenient imports for use by subclasses: | |
| 356 static ByteSize cell_offset(int index) { | |
| 357 return DataLayout::cell_offset(index); | |
| 358 } | |
| 359 static int flag_number_to_byte_constant(int flag_number) { | |
| 360 return DataLayout::flag_number_to_byte_constant(flag_number); | |
| 361 } | |
| 362 | |
| 363 ProfileData(DataLayout* data) { | |
| 364 _data = data; | |
| 365 } | |
| 366 | |
| 367 public: | |
| 368 // Constructor for invalid ProfileData. | |
| 369 ProfileData(); | |
| 370 | |
| 371 u2 bci() { | |
| 372 return data()->bci(); | |
| 373 } | |
| 374 | |
| 375 address dp() { | |
| 376 return (address)_data; | |
| 377 } | |
| 378 | |
| 379 int trap_state() { | |
| 380 return data()->trap_state(); | |
| 381 } | |
| 382 void set_trap_state(int new_state) { | |
| 383 data()->set_trap_state(new_state); | |
| 384 } | |
| 385 | |
| 386 // Type checking | |
| 387 virtual bool is_BitData() { return false; } | |
| 388 virtual bool is_CounterData() { return false; } | |
| 389 virtual bool is_JumpData() { return false; } | |
| 390 virtual bool is_ReceiverTypeData(){ return false; } | |
| 391 virtual bool is_VirtualCallData() { return false; } | |
| 392 virtual bool is_RetData() { return false; } | |
| 393 virtual bool is_BranchData() { return false; } | |
| 394 virtual bool is_ArrayData() { return false; } | |
| 395 virtual bool is_MultiBranchData() { return false; } | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
396 virtual bool is_ArgInfoData() { return false; } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
397 |
| 0 | 398 |
| 399 BitData* as_BitData() { | |
| 400 assert(is_BitData(), "wrong type"); | |
| 401 return is_BitData() ? (BitData*) this : NULL; | |
| 402 } | |
| 403 CounterData* as_CounterData() { | |
| 404 assert(is_CounterData(), "wrong type"); | |
| 405 return is_CounterData() ? (CounterData*) this : NULL; | |
| 406 } | |
| 407 JumpData* as_JumpData() { | |
| 408 assert(is_JumpData(), "wrong type"); | |
| 409 return is_JumpData() ? (JumpData*) this : NULL; | |
| 410 } | |
| 411 ReceiverTypeData* as_ReceiverTypeData() { | |
| 412 assert(is_ReceiverTypeData(), "wrong type"); | |
| 413 return is_ReceiverTypeData() ? (ReceiverTypeData*)this : NULL; | |
| 414 } | |
| 415 VirtualCallData* as_VirtualCallData() { | |
| 416 assert(is_VirtualCallData(), "wrong type"); | |
| 417 return is_VirtualCallData() ? (VirtualCallData*)this : NULL; | |
| 418 } | |
| 419 RetData* as_RetData() { | |
| 420 assert(is_RetData(), "wrong type"); | |
| 421 return is_RetData() ? (RetData*) this : NULL; | |
| 422 } | |
| 423 BranchData* as_BranchData() { | |
| 424 assert(is_BranchData(), "wrong type"); | |
| 425 return is_BranchData() ? (BranchData*) this : NULL; | |
| 426 } | |
| 427 ArrayData* as_ArrayData() { | |
| 428 assert(is_ArrayData(), "wrong type"); | |
| 429 return is_ArrayData() ? (ArrayData*) this : NULL; | |
| 430 } | |
| 431 MultiBranchData* as_MultiBranchData() { | |
| 432 assert(is_MultiBranchData(), "wrong type"); | |
| 433 return is_MultiBranchData() ? (MultiBranchData*)this : NULL; | |
| 434 } | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
435 ArgInfoData* as_ArgInfoData() { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
436 assert(is_ArgInfoData(), "wrong type"); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
437 return is_ArgInfoData() ? (ArgInfoData*)this : NULL; |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
438 } |
| 0 | 439 |
| 440 | |
| 441 // Subclass specific initialization | |
| 442 virtual void post_initialize(BytecodeStream* stream, methodDataOop mdo) {} | |
| 443 | |
| 444 // GC support | |
| 445 virtual void follow_contents() {} | |
| 446 virtual void oop_iterate(OopClosure* blk) {} | |
| 447 virtual void oop_iterate_m(OopClosure* blk, MemRegion mr) {} | |
| 448 virtual void adjust_pointers() {} | |
| 941 | 449 virtual void follow_weak_refs(BoolObjectClosure* is_alive_closure) {} |
| 0 | 450 |
| 451 #ifndef SERIALGC | |
| 452 // Parallel old support | |
| 453 virtual void follow_contents(ParCompactionManager* cm) {} | |
| 454 virtual void update_pointers() {} | |
| 455 #endif // SERIALGC | |
| 456 | |
| 457 // CI translation: ProfileData can represent both MethodDataOop data | |
| 458 // as well as CIMethodData data. This function is provided for translating | |
| 459 // an oop in a ProfileData to the ci equivalent. Generally speaking, | |
| 460 // most ProfileData don't require any translation, so we provide the null | |
| 461 // translation here, and the required translators are in the ci subclasses. | |
| 462 virtual void translate_from(ProfileData* data) {} | |
| 463 | |
| 464 virtual void print_data_on(outputStream* st) { | |
| 465 ShouldNotReachHere(); | |
| 466 } | |
| 467 | |
| 468 #ifndef PRODUCT | |
| 469 void print_shared(outputStream* st, const char* name); | |
| 470 void tab(outputStream* st); | |
| 471 #endif | |
| 472 }; | |
| 473 | |
| 474 // BitData | |
| 475 // | |
| 476 // A BitData holds a flag or two in its header. | |
| 477 class BitData : public ProfileData { | |
| 478 protected: | |
| 479 enum { | |
| 480 // null_seen: | |
| 481 // saw a null operand (cast/aastore/instanceof) | |
| 482 null_seen_flag = DataLayout::first_flag + 0 | |
| 483 }; | |
| 484 enum { bit_cell_count = 0 }; // no additional data fields needed. | |
| 485 public: | |
| 486 BitData(DataLayout* layout) : ProfileData(layout) { | |
| 487 } | |
| 488 | |
| 489 virtual bool is_BitData() { return true; } | |
| 490 | |
| 491 static int static_cell_count() { | |
| 492 return bit_cell_count; | |
| 493 } | |
| 494 | |
| 495 virtual int cell_count() { | |
| 496 return static_cell_count(); | |
| 497 } | |
| 498 | |
| 499 // Accessor | |
| 500 | |
| 501 // The null_seen flag bit is specially known to the interpreter. | |
| 502 // Consulting it allows the compiler to avoid setting up null_check traps. | |
| 503 bool null_seen() { return flag_at(null_seen_flag); } | |
| 504 void set_null_seen() { set_flag_at(null_seen_flag); } | |
| 505 | |
| 506 | |
| 507 // Code generation support | |
| 508 static int null_seen_byte_constant() { | |
| 509 return flag_number_to_byte_constant(null_seen_flag); | |
| 510 } | |
| 511 | |
| 512 static ByteSize bit_data_size() { | |
| 513 return cell_offset(bit_cell_count); | |
| 514 } | |
| 515 | |
| 516 #ifndef PRODUCT | |
| 517 void print_data_on(outputStream* st); | |
| 518 #endif | |
| 519 }; | |
| 520 | |
| 521 // CounterData | |
| 522 // | |
| 523 // A CounterData corresponds to a simple counter. | |
| 524 class CounterData : public BitData { | |
| 525 protected: | |
| 526 enum { | |
| 527 count_off, | |
| 528 counter_cell_count | |
| 529 }; | |
| 530 public: | |
| 531 CounterData(DataLayout* layout) : BitData(layout) {} | |
| 532 | |
| 533 virtual bool is_CounterData() { return true; } | |
| 534 | |
| 535 static int static_cell_count() { | |
| 536 return counter_cell_count; | |
| 537 } | |
| 538 | |
| 539 virtual int cell_count() { | |
| 540 return static_cell_count(); | |
| 541 } | |
| 542 | |
| 543 // Direct accessor | |
| 544 uint count() { | |
| 545 return uint_at(count_off); | |
| 546 } | |
| 547 | |
| 548 // Code generation support | |
| 549 static ByteSize count_offset() { | |
| 550 return cell_offset(count_off); | |
| 551 } | |
| 552 static ByteSize counter_data_size() { | |
| 553 return cell_offset(counter_cell_count); | |
| 554 } | |
| 555 | |
|
1251
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
556 void set_count(uint count) { |
|
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
557 set_uint_at(count_off, count); |
|
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
558 } |
|
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
559 |
| 0 | 560 #ifndef PRODUCT |
| 561 void print_data_on(outputStream* st); | |
| 562 #endif | |
| 563 }; | |
| 564 | |
| 565 // JumpData | |
| 566 // | |
| 567 // A JumpData is used to access profiling information for a direct | |
| 568 // branch. It is a counter, used for counting the number of branches, | |
| 569 // plus a data displacement, used for realigning the data pointer to | |
| 570 // the corresponding target bci. | |
| 571 class JumpData : public ProfileData { | |
| 572 protected: | |
| 573 enum { | |
| 574 taken_off_set, | |
| 575 displacement_off_set, | |
| 576 jump_cell_count | |
| 577 }; | |
| 578 | |
| 579 void set_displacement(int displacement) { | |
| 580 set_int_at(displacement_off_set, displacement); | |
| 581 } | |
| 582 | |
| 583 public: | |
| 584 JumpData(DataLayout* layout) : ProfileData(layout) { | |
| 585 assert(layout->tag() == DataLayout::jump_data_tag || | |
| 586 layout->tag() == DataLayout::branch_data_tag, "wrong type"); | |
| 587 } | |
| 588 | |
| 589 virtual bool is_JumpData() { return true; } | |
| 590 | |
| 591 static int static_cell_count() { | |
| 592 return jump_cell_count; | |
| 593 } | |
| 594 | |
| 595 virtual int cell_count() { | |
| 596 return static_cell_count(); | |
| 597 } | |
| 598 | |
| 599 // Direct accessor | |
| 600 uint taken() { | |
| 601 return uint_at(taken_off_set); | |
| 602 } | |
|
3905
c26de9aef2ed
7071307: MethodHandle bimorphic inlining should consider the frequency
never
parents:
3345
diff
changeset
|
603 |
|
c26de9aef2ed
7071307: MethodHandle bimorphic inlining should consider the frequency
never
parents:
3345
diff
changeset
|
604 void set_taken(uint cnt) { |
|
c26de9aef2ed
7071307: MethodHandle bimorphic inlining should consider the frequency
never
parents:
3345
diff
changeset
|
605 set_uint_at(taken_off_set, cnt); |
|
c26de9aef2ed
7071307: MethodHandle bimorphic inlining should consider the frequency
never
parents:
3345
diff
changeset
|
606 } |
|
c26de9aef2ed
7071307: MethodHandle bimorphic inlining should consider the frequency
never
parents:
3345
diff
changeset
|
607 |
| 0 | 608 // Saturating counter |
| 609 uint inc_taken() { | |
| 610 uint cnt = taken() + 1; | |
| 611 // Did we wrap? Will compiler screw us?? | |
| 612 if (cnt == 0) cnt--; | |
| 613 set_uint_at(taken_off_set, cnt); | |
| 614 return cnt; | |
| 615 } | |
| 616 | |
| 617 int displacement() { | |
| 618 return int_at(displacement_off_set); | |
| 619 } | |
| 620 | |
| 621 // Code generation support | |
| 622 static ByteSize taken_offset() { | |
| 623 return cell_offset(taken_off_set); | |
| 624 } | |
| 625 | |
| 626 static ByteSize displacement_offset() { | |
| 627 return cell_offset(displacement_off_set); | |
| 628 } | |
| 629 | |
| 630 // Specific initialization. | |
| 631 void post_initialize(BytecodeStream* stream, methodDataOop mdo); | |
| 632 | |
| 633 #ifndef PRODUCT | |
| 634 void print_data_on(outputStream* st); | |
| 635 #endif | |
| 636 }; | |
| 637 | |
| 638 // ReceiverTypeData | |
| 639 // | |
| 640 // A ReceiverTypeData is used to access profiling information about a | |
| 641 // dynamic type check. It consists of a counter which counts the total times | |
| 642 // that the check is reached, and a series of (klassOop, count) pairs | |
| 643 // which are used to store a type profile for the receiver of the check. | |
| 644 class ReceiverTypeData : public CounterData { | |
| 645 protected: | |
| 646 enum { | |
| 647 receiver0_offset = counter_cell_count, | |
| 648 count0_offset, | |
| 649 receiver_type_row_cell_count = (count0_offset + 1) - receiver0_offset | |
| 650 }; | |
| 651 | |
| 652 public: | |
| 653 ReceiverTypeData(DataLayout* layout) : CounterData(layout) { | |
| 654 assert(layout->tag() == DataLayout::receiver_type_data_tag || | |
| 655 layout->tag() == DataLayout::virtual_call_data_tag, "wrong type"); | |
| 656 } | |
| 657 | |
| 658 virtual bool is_ReceiverTypeData() { return true; } | |
| 659 | |
| 660 static int static_cell_count() { | |
| 661 return counter_cell_count + (uint) TypeProfileWidth * receiver_type_row_cell_count; | |
| 662 } | |
| 663 | |
| 664 virtual int cell_count() { | |
| 665 return static_cell_count(); | |
| 666 } | |
| 667 | |
| 668 // Direct accessors | |
| 669 static uint row_limit() { | |
| 670 return TypeProfileWidth; | |
| 671 } | |
| 672 static int receiver_cell_index(uint row) { | |
| 673 return receiver0_offset + row * receiver_type_row_cell_count; | |
| 674 } | |
| 675 static int receiver_count_cell_index(uint row) { | |
| 676 return count0_offset + row * receiver_type_row_cell_count; | |
| 677 } | |
| 678 | |
| 679 // Get the receiver at row. The 'unchecked' version is needed by parallel old | |
| 680 // gc; it does not assert the receiver is a klass. During compaction of the | |
| 681 // perm gen, the klass may already have moved, so the is_klass() predicate | |
| 682 // would fail. The 'normal' version should be used whenever possible. | |
| 683 klassOop receiver_unchecked(uint row) { | |
| 684 assert(row < row_limit(), "oob"); | |
| 685 oop recv = oop_at(receiver_cell_index(row)); | |
| 686 return (klassOop)recv; | |
| 687 } | |
| 688 | |
| 689 klassOop receiver(uint row) { | |
| 690 klassOop recv = receiver_unchecked(row); | |
| 691 assert(recv == NULL || ((oop)recv)->is_klass(), "wrong type"); | |
| 692 return recv; | |
| 693 } | |
| 694 | |
| 941 | 695 void set_receiver(uint row, oop p) { |
| 696 assert((uint)row < row_limit(), "oob"); | |
| 697 set_oop_at(receiver_cell_index(row), p); | |
| 698 } | |
| 699 | |
| 0 | 700 uint receiver_count(uint row) { |
| 701 assert(row < row_limit(), "oob"); | |
| 702 return uint_at(receiver_count_cell_index(row)); | |
| 703 } | |
| 704 | |
| 941 | 705 void set_receiver_count(uint row, uint count) { |
| 706 assert(row < row_limit(), "oob"); | |
| 707 set_uint_at(receiver_count_cell_index(row), count); | |
| 708 } | |
| 709 | |
| 710 void clear_row(uint row) { | |
| 711 assert(row < row_limit(), "oob"); | |
|
1251
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
712 // Clear total count - indicator of polymorphic call site. |
|
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
713 // The site may look like as monomorphic after that but |
|
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
714 // it allow to have more accurate profiling information because |
|
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
715 // there was execution phase change since klasses were unloaded. |
|
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
716 // If the site is still polymorphic then MDO will be updated |
|
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
717 // to reflect it. But it could be the case that the site becomes |
|
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
718 // only bimorphic. Then keeping total count not 0 will be wrong. |
|
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
719 // Even if we use monomorphic (when it is not) for compilation |
|
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
720 // we will only have trap, deoptimization and recompile again |
|
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
721 // with updated MDO after executing method in Interpreter. |
|
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
722 // An additional receiver will be recorded in the cleaned row |
|
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
723 // during next call execution. |
|
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
724 // |
|
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
725 // Note: our profiling logic works with empty rows in any slot. |
|
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
726 // We do sorting a profiling info (ciCallProfile) for compilation. |
|
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
727 // |
|
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
728 set_count(0); |
| 941 | 729 set_receiver(row, NULL); |
| 730 set_receiver_count(row, 0); | |
| 731 } | |
| 732 | |
| 0 | 733 // Code generation support |
| 734 static ByteSize receiver_offset(uint row) { | |
| 735 return cell_offset(receiver_cell_index(row)); | |
| 736 } | |
| 737 static ByteSize receiver_count_offset(uint row) { | |
| 738 return cell_offset(receiver_count_cell_index(row)); | |
| 739 } | |
| 740 static ByteSize receiver_type_data_size() { | |
| 741 return cell_offset(static_cell_count()); | |
| 742 } | |
| 743 | |
| 744 // GC support | |
| 745 virtual void follow_contents(); | |
| 746 virtual void oop_iterate(OopClosure* blk); | |
| 747 virtual void oop_iterate_m(OopClosure* blk, MemRegion mr); | |
| 748 virtual void adjust_pointers(); | |
| 941 | 749 virtual void follow_weak_refs(BoolObjectClosure* is_alive_closure); |
| 0 | 750 |
| 751 #ifndef SERIALGC | |
| 752 // Parallel old support | |
| 753 virtual void follow_contents(ParCompactionManager* cm); | |
| 754 virtual void update_pointers(); | |
| 755 #endif // SERIALGC | |
| 756 | |
| 757 oop* adr_receiver(uint row) { | |
| 758 return adr_oop_at(receiver_cell_index(row)); | |
| 759 } | |
| 760 | |
| 761 #ifndef PRODUCT | |
| 762 void print_receiver_data_on(outputStream* st); | |
| 763 void print_data_on(outputStream* st); | |
| 764 #endif | |
| 765 }; | |
| 766 | |
| 767 // VirtualCallData | |
| 768 // | |
| 769 // A VirtualCallData is used to access profiling information about a | |
| 770 // virtual call. For now, it has nothing more than a ReceiverTypeData. | |
| 771 class VirtualCallData : public ReceiverTypeData { | |
| 772 public: | |
| 773 VirtualCallData(DataLayout* layout) : ReceiverTypeData(layout) { | |
| 774 assert(layout->tag() == DataLayout::virtual_call_data_tag, "wrong type"); | |
| 775 } | |
| 776 | |
| 777 virtual bool is_VirtualCallData() { return true; } | |
| 778 | |
| 779 static int static_cell_count() { | |
| 780 // At this point we could add more profile state, e.g., for arguments. | |
| 781 // But for now it's the same size as the base record type. | |
| 782 return ReceiverTypeData::static_cell_count(); | |
| 783 } | |
| 784 | |
| 785 virtual int cell_count() { | |
| 786 return static_cell_count(); | |
| 787 } | |
| 788 | |
| 789 // Direct accessors | |
| 790 static ByteSize virtual_call_data_size() { | |
| 791 return cell_offset(static_cell_count()); | |
| 792 } | |
| 793 | |
| 794 #ifndef PRODUCT | |
| 795 void print_data_on(outputStream* st); | |
| 796 #endif | |
| 797 }; | |
| 798 | |
| 799 // RetData | |
| 800 // | |
| 801 // A RetData is used to access profiling information for a ret bytecode. | |
| 802 // It is composed of a count of the number of times that the ret has | |
| 803 // been executed, followed by a series of triples of the form | |
| 804 // (bci, count, di) which count the number of times that some bci was the | |
| 805 // target of the ret and cache a corresponding data displacement. | |
| 806 class RetData : public CounterData { | |
| 807 protected: | |
| 808 enum { | |
| 809 bci0_offset = counter_cell_count, | |
| 810 count0_offset, | |
| 811 displacement0_offset, | |
| 812 ret_row_cell_count = (displacement0_offset + 1) - bci0_offset | |
| 813 }; | |
| 814 | |
| 815 void set_bci(uint row, int bci) { | |
| 816 assert((uint)row < row_limit(), "oob"); | |
| 817 set_int_at(bci0_offset + row * ret_row_cell_count, bci); | |
| 818 } | |
| 819 void release_set_bci(uint row, int bci) { | |
| 820 assert((uint)row < row_limit(), "oob"); | |
| 821 // 'release' when setting the bci acts as a valid flag for other | |
| 822 // threads wrt bci_count and bci_displacement. | |
| 823 release_set_int_at(bci0_offset + row * ret_row_cell_count, bci); | |
| 824 } | |
| 825 void set_bci_count(uint row, uint count) { | |
| 826 assert((uint)row < row_limit(), "oob"); | |
| 827 set_uint_at(count0_offset + row * ret_row_cell_count, count); | |
| 828 } | |
| 829 void set_bci_displacement(uint row, int disp) { | |
| 830 set_int_at(displacement0_offset + row * ret_row_cell_count, disp); | |
| 831 } | |
| 832 | |
| 833 public: | |
| 834 RetData(DataLayout* layout) : CounterData(layout) { | |
| 835 assert(layout->tag() == DataLayout::ret_data_tag, "wrong type"); | |
| 836 } | |
| 837 | |
| 838 virtual bool is_RetData() { return true; } | |
| 839 | |
| 840 enum { | |
| 841 no_bci = -1 // value of bci when bci1/2 are not in use. | |
| 842 }; | |
| 843 | |
| 844 static int static_cell_count() { | |
| 845 return counter_cell_count + (uint) BciProfileWidth * ret_row_cell_count; | |
| 846 } | |
| 847 | |
| 848 virtual int cell_count() { | |
| 849 return static_cell_count(); | |
| 850 } | |
| 851 | |
| 852 static uint row_limit() { | |
| 853 return BciProfileWidth; | |
| 854 } | |
| 855 static int bci_cell_index(uint row) { | |
| 856 return bci0_offset + row * ret_row_cell_count; | |
| 857 } | |
| 858 static int bci_count_cell_index(uint row) { | |
| 859 return count0_offset + row * ret_row_cell_count; | |
| 860 } | |
| 861 static int bci_displacement_cell_index(uint row) { | |
| 862 return displacement0_offset + row * ret_row_cell_count; | |
| 863 } | |
| 864 | |
| 865 // Direct accessors | |
| 866 int bci(uint row) { | |
| 867 return int_at(bci_cell_index(row)); | |
| 868 } | |
| 869 uint bci_count(uint row) { | |
| 870 return uint_at(bci_count_cell_index(row)); | |
| 871 } | |
| 872 int bci_displacement(uint row) { | |
| 873 return int_at(bci_displacement_cell_index(row)); | |
| 874 } | |
| 875 | |
| 876 // Interpreter Runtime support | |
| 877 address fixup_ret(int return_bci, methodDataHandle mdo); | |
| 878 | |
| 879 // Code generation support | |
| 880 static ByteSize bci_offset(uint row) { | |
| 881 return cell_offset(bci_cell_index(row)); | |
| 882 } | |
| 883 static ByteSize bci_count_offset(uint row) { | |
| 884 return cell_offset(bci_count_cell_index(row)); | |
| 885 } | |
| 886 static ByteSize bci_displacement_offset(uint row) { | |
| 887 return cell_offset(bci_displacement_cell_index(row)); | |
| 888 } | |
| 889 | |
| 890 // Specific initialization. | |
| 891 void post_initialize(BytecodeStream* stream, methodDataOop mdo); | |
| 892 | |
| 893 #ifndef PRODUCT | |
| 894 void print_data_on(outputStream* st); | |
| 895 #endif | |
| 896 }; | |
| 897 | |
| 898 // BranchData | |
| 899 // | |
| 900 // A BranchData is used to access profiling data for a two-way branch. | |
| 901 // It consists of taken and not_taken counts as well as a data displacement | |
| 902 // for the taken case. | |
| 903 class BranchData : public JumpData { | |
| 904 protected: | |
| 905 enum { | |
| 906 not_taken_off_set = jump_cell_count, | |
| 907 branch_cell_count | |
| 908 }; | |
| 909 | |
| 910 void set_displacement(int displacement) { | |
| 911 set_int_at(displacement_off_set, displacement); | |
| 912 } | |
| 913 | |
| 914 public: | |
| 915 BranchData(DataLayout* layout) : JumpData(layout) { | |
| 916 assert(layout->tag() == DataLayout::branch_data_tag, "wrong type"); | |
| 917 } | |
| 918 | |
| 919 virtual bool is_BranchData() { return true; } | |
| 920 | |
| 921 static int static_cell_count() { | |
| 922 return branch_cell_count; | |
| 923 } | |
| 924 | |
| 925 virtual int cell_count() { | |
| 926 return static_cell_count(); | |
| 927 } | |
| 928 | |
| 929 // Direct accessor | |
| 930 uint not_taken() { | |
| 931 return uint_at(not_taken_off_set); | |
| 932 } | |
| 933 | |
|
3905
c26de9aef2ed
7071307: MethodHandle bimorphic inlining should consider the frequency
never
parents:
3345
diff
changeset
|
934 void set_not_taken(uint cnt) { |
|
c26de9aef2ed
7071307: MethodHandle bimorphic inlining should consider the frequency
never
parents:
3345
diff
changeset
|
935 set_uint_at(not_taken_off_set, cnt); |
|
c26de9aef2ed
7071307: MethodHandle bimorphic inlining should consider the frequency
never
parents:
3345
diff
changeset
|
936 } |
|
c26de9aef2ed
7071307: MethodHandle bimorphic inlining should consider the frequency
never
parents:
3345
diff
changeset
|
937 |
| 0 | 938 uint inc_not_taken() { |
| 939 uint cnt = not_taken() + 1; | |
| 940 // Did we wrap? Will compiler screw us?? | |
| 941 if (cnt == 0) cnt--; | |
| 942 set_uint_at(not_taken_off_set, cnt); | |
| 943 return cnt; | |
| 944 } | |
| 945 | |
| 946 // Code generation support | |
| 947 static ByteSize not_taken_offset() { | |
| 948 return cell_offset(not_taken_off_set); | |
| 949 } | |
| 950 static ByteSize branch_data_size() { | |
| 951 return cell_offset(branch_cell_count); | |
| 952 } | |
| 953 | |
| 954 // Specific initialization. | |
| 955 void post_initialize(BytecodeStream* stream, methodDataOop mdo); | |
| 956 | |
| 957 #ifndef PRODUCT | |
| 958 void print_data_on(outputStream* st); | |
| 959 #endif | |
| 960 }; | |
| 961 | |
| 962 // ArrayData | |
| 963 // | |
| 964 // A ArrayData is a base class for accessing profiling data which does | |
| 965 // not have a statically known size. It consists of an array length | |
| 966 // and an array start. | |
| 967 class ArrayData : public ProfileData { | |
| 968 protected: | |
| 969 friend class DataLayout; | |
| 970 | |
| 971 enum { | |
| 972 array_len_off_set, | |
| 973 array_start_off_set | |
| 974 }; | |
| 975 | |
| 976 uint array_uint_at(int index) { | |
| 977 int aindex = index + array_start_off_set; | |
| 978 return uint_at(aindex); | |
| 979 } | |
| 980 int array_int_at(int index) { | |
| 981 int aindex = index + array_start_off_set; | |
| 982 return int_at(aindex); | |
| 983 } | |
| 984 oop array_oop_at(int index) { | |
| 985 int aindex = index + array_start_off_set; | |
| 986 return oop_at(aindex); | |
| 987 } | |
| 988 void array_set_int_at(int index, int value) { | |
| 989 int aindex = index + array_start_off_set; | |
| 990 set_int_at(aindex, value); | |
| 991 } | |
| 992 | |
| 993 // Code generation support for subclasses. | |
| 994 static ByteSize array_element_offset(int index) { | |
| 995 return cell_offset(array_start_off_set + index); | |
| 996 } | |
| 997 | |
| 998 public: | |
| 999 ArrayData(DataLayout* layout) : ProfileData(layout) {} | |
| 1000 | |
| 1001 virtual bool is_ArrayData() { return true; } | |
| 1002 | |
| 1003 static int static_cell_count() { | |
| 1004 return -1; | |
| 1005 } | |
| 1006 | |
| 1007 int array_len() { | |
| 1008 return int_at_unchecked(array_len_off_set); | |
| 1009 } | |
| 1010 | |
| 1011 virtual int cell_count() { | |
| 1012 return array_len() + 1; | |
| 1013 } | |
| 1014 | |
| 1015 // Code generation support | |
| 1016 static ByteSize array_len_offset() { | |
| 1017 return cell_offset(array_len_off_set); | |
| 1018 } | |
| 1019 static ByteSize array_start_offset() { | |
| 1020 return cell_offset(array_start_off_set); | |
| 1021 } | |
| 1022 }; | |
| 1023 | |
| 1024 // MultiBranchData | |
| 1025 // | |
| 1026 // A MultiBranchData is used to access profiling information for | |
| 1027 // a multi-way branch (*switch bytecodes). It consists of a series | |
| 1028 // of (count, displacement) pairs, which count the number of times each | |
| 1029 // case was taken and specify the data displacment for each branch target. | |
| 1030 class MultiBranchData : public ArrayData { | |
| 1031 protected: | |
| 1032 enum { | |
| 1033 default_count_off_set, | |
| 1034 default_disaplacement_off_set, | |
| 1035 case_array_start | |
| 1036 }; | |
| 1037 enum { | |
| 1038 relative_count_off_set, | |
| 1039 relative_displacement_off_set, | |
| 1040 per_case_cell_count | |
| 1041 }; | |
| 1042 | |
| 1043 void set_default_displacement(int displacement) { | |
| 1044 array_set_int_at(default_disaplacement_off_set, displacement); | |
| 1045 } | |
| 1046 void set_displacement_at(int index, int displacement) { | |
| 1047 array_set_int_at(case_array_start + | |
| 1048 index * per_case_cell_count + | |
| 1049 relative_displacement_off_set, | |
| 1050 displacement); | |
| 1051 } | |
| 1052 | |
| 1053 public: | |
| 1054 MultiBranchData(DataLayout* layout) : ArrayData(layout) { | |
| 1055 assert(layout->tag() == DataLayout::multi_branch_data_tag, "wrong type"); | |
| 1056 } | |
| 1057 | |
| 1058 virtual bool is_MultiBranchData() { return true; } | |
| 1059 | |
| 1060 static int compute_cell_count(BytecodeStream* stream); | |
| 1061 | |
| 1062 int number_of_cases() { | |
| 1063 int alen = array_len() - 2; // get rid of default case here. | |
| 1064 assert(alen % per_case_cell_count == 0, "must be even"); | |
| 1065 return (alen / per_case_cell_count); | |
| 1066 } | |
| 1067 | |
| 1068 uint default_count() { | |
| 1069 return array_uint_at(default_count_off_set); | |
| 1070 } | |
| 1071 int default_displacement() { | |
| 1072 return array_int_at(default_disaplacement_off_set); | |
| 1073 } | |
| 1074 | |
| 1075 uint count_at(int index) { | |
| 1076 return array_uint_at(case_array_start + | |
| 1077 index * per_case_cell_count + | |
| 1078 relative_count_off_set); | |
| 1079 } | |
| 1080 int displacement_at(int index) { | |
| 1081 return array_int_at(case_array_start + | |
| 1082 index * per_case_cell_count + | |
| 1083 relative_displacement_off_set); | |
| 1084 } | |
| 1085 | |
| 1086 // Code generation support | |
| 1087 static ByteSize default_count_offset() { | |
| 1088 return array_element_offset(default_count_off_set); | |
| 1089 } | |
| 1090 static ByteSize default_displacement_offset() { | |
| 1091 return array_element_offset(default_disaplacement_off_set); | |
| 1092 } | |
| 1093 static ByteSize case_count_offset(int index) { | |
| 1094 return case_array_offset() + | |
| 1095 (per_case_size() * index) + | |
| 1096 relative_count_offset(); | |
| 1097 } | |
| 1098 static ByteSize case_array_offset() { | |
| 1099 return array_element_offset(case_array_start); | |
| 1100 } | |
| 1101 static ByteSize per_case_size() { | |
| 1102 return in_ByteSize(per_case_cell_count) * cell_size; | |
| 1103 } | |
| 1104 static ByteSize relative_count_offset() { | |
| 1105 return in_ByteSize(relative_count_off_set) * cell_size; | |
| 1106 } | |
| 1107 static ByteSize relative_displacement_offset() { | |
| 1108 return in_ByteSize(relative_displacement_off_set) * cell_size; | |
| 1109 } | |
| 1110 | |
| 1111 // Specific initialization. | |
| 1112 void post_initialize(BytecodeStream* stream, methodDataOop mdo); | |
| 1113 | |
| 1114 #ifndef PRODUCT | |
| 1115 void print_data_on(outputStream* st); | |
| 1116 #endif | |
| 1117 }; | |
| 1118 | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1119 class ArgInfoData : public ArrayData { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1120 |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1121 public: |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1122 ArgInfoData(DataLayout* layout) : ArrayData(layout) { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1123 assert(layout->tag() == DataLayout::arg_info_data_tag, "wrong type"); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1124 } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1125 |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1126 virtual bool is_ArgInfoData() { return true; } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1127 |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1128 |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1129 int number_of_args() { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1130 return array_len(); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1131 } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1132 |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1133 uint arg_modified(int arg) { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1134 return array_uint_at(arg); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1135 } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1136 |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1137 void set_arg_modified(int arg, uint val) { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1138 array_set_int_at(arg, val); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1139 } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1140 |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1141 #ifndef PRODUCT |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1142 void print_data_on(outputStream* st); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1143 #endif |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1144 }; |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1145 |
| 0 | 1146 // methodDataOop |
| 1147 // | |
| 1148 // A methodDataOop holds information which has been collected about | |
| 1149 // a method. Its layout looks like this: | |
| 1150 // | |
| 1151 // ----------------------------- | |
| 1152 // | header | | |
| 1153 // | klass | | |
| 1154 // ----------------------------- | |
| 1155 // | method | | |
| 1156 // | size of the methodDataOop | | |
| 1157 // ----------------------------- | |
| 1158 // | Data entries... | | |
| 1159 // | (variable size) | | |
| 1160 // | | | |
| 1161 // . . | |
| 1162 // . . | |
| 1163 // . . | |
| 1164 // | | | |
| 1165 // ----------------------------- | |
| 1166 // | |
| 1167 // The data entry area is a heterogeneous array of DataLayouts. Each | |
| 1168 // DataLayout in the array corresponds to a specific bytecode in the | |
| 1169 // method. The entries in the array are sorted by the corresponding | |
| 1170 // bytecode. Access to the data is via resource-allocated ProfileData, | |
| 1171 // which point to the underlying blocks of DataLayout structures. | |
| 1172 // | |
| 1173 // During interpretation, if profiling in enabled, the interpreter | |
| 1174 // maintains a method data pointer (mdp), which points at the entry | |
| 1175 // in the array corresponding to the current bci. In the course of | |
| 1176 // intepretation, when a bytecode is encountered that has profile data | |
| 1177 // associated with it, the entry pointed to by mdp is updated, then the | |
| 1178 // mdp is adjusted to point to the next appropriate DataLayout. If mdp | |
| 1179 // is NULL to begin with, the interpreter assumes that the current method | |
| 1180 // is not (yet) being profiled. | |
| 1181 // | |
| 1182 // In methodDataOop parlance, "dp" is a "data pointer", the actual address | |
| 1183 // of a DataLayout element. A "di" is a "data index", the offset in bytes | |
| 1184 // from the base of the data entry array. A "displacement" is the byte offset | |
| 1185 // in certain ProfileData objects that indicate the amount the mdp must be | |
| 1186 // adjusted in the event of a change in control flow. | |
| 1187 // | |
| 1188 | |
| 1189 class methodDataOopDesc : public oopDesc { | |
| 1190 friend class VMStructs; | |
| 1191 private: | |
| 1192 friend class ProfileData; | |
| 1193 | |
| 1194 // Back pointer to the methodOop | |
| 1195 methodOop _method; | |
| 1196 | |
| 1197 // Size of this oop in bytes | |
| 1198 int _size; | |
| 1199 | |
| 1200 // Cached hint for bci_to_dp and bci_to_data | |
| 1201 int _hint_di; | |
| 1202 | |
| 1203 // Whole-method sticky bits and flags | |
| 1204 public: | |
| 1205 enum { | |
| 3345 | 1206 _trap_hist_limit = 17, // decoupled from Deoptimization::Reason_LIMIT |
| 0 | 1207 _trap_hist_mask = max_jubyte, |
| 1208 _extra_data_count = 4 // extra DataLayout headers, for trap history | |
| 1209 }; // Public flag values | |
| 1210 private: | |
| 1211 uint _nof_decompiles; // count of all nmethod removals | |
| 1212 uint _nof_overflow_recompiles; // recompile count, excluding recomp. bits | |
| 1213 uint _nof_overflow_traps; // trap count, excluding _trap_hist | |
| 1214 union { | |
| 1215 intptr_t _align; | |
| 1216 u1 _array[_trap_hist_limit]; | |
| 1217 } _trap_hist; | |
| 1218 | |
| 1219 // Support for interprocedural escape analysis, from Thomas Kotzmann. | |
| 1220 intx _eflags; // flags on escape information | |
| 1221 intx _arg_local; // bit set of non-escaping arguments | |
| 1222 intx _arg_stack; // bit set of stack-allocatable arguments | |
| 1223 intx _arg_returned; // bit set of returned arguments | |
| 1224 | |
| 1783 | 1225 int _creation_mileage; // method mileage at MDO creation |
| 1226 | |
| 1227 // How many invocations has this MDO seen? | |
| 1228 // These counters are used to determine the exact age of MDO. | |
| 1229 // We need those because in tiered a method can be concurrently | |
| 1230 // executed at different levels. | |
| 1231 InvocationCounter _invocation_counter; | |
| 1232 // Same for backedges. | |
| 1233 InvocationCounter _backedge_counter; | |
| 2252 | 1234 // Counter values at the time profiling started. |
| 1235 int _invocation_counter_start; | |
| 1236 int _backedge_counter_start; | |
| 1783 | 1237 // Number of loops and blocks is computed when compiling the first |
| 1238 // time with C1. It is used to determine if method is trivial. | |
| 1239 short _num_loops; | |
| 1240 short _num_blocks; | |
| 1241 // Highest compile level this method has ever seen. | |
| 1242 u1 _highest_comp_level; | |
| 1243 // Same for OSR level | |
| 1244 u1 _highest_osr_comp_level; | |
| 1245 // Does this method contain anything worth profiling? | |
| 1246 bool _would_profile; | |
| 0 | 1247 |
| 1248 // Size of _data array in bytes. (Excludes header and extra_data fields.) | |
| 1249 int _data_size; | |
| 1250 | |
| 1251 // Beginning of the data entries | |
| 1252 intptr_t _data[1]; | |
| 1253 | |
| 1254 // Helper for size computation | |
| 1255 static int compute_data_size(BytecodeStream* stream); | |
| 1256 static int bytecode_cell_count(Bytecodes::Code code); | |
| 1257 enum { no_profile_data = -1, variable_cell_count = -2 }; | |
| 1258 | |
| 1259 // Helper for initialization | |
| 1260 DataLayout* data_layout_at(int data_index) { | |
| 1261 assert(data_index % sizeof(intptr_t) == 0, "unaligned"); | |
| 1262 return (DataLayout*) (((address)_data) + data_index); | |
| 1263 } | |
| 1264 | |
| 1265 // Initialize an individual data segment. Returns the size of | |
| 1266 // the segment in bytes. | |
| 1267 int initialize_data(BytecodeStream* stream, int data_index); | |
| 1268 | |
| 1269 // Helper for data_at | |
| 1270 DataLayout* limit_data_position() { | |
| 1271 return (DataLayout*)((address)data_base() + _data_size); | |
| 1272 } | |
| 1273 bool out_of_bounds(int data_index) { | |
| 1274 return data_index >= data_size(); | |
| 1275 } | |
| 1276 | |
| 1277 // Give each of the data entries a chance to perform specific | |
| 1278 // data initialization. | |
| 1279 void post_initialize(BytecodeStream* stream); | |
| 1280 | |
| 1281 // hint accessors | |
| 1282 int hint_di() const { return _hint_di; } | |
| 1283 void set_hint_di(int di) { | |
| 1284 assert(!out_of_bounds(di), "hint_di out of bounds"); | |
| 1285 _hint_di = di; | |
| 1286 } | |
| 1287 ProfileData* data_before(int bci) { | |
| 1288 // avoid SEGV on this edge case | |
| 1289 if (data_size() == 0) | |
| 1290 return NULL; | |
| 1291 int hint = hint_di(); | |
| 1292 if (data_layout_at(hint)->bci() <= bci) | |
| 1293 return data_at(hint); | |
| 1294 return first_data(); | |
| 1295 } | |
| 1296 | |
| 1297 // What is the index of the first data entry? | |
| 1298 int first_di() { return 0; } | |
| 1299 | |
| 1300 // Find or create an extra ProfileData: | |
| 1301 ProfileData* bci_to_extra_data(int bci, bool create_if_missing); | |
| 1302 | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1303 // return the argument info cell |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1304 ArgInfoData *arg_info(); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1305 |
| 0 | 1306 public: |
| 1307 static int header_size() { | |
| 1308 return sizeof(methodDataOopDesc)/wordSize; | |
| 1309 } | |
| 1310 | |
| 1311 // Compute the size of a methodDataOop before it is created. | |
| 1312 static int compute_allocation_size_in_bytes(methodHandle method); | |
| 1313 static int compute_allocation_size_in_words(methodHandle method); | |
| 1314 static int compute_extra_data_count(int data_size, int empty_bc_count); | |
| 1315 | |
| 1316 // Determine if a given bytecode can have profile information. | |
| 1317 static bool bytecode_has_profile(Bytecodes::Code code) { | |
| 1318 return bytecode_cell_count(code) != no_profile_data; | |
| 1319 } | |
| 1320 | |
| 1321 // Perform initialization of a new methodDataOop | |
| 1322 void initialize(methodHandle method); | |
| 1323 | |
| 1324 // My size | |
| 1325 int object_size_in_bytes() { return _size; } | |
| 1326 int object_size() { | |
| 1327 return align_object_size(align_size_up(_size, BytesPerWord)/BytesPerWord); | |
| 1328 } | |
| 1329 | |
| 1330 int creation_mileage() const { return _creation_mileage; } | |
| 1331 void set_creation_mileage(int x) { _creation_mileage = x; } | |
| 1783 | 1332 |
| 1333 int invocation_count() { | |
| 1334 if (invocation_counter()->carry()) { | |
| 1335 return InvocationCounter::count_limit; | |
| 1336 } | |
| 1337 return invocation_counter()->count(); | |
| 1338 } | |
| 1339 int backedge_count() { | |
| 1340 if (backedge_counter()->carry()) { | |
| 1341 return InvocationCounter::count_limit; | |
| 1342 } | |
| 1343 return backedge_counter()->count(); | |
| 1344 } | |
| 1345 | |
| 2252 | 1346 int invocation_count_start() { |
| 1347 if (invocation_counter()->carry()) { | |
| 1348 return 0; | |
| 1349 } | |
| 1350 return _invocation_counter_start; | |
| 1351 } | |
| 1352 | |
| 1353 int backedge_count_start() { | |
| 1354 if (backedge_counter()->carry()) { | |
| 1355 return 0; | |
| 1356 } | |
| 1357 return _backedge_counter_start; | |
| 1358 } | |
| 1359 | |
| 1360 int invocation_count_delta() { return invocation_count() - invocation_count_start(); } | |
| 1361 int backedge_count_delta() { return backedge_count() - backedge_count_start(); } | |
| 1362 | |
| 1363 void reset_start_counters() { | |
| 1364 _invocation_counter_start = invocation_count(); | |
| 1365 _backedge_counter_start = backedge_count(); | |
| 1366 } | |
| 1367 | |
| 1783 | 1368 InvocationCounter* invocation_counter() { return &_invocation_counter; } |
| 1369 InvocationCounter* backedge_counter() { return &_backedge_counter; } | |
| 1370 | |
| 1371 void set_would_profile(bool p) { _would_profile = p; } | |
| 1372 bool would_profile() const { return _would_profile; } | |
| 1373 | |
| 1374 int highest_comp_level() { return _highest_comp_level; } | |
| 1375 void set_highest_comp_level(int level) { _highest_comp_level = level; } | |
| 1376 int highest_osr_comp_level() { return _highest_osr_comp_level; } | |
| 1377 void set_highest_osr_comp_level(int level) { _highest_osr_comp_level = level; } | |
| 1378 | |
| 1379 int num_loops() const { return _num_loops; } | |
| 1380 void set_num_loops(int n) { _num_loops = n; } | |
| 1381 int num_blocks() const { return _num_blocks; } | |
| 1382 void set_num_blocks(int n) { _num_blocks = n; } | |
| 1383 | |
| 0 | 1384 bool is_mature() const; // consult mileage and ProfileMaturityPercentage |
| 1385 static int mileage_of(methodOop m); | |
| 1386 | |
| 1387 // Support for interprocedural escape analysis, from Thomas Kotzmann. | |
| 1388 enum EscapeFlag { | |
| 1389 estimated = 1 << 0, | |
|
78
e1e86702e43e
6680665: bytecode Escape Analyzer produces incorrect escape information for methods without oop arguments
kvn
parents:
45
diff
changeset
|
1390 return_local = 1 << 1, |
|
e1e86702e43e
6680665: bytecode Escape Analyzer produces incorrect escape information for methods without oop arguments
kvn
parents:
45
diff
changeset
|
1391 return_allocated = 1 << 2, |
|
e1e86702e43e
6680665: bytecode Escape Analyzer produces incorrect escape information for methods without oop arguments
kvn
parents:
45
diff
changeset
|
1392 allocated_escapes = 1 << 3, |
|
e1e86702e43e
6680665: bytecode Escape Analyzer produces incorrect escape information for methods without oop arguments
kvn
parents:
45
diff
changeset
|
1393 unknown_modified = 1 << 4 |
| 0 | 1394 }; |
| 1395 | |
| 1396 intx eflags() { return _eflags; } | |
| 1397 intx arg_local() { return _arg_local; } | |
| 1398 intx arg_stack() { return _arg_stack; } | |
| 1399 intx arg_returned() { return _arg_returned; } | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1400 uint arg_modified(int a) { ArgInfoData *aid = arg_info(); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1401 assert(a >= 0 && a < aid->number_of_args(), "valid argument number"); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1402 return aid->arg_modified(a); } |
| 0 | 1403 |
| 1404 void set_eflags(intx v) { _eflags = v; } | |
| 1405 void set_arg_local(intx v) { _arg_local = v; } | |
| 1406 void set_arg_stack(intx v) { _arg_stack = v; } | |
| 1407 void set_arg_returned(intx v) { _arg_returned = v; } | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1408 void set_arg_modified(int a, uint v) { ArgInfoData *aid = arg_info(); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1409 assert(a >= 0 && a < aid->number_of_args(), "valid argument number"); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1410 |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
1411 aid->set_arg_modified(a, v); } |
| 0 | 1412 |
| 1413 void clear_escape_info() { _eflags = _arg_local = _arg_stack = _arg_returned = 0; } | |
| 1414 | |
| 1415 // Location and size of data area | |
| 1416 address data_base() const { | |
| 1417 return (address) _data; | |
| 1418 } | |
| 1419 int data_size() { | |
| 1420 return _data_size; | |
| 1421 } | |
| 1422 | |
| 1423 // Accessors | |
| 1424 methodOop method() { return _method; } | |
| 1425 | |
| 1426 // Get the data at an arbitrary (sort of) data index. | |
| 1427 ProfileData* data_at(int data_index); | |
| 1428 | |
| 1429 // Walk through the data in order. | |
| 1430 ProfileData* first_data() { return data_at(first_di()); } | |
| 1431 ProfileData* next_data(ProfileData* current); | |
| 1432 bool is_valid(ProfileData* current) { return current != NULL; } | |
| 1433 | |
| 1434 // Convert a dp (data pointer) to a di (data index). | |
| 1435 int dp_to_di(address dp) { | |
| 1436 return dp - ((address)_data); | |
| 1437 } | |
| 1438 | |
| 1439 address di_to_dp(int di) { | |
| 1440 return (address)data_layout_at(di); | |
| 1441 } | |
| 1442 | |
| 1443 // bci to di/dp conversion. | |
| 1444 address bci_to_dp(int bci); | |
| 1445 int bci_to_di(int bci) { | |
| 1446 return dp_to_di(bci_to_dp(bci)); | |
| 1447 } | |
| 1448 | |
| 1449 // Get the data at an arbitrary bci, or NULL if there is none. | |
| 1450 ProfileData* bci_to_data(int bci); | |
| 1451 | |
| 1452 // Same, but try to create an extra_data record if one is needed: | |
| 1453 ProfileData* allocate_bci_to_data(int bci) { | |
| 1454 ProfileData* data = bci_to_data(bci); | |
| 1455 return (data != NULL) ? data : bci_to_extra_data(bci, true); | |
| 1456 } | |
| 1457 | |
| 1458 // Add a handful of extra data records, for trap tracking. | |
| 1459 DataLayout* extra_data_base() { return limit_data_position(); } | |
| 1460 DataLayout* extra_data_limit() { return (DataLayout*)((address)this + object_size_in_bytes()); } | |
| 1461 int extra_data_size() { return (address)extra_data_limit() | |
| 1462 - (address)extra_data_base(); } | |
| 1463 static DataLayout* next_extra(DataLayout* dp) { return (DataLayout*)((address)dp + in_bytes(DataLayout::cell_offset(0))); } | |
| 1464 | |
| 1465 // Return (uint)-1 for overflow. | |
| 1466 uint trap_count(int reason) const { | |
| 1467 assert((uint)reason < _trap_hist_limit, "oob"); | |
| 1468 return (int)((_trap_hist._array[reason]+1) & _trap_hist_mask) - 1; | |
| 1469 } | |
| 1470 // For loops: | |
| 1471 static uint trap_reason_limit() { return _trap_hist_limit; } | |
| 1472 static uint trap_count_limit() { return _trap_hist_mask; } | |
| 1473 uint inc_trap_count(int reason) { | |
| 1474 // Count another trap, anywhere in this method. | |
| 1475 assert(reason >= 0, "must be single trap"); | |
| 1476 if ((uint)reason < _trap_hist_limit) { | |
| 1477 uint cnt1 = 1 + _trap_hist._array[reason]; | |
| 1478 if ((cnt1 & _trap_hist_mask) != 0) { // if no counter overflow... | |
| 1479 _trap_hist._array[reason] = cnt1; | |
| 1480 return cnt1; | |
| 1481 } else { | |
| 1482 return _trap_hist_mask + (++_nof_overflow_traps); | |
| 1483 } | |
| 1484 } else { | |
| 1485 // Could not represent the count in the histogram. | |
| 1486 return (++_nof_overflow_traps); | |
| 1487 } | |
| 1488 } | |
| 1489 | |
| 1490 uint overflow_trap_count() const { | |
| 1491 return _nof_overflow_traps; | |
| 1492 } | |
| 1493 uint overflow_recompile_count() const { | |
| 1494 return _nof_overflow_recompiles; | |
| 1495 } | |
| 1496 void inc_overflow_recompile_count() { | |
| 1497 _nof_overflow_recompiles += 1; | |
| 1498 } | |
| 1499 uint decompile_count() const { | |
| 1500 return _nof_decompiles; | |
| 1501 } | |
| 1502 void inc_decompile_count() { | |
| 1503 _nof_decompiles += 1; | |
|
1206
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
948
diff
changeset
|
1504 if (decompile_count() > (uint)PerMethodRecompilationCutoff) { |
| 1783 | 1505 method()->set_not_compilable(CompLevel_full_optimization); |
|
1206
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
948
diff
changeset
|
1506 } |
| 0 | 1507 } |
| 1508 | |
| 1509 // Support for code generation | |
| 1510 static ByteSize data_offset() { | |
| 1511 return byte_offset_of(methodDataOopDesc, _data[0]); | |
| 1512 } | |
| 1513 | |
| 1783 | 1514 static ByteSize invocation_counter_offset() { |
| 1515 return byte_offset_of(methodDataOopDesc, _invocation_counter); | |
| 1516 } | |
| 1517 static ByteSize backedge_counter_offset() { | |
| 1518 return byte_offset_of(methodDataOopDesc, _backedge_counter); | |
| 1519 } | |
| 1520 | |
| 0 | 1521 // GC support |
| 1522 oop* adr_method() const { return (oop*)&_method; } | |
| 1523 bool object_is_parsable() const { return _size != 0; } | |
| 1524 void set_object_is_parsable(int object_size_in_bytes) { _size = object_size_in_bytes; } | |
| 1525 | |
| 1526 #ifndef PRODUCT | |
| 1527 // printing support for method data | |
| 1528 void print_data_on(outputStream* st); | |
| 1529 #endif | |
| 1530 | |
| 1531 // verification | |
| 1532 void verify_data_on(outputStream* st); | |
| 1533 }; | |
| 1972 | 1534 |
| 1535 #endif // SHARE_VM_OOPS_METHODDATAOOP_HPP |