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