Mercurial > hg > truffle
annotate src/share/vm/oops/methodData.cpp @ 9126:bc26f978b0ce
HotSpotResolvedObjectType: implement hasFinalizeSubclass() correctly
don't use the (wrong) cached value, but ask the runtime on each request.
Fixes regression on xml.* benchmarks @ specjvm2008. The problem was:
After the constructor of Object was deoptimized due to an assumption violation,
it was recompiled again after some time. However, on recompilation, the value
of hasFinalizeSubclass for the class was not updated and it was compiled again
with a, now wrong, assumption, which then triggers deoptimization again.
This was repeated until it hit the recompilation limit (defined by
PerMethodRecompilationCutoff), and therefore only executed by the interpreter
from now on, causing the performance regression.
| author | Bernhard Urban <bernhard.urban@jku.at> |
|---|---|
| date | Mon, 15 Apr 2013 19:54:58 +0200 |
| parents | 89e4d67fdd2a |
| children | 57e5211846f9 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 7956 | 2 * Copyright (c) 2000, 2013, 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:
941
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
941
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:
941
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "classfile/systemDictionary.hpp" | |
| 27 #include "interpreter/bytecode.hpp" | |
| 28 #include "interpreter/bytecodeStream.hpp" | |
| 29 #include "interpreter/linkResolver.hpp" | |
| 7956 | 30 #include "memory/heapInspection.hpp" |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
31 #include "oops/methodData.hpp" |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
32 #include "prims/jvmtiRedefineClasses.hpp" |
| 1972 | 33 #include "runtime/compilationPolicy.hpp" |
| 34 #include "runtime/deoptimization.hpp" | |
| 35 #include "runtime/handles.inline.hpp" | |
| 0 | 36 |
| 37 // ================================================================== | |
| 38 // DataLayout | |
| 39 // | |
| 40 // Overlay for generic profiling data. | |
| 41 | |
| 42 // Some types of data layouts need a length field. | |
| 43 bool DataLayout::needs_array_len(u1 tag) { | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
44 return (tag == multi_branch_data_tag) || (tag == arg_info_data_tag); |
| 0 | 45 } |
| 46 | |
| 47 // Perform generic initialization of the data. More specific | |
| 48 // initialization occurs in overrides of ProfileData::post_initialize. | |
| 49 void DataLayout::initialize(u1 tag, u2 bci, int cell_count) { | |
| 50 _header._bits = (intptr_t)0; | |
| 51 _header._struct._tag = tag; | |
| 52 _header._struct._bci = bci; | |
| 53 for (int i = 0; i < cell_count; i++) { | |
| 54 set_cell_at(i, (intptr_t)0); | |
| 55 } | |
| 56 if (needs_array_len(tag)) { | |
| 57 set_cell_at(ArrayData::array_len_off_set, cell_count - 1); // -1 for header. | |
| 58 } | |
| 59 } | |
| 60 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
61 void DataLayout::clean_weak_klass_links(BoolObjectClosure* cl) { |
| 941 | 62 ResourceMark m; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
63 data_in()->clean_weak_klass_links(cl); |
| 941 | 64 } |
| 65 | |
| 66 | |
| 0 | 67 // ================================================================== |
| 68 // ProfileData | |
| 69 // | |
| 70 // A ProfileData object is created to refer to a section of profiling | |
| 71 // data in a structured way. | |
| 72 | |
| 73 // Constructor for invalid ProfileData. | |
| 74 ProfileData::ProfileData() { | |
| 75 _data = NULL; | |
| 76 } | |
| 77 | |
| 78 #ifndef PRODUCT | |
| 79 void ProfileData::print_shared(outputStream* st, const char* name) { | |
| 80 st->print("bci: %d", bci()); | |
| 81 st->fill_to(tab_width_one); | |
| 82 st->print("%s", name); | |
| 83 tab(st); | |
| 84 int trap = trap_state(); | |
| 85 if (trap != 0) { | |
| 86 char buf[100]; | |
| 87 st->print("trap(%s) ", Deoptimization::format_trap_state(buf, sizeof(buf), trap)); | |
| 88 } | |
| 89 int flags = data()->flags(); | |
| 90 if (flags != 0) | |
| 91 st->print("flags(%d) ", flags); | |
| 92 } | |
| 93 | |
| 94 void ProfileData::tab(outputStream* st) { | |
| 95 st->fill_to(tab_width_two); | |
| 96 } | |
| 97 #endif // !PRODUCT | |
| 98 | |
| 99 // ================================================================== | |
| 100 // BitData | |
| 101 // | |
| 102 // A BitData corresponds to a one-bit flag. This is used to indicate | |
| 103 // whether a checkcast bytecode has seen a null value. | |
| 104 | |
| 105 | |
| 106 #ifndef PRODUCT | |
| 107 void BitData::print_data_on(outputStream* st) { | |
| 108 print_shared(st, "BitData"); | |
| 109 } | |
| 110 #endif // !PRODUCT | |
| 111 | |
| 112 // ================================================================== | |
| 113 // CounterData | |
| 114 // | |
| 115 // A CounterData corresponds to a simple counter. | |
| 116 | |
| 117 #ifndef PRODUCT | |
| 118 void CounterData::print_data_on(outputStream* st) { | |
| 119 print_shared(st, "CounterData"); | |
| 120 st->print_cr("count(%u)", count()); | |
| 121 } | |
| 122 #endif // !PRODUCT | |
| 123 | |
| 124 // ================================================================== | |
| 125 // JumpData | |
| 126 // | |
| 127 // A JumpData is used to access profiling information for a direct | |
| 128 // branch. It is a counter, used for counting the number of branches, | |
| 129 // plus a data displacement, used for realigning the data pointer to | |
| 130 // the corresponding target bci. | |
| 131 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
132 void JumpData::post_initialize(BytecodeStream* stream, MethodData* mdo) { |
| 0 | 133 assert(stream->bci() == bci(), "wrong pos"); |
| 134 int target; | |
| 135 Bytecodes::Code c = stream->code(); | |
| 136 if (c == Bytecodes::_goto_w || c == Bytecodes::_jsr_w) { | |
| 137 target = stream->dest_w(); | |
| 138 } else { | |
| 139 target = stream->dest(); | |
| 140 } | |
| 141 int my_di = mdo->dp_to_di(dp()); | |
| 142 int target_di = mdo->bci_to_di(target); | |
| 143 int offset = target_di - my_di; | |
| 144 set_displacement(offset); | |
| 145 } | |
| 146 | |
| 147 #ifndef PRODUCT | |
| 148 void JumpData::print_data_on(outputStream* st) { | |
| 149 print_shared(st, "JumpData"); | |
| 150 st->print_cr("taken(%u) displacement(%d)", taken(), displacement()); | |
| 151 } | |
| 152 #endif // !PRODUCT | |
| 153 | |
| 154 // ================================================================== | |
| 155 // ReceiverTypeData | |
| 156 // | |
| 157 // A ReceiverTypeData is used to access profiling information about a | |
| 158 // 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:
2264
diff
changeset
|
159 // that the check is reached, and a series of (Klass*, count) pairs |
| 0 | 160 // which are used to store a type profile for the receiver of the check. |
| 161 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
162 void ReceiverTypeData::clean_weak_klass_links(BoolObjectClosure* is_alive_cl) { |
| 941 | 163 for (uint row = 0; row < row_limit(); row++) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
164 Klass* p = receiver(row); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
165 if (p != NULL && !p->is_loader_alive(is_alive_cl)) { |
| 941 | 166 clear_row(row); |
| 167 } | |
| 168 } | |
| 169 } | |
| 170 | |
| 0 | 171 #ifndef PRODUCT |
| 172 void ReceiverTypeData::print_receiver_data_on(outputStream* st) { | |
| 173 uint row; | |
| 174 int entries = 0; | |
| 175 for (row = 0; row < row_limit(); row++) { | |
| 176 if (receiver(row) != NULL) entries++; | |
| 177 } | |
| 178 st->print_cr("count(%u) entries(%u)", count(), entries); | |
| 1783 | 179 int total = count(); |
| 180 for (row = 0; row < row_limit(); row++) { | |
| 181 if (receiver(row) != NULL) { | |
| 182 total += receiver_count(row); | |
| 183 } | |
| 184 } | |
| 0 | 185 for (row = 0; row < row_limit(); row++) { |
| 186 if (receiver(row) != NULL) { | |
| 187 tab(st); | |
| 188 receiver(row)->print_value_on(st); | |
| 1783 | 189 st->print_cr("(%u %4.2f)", receiver_count(row), (float) receiver_count(row) / (float) total); |
| 0 | 190 } |
| 191 } | |
| 192 } | |
| 193 void ReceiverTypeData::print_data_on(outputStream* st) { | |
| 194 print_shared(st, "ReceiverTypeData"); | |
| 195 print_receiver_data_on(st); | |
| 196 } | |
| 197 void VirtualCallData::print_data_on(outputStream* st) { | |
| 198 print_shared(st, "VirtualCallData"); | |
| 199 print_receiver_data_on(st); | |
| 200 } | |
| 201 #endif // !PRODUCT | |
| 202 | |
| 203 // ================================================================== | |
| 204 // RetData | |
| 205 // | |
| 206 // A RetData is used to access profiling information for a ret bytecode. | |
| 207 // It is composed of a count of the number of times that the ret has | |
| 208 // been executed, followed by a series of triples of the form | |
| 209 // (bci, count, di) which count the number of times that some bci was the | |
| 210 // target of the ret and cache a corresponding displacement. | |
| 211 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
212 void RetData::post_initialize(BytecodeStream* stream, MethodData* mdo) { |
| 0 | 213 for (uint row = 0; row < row_limit(); row++) { |
| 214 set_bci_displacement(row, -1); | |
| 215 set_bci(row, no_bci); | |
| 216 } | |
| 217 // release so other threads see a consistent state. bci is used as | |
| 218 // a valid flag for bci_displacement. | |
| 219 OrderAccess::release(); | |
| 220 } | |
| 221 | |
| 222 // This routine needs to atomically update the RetData structure, so the | |
| 223 // caller needs to hold the RetData_lock before it gets here. Since taking | |
| 224 // the lock can block (and allow GC) and since RetData is a ProfileData is a | |
| 225 // wrapper around a derived oop, taking the lock in _this_ method will | |
| 226 // basically cause the 'this' pointer's _data field to contain junk after the | |
| 227 // lock. We require the caller to take the lock before making the ProfileData | |
| 228 // structure. Currently the only caller is InterpreterRuntime::update_mdp_for_ret | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
229 address RetData::fixup_ret(int return_bci, MethodData* h_mdo) { |
| 0 | 230 // First find the mdp which corresponds to the return bci. |
| 231 address mdp = h_mdo->bci_to_dp(return_bci); | |
| 232 | |
| 233 // Now check to see if any of the cache slots are open. | |
| 234 for (uint row = 0; row < row_limit(); row++) { | |
| 235 if (bci(row) == no_bci) { | |
| 236 set_bci_displacement(row, mdp - dp()); | |
| 237 set_bci_count(row, DataLayout::counter_increment); | |
| 238 // Barrier to ensure displacement is written before the bci; allows | |
| 239 // the interpreter to read displacement without fear of race condition. | |
| 240 release_set_bci(row, return_bci); | |
| 241 break; | |
| 242 } | |
| 243 } | |
| 244 return mdp; | |
| 245 } | |
| 246 | |
| 247 | |
| 248 #ifndef PRODUCT | |
| 249 void RetData::print_data_on(outputStream* st) { | |
| 250 print_shared(st, "RetData"); | |
| 251 uint row; | |
| 252 int entries = 0; | |
| 253 for (row = 0; row < row_limit(); row++) { | |
| 254 if (bci(row) != no_bci) entries++; | |
| 255 } | |
| 256 st->print_cr("count(%u) entries(%u)", count(), entries); | |
| 257 for (row = 0; row < row_limit(); row++) { | |
| 258 if (bci(row) != no_bci) { | |
| 259 tab(st); | |
| 260 st->print_cr("bci(%d: count(%u) displacement(%d))", | |
| 261 bci(row), bci_count(row), bci_displacement(row)); | |
| 262 } | |
| 263 } | |
| 264 } | |
| 265 #endif // !PRODUCT | |
| 266 | |
| 267 // ================================================================== | |
| 268 // BranchData | |
| 269 // | |
| 270 // A BranchData is used to access profiling data for a two-way branch. | |
| 271 // It consists of taken and not_taken counts as well as a data displacement | |
| 272 // for the taken case. | |
| 273 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
274 void BranchData::post_initialize(BytecodeStream* stream, MethodData* mdo) { |
| 0 | 275 assert(stream->bci() == bci(), "wrong pos"); |
| 276 int target = stream->dest(); | |
| 277 int my_di = mdo->dp_to_di(dp()); | |
| 278 int target_di = mdo->bci_to_di(target); | |
| 279 int offset = target_di - my_di; | |
| 280 set_displacement(offset); | |
| 281 } | |
| 282 | |
| 283 #ifndef PRODUCT | |
| 284 void BranchData::print_data_on(outputStream* st) { | |
| 285 print_shared(st, "BranchData"); | |
| 286 st->print_cr("taken(%u) displacement(%d)", | |
| 287 taken(), displacement()); | |
| 288 tab(st); | |
| 289 st->print_cr("not taken(%u)", not_taken()); | |
| 290 } | |
| 291 #endif | |
| 292 | |
| 293 // ================================================================== | |
| 294 // MultiBranchData | |
| 295 // | |
| 296 // A MultiBranchData is used to access profiling information for | |
| 297 // a multi-way branch (*switch bytecodes). It consists of a series | |
| 298 // of (count, displacement) pairs, which count the number of times each | |
| 299 // case was taken and specify the data displacment for each branch target. | |
| 300 | |
| 301 int MultiBranchData::compute_cell_count(BytecodeStream* stream) { | |
| 302 int cell_count = 0; | |
| 303 if (stream->code() == Bytecodes::_tableswitch) { | |
| 2142 | 304 Bytecode_tableswitch sw(stream->method()(), stream->bcp()); |
| 305 cell_count = 1 + per_case_cell_count * (1 + sw.length()); // 1 for default | |
| 0 | 306 } else { |
| 2142 | 307 Bytecode_lookupswitch sw(stream->method()(), stream->bcp()); |
| 308 cell_count = 1 + per_case_cell_count * (sw.number_of_pairs() + 1); // 1 for default | |
| 0 | 309 } |
| 310 return cell_count; | |
| 311 } | |
| 312 | |
| 313 void MultiBranchData::post_initialize(BytecodeStream* stream, | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
314 MethodData* mdo) { |
| 0 | 315 assert(stream->bci() == bci(), "wrong pos"); |
| 316 int target; | |
| 317 int my_di; | |
| 318 int target_di; | |
| 319 int offset; | |
| 320 if (stream->code() == Bytecodes::_tableswitch) { | |
| 2142 | 321 Bytecode_tableswitch sw(stream->method()(), stream->bcp()); |
| 322 int len = sw.length(); | |
| 0 | 323 assert(array_len() == per_case_cell_count * (len + 1), "wrong len"); |
| 324 for (int count = 0; count < len; count++) { | |
| 2142 | 325 target = sw.dest_offset_at(count) + bci(); |
| 0 | 326 my_di = mdo->dp_to_di(dp()); |
| 327 target_di = mdo->bci_to_di(target); | |
| 328 offset = target_di - my_di; | |
| 329 set_displacement_at(count, offset); | |
| 330 } | |
| 2142 | 331 target = sw.default_offset() + bci(); |
| 0 | 332 my_di = mdo->dp_to_di(dp()); |
| 333 target_di = mdo->bci_to_di(target); | |
| 334 offset = target_di - my_di; | |
| 335 set_default_displacement(offset); | |
| 336 | |
| 337 } else { | |
| 2142 | 338 Bytecode_lookupswitch sw(stream->method()(), stream->bcp()); |
| 339 int npairs = sw.number_of_pairs(); | |
| 0 | 340 assert(array_len() == per_case_cell_count * (npairs + 1), "wrong len"); |
| 341 for (int count = 0; count < npairs; count++) { | |
| 2142 | 342 LookupswitchPair pair = sw.pair_at(count); |
| 343 target = pair.offset() + bci(); | |
| 0 | 344 my_di = mdo->dp_to_di(dp()); |
| 345 target_di = mdo->bci_to_di(target); | |
| 346 offset = target_di - my_di; | |
| 347 set_displacement_at(count, offset); | |
| 348 } | |
| 2142 | 349 target = sw.default_offset() + bci(); |
| 0 | 350 my_di = mdo->dp_to_di(dp()); |
| 351 target_di = mdo->bci_to_di(target); | |
| 352 offset = target_di - my_di; | |
| 353 set_default_displacement(offset); | |
| 354 } | |
| 355 } | |
| 356 | |
| 357 #ifndef PRODUCT | |
| 358 void MultiBranchData::print_data_on(outputStream* st) { | |
| 359 print_shared(st, "MultiBranchData"); | |
| 360 st->print_cr("default_count(%u) displacement(%d)", | |
| 361 default_count(), default_displacement()); | |
| 362 int cases = number_of_cases(); | |
| 363 for (int i = 0; i < cases; i++) { | |
| 364 tab(st); | |
| 365 st->print_cr("count(%u) displacement(%d)", | |
| 366 count_at(i), displacement_at(i)); | |
| 367 } | |
| 368 } | |
| 369 #endif | |
| 370 | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
371 #ifndef PRODUCT |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
372 void ArgInfoData::print_data_on(outputStream* st) { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
373 print_shared(st, "ArgInfoData"); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
374 int nargs = number_of_args(); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
375 for (int i = 0; i < nargs; i++) { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
376 st->print(" 0x%x", arg_modified(i)); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
377 } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
378 st->cr(); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
379 } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
380 |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
381 #endif |
| 0 | 382 // ================================================================== |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
383 // MethodData* |
| 0 | 384 // |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
385 // A MethodData* holds information which has been collected about |
| 0 | 386 // a method. |
| 387 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
388 MethodData* MethodData::allocate(ClassLoaderData* loader_data, methodHandle method, TRAPS) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
389 int size = MethodData::compute_allocation_size_in_words(method); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
390 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
391 return new (loader_data, size, false, THREAD) MethodData(method(), size, CHECK_NULL); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
392 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
393 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
394 int MethodData::bytecode_cell_count(Bytecodes::Code code) { |
| 8883 | 395 #if defined(COMPILER1) && !(defined(COMPILER2) || defined(GRAAL)) |
| 8860 | 396 return no_profile_data; |
| 397 #else | |
| 0 | 398 switch (code) { |
| 399 case Bytecodes::_checkcast: | |
| 400 case Bytecodes::_instanceof: | |
| 401 case Bytecodes::_aastore: | |
| 402 if (TypeProfileCasts) { | |
| 403 return ReceiverTypeData::static_cell_count(); | |
| 404 } else { | |
| 405 return BitData::static_cell_count(); | |
| 406 } | |
| 407 case Bytecodes::_invokespecial: | |
| 408 case Bytecodes::_invokestatic: | |
| 409 return CounterData::static_cell_count(); | |
| 410 case Bytecodes::_goto: | |
| 411 case Bytecodes::_goto_w: | |
| 412 case Bytecodes::_jsr: | |
| 413 case Bytecodes::_jsr_w: | |
| 414 return JumpData::static_cell_count(); | |
| 415 case Bytecodes::_invokevirtual: | |
| 416 case Bytecodes::_invokeinterface: | |
| 417 return VirtualCallData::static_cell_count(); | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
196
diff
changeset
|
418 case Bytecodes::_invokedynamic: |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
196
diff
changeset
|
419 return CounterData::static_cell_count(); |
| 0 | 420 case Bytecodes::_ret: |
| 421 return RetData::static_cell_count(); | |
| 422 case Bytecodes::_ifeq: | |
| 423 case Bytecodes::_ifne: | |
| 424 case Bytecodes::_iflt: | |
| 425 case Bytecodes::_ifge: | |
| 426 case Bytecodes::_ifgt: | |
| 427 case Bytecodes::_ifle: | |
| 428 case Bytecodes::_if_icmpeq: | |
| 429 case Bytecodes::_if_icmpne: | |
| 430 case Bytecodes::_if_icmplt: | |
| 431 case Bytecodes::_if_icmpge: | |
| 432 case Bytecodes::_if_icmpgt: | |
| 433 case Bytecodes::_if_icmple: | |
| 434 case Bytecodes::_if_acmpeq: | |
| 435 case Bytecodes::_if_acmpne: | |
| 436 case Bytecodes::_ifnull: | |
| 437 case Bytecodes::_ifnonnull: | |
| 438 return BranchData::static_cell_count(); | |
| 439 case Bytecodes::_lookupswitch: | |
| 440 case Bytecodes::_tableswitch: | |
| 441 return variable_cell_count; | |
| 442 } | |
| 443 return no_profile_data; | |
| 8860 | 444 #endif |
| 0 | 445 } |
| 446 | |
| 447 // Compute the size of the profiling information corresponding to | |
| 448 // the current bytecode. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
449 int MethodData::compute_data_size(BytecodeStream* stream) { |
| 0 | 450 int cell_count = bytecode_cell_count(stream->code()); |
| 451 if (cell_count == no_profile_data) { | |
| 452 return 0; | |
| 453 } | |
| 454 if (cell_count == variable_cell_count) { | |
| 455 cell_count = MultiBranchData::compute_cell_count(stream); | |
| 456 } | |
| 457 // Note: cell_count might be zero, meaning that there is just | |
| 458 // a DataLayout header, with no extra cells. | |
| 459 assert(cell_count >= 0, "sanity"); | |
| 460 return DataLayout::compute_size_in_bytes(cell_count); | |
| 461 } | |
| 462 | |
|
8616
d343737786fe
changed profiling of exceptions so that the ExceptionSeen flag also works without GRAALVM
Christian Haeubl <haeubl@ssw.jku.at>
parents:
8615
diff
changeset
|
463 #ifdef GRAAL |
|
6948
e522a00b91aa
Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works
Doug Simon <doug.simon@oracle.com>
diff
changeset
|
464 int MethodData::compute_extra_data_count(int data_size, int empty_bc_count) { |
|
4568
8e1d9c27989a
better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately
Christian Haeubl <christian.haeubl@oracle.com>
parents:
4439
diff
changeset
|
465 if (!ProfileTraps) return 0; |
|
8e1d9c27989a
better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately
Christian Haeubl <christian.haeubl@oracle.com>
parents:
4439
diff
changeset
|
466 |
|
8e1d9c27989a
better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately
Christian Haeubl <christian.haeubl@oracle.com>
parents:
4439
diff
changeset
|
467 // Assume that up to 30% of the possibly trapping BCIs with no MDP will need to allocate one. |
|
8e1d9c27989a
better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately
Christian Haeubl <christian.haeubl@oracle.com>
parents:
4439
diff
changeset
|
468 return MIN2(empty_bc_count, MAX2(4, (empty_bc_count * 30) / 100)); |
|
8e1d9c27989a
better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately
Christian Haeubl <christian.haeubl@oracle.com>
parents:
4439
diff
changeset
|
469 } |
|
8e1d9c27989a
better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately
Christian Haeubl <christian.haeubl@oracle.com>
parents:
4439
diff
changeset
|
470 #else |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
471 int MethodData::compute_extra_data_count(int data_size, int empty_bc_count) { |
| 0 | 472 if (ProfileTraps) { |
| 473 // Assume that up to 3% of BCIs with no MDP will need to allocate one. | |
| 474 int extra_data_count = (uint)(empty_bc_count * 3) / 128 + 1; | |
| 475 // If the method is large, let the extra BCIs grow numerous (to ~1%). | |
| 476 int one_percent_of_data | |
| 477 = (uint)data_size / (DataLayout::header_size_in_bytes()*128); | |
| 478 if (extra_data_count < one_percent_of_data) | |
| 479 extra_data_count = one_percent_of_data; | |
| 480 if (extra_data_count > empty_bc_count) | |
| 481 extra_data_count = empty_bc_count; // no need for more | |
| 482 return extra_data_count; | |
| 483 } else { | |
| 484 return 0; | |
| 485 } | |
| 486 } | |
|
4568
8e1d9c27989a
better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately
Christian Haeubl <christian.haeubl@oracle.com>
parents:
4439
diff
changeset
|
487 #endif |
| 0 | 488 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
489 // Compute the size of the MethodData* necessary to store |
| 0 | 490 // profiling information about a given method. Size is in bytes. |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
491 int MethodData::compute_allocation_size_in_bytes(methodHandle method) { |
| 0 | 492 int data_size = 0; |
| 493 BytecodeStream stream(method); | |
| 494 Bytecodes::Code c; | |
| 495 int empty_bc_count = 0; // number of bytecodes lacking data | |
| 496 while ((c = stream.next()) >= 0) { | |
| 497 int size_in_bytes = compute_data_size(&stream); | |
| 498 data_size += size_in_bytes; | |
|
4568
8e1d9c27989a
better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately
Christian Haeubl <christian.haeubl@oracle.com>
parents:
4439
diff
changeset
|
499 |
|
8e1d9c27989a
better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately
Christian Haeubl <christian.haeubl@oracle.com>
parents:
4439
diff
changeset
|
500 if (is_empty_data(size_in_bytes, c)) empty_bc_count++; |
| 0 | 501 } |
| 502 int object_size = in_bytes(data_offset()) + data_size; | |
| 503 | |
| 504 // Add some extra DataLayout cells (at least one) to track stray traps. | |
| 505 int extra_data_count = compute_extra_data_count(data_size, empty_bc_count); | |
| 506 object_size += extra_data_count * DataLayout::compute_size_in_bytes(0); | |
| 507 | |
|
7154
5d0bb7d52783
changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API
Doug Simon <doug.simon@oracle.com>
parents:
6948
diff
changeset
|
508 #ifndef GRAALVM |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
509 // Add a cell to record information about modified arguments. |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
510 int arg_size = method->size_of_parameters(); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
511 object_size += DataLayout::compute_size_in_bytes(arg_size+1); |
|
4568
8e1d9c27989a
better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately
Christian Haeubl <christian.haeubl@oracle.com>
parents:
4439
diff
changeset
|
512 #endif |
| 0 | 513 return object_size; |
| 514 } | |
| 515 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
516 // Compute the size of the MethodData* necessary to store |
| 0 | 517 // profiling information about a given method. Size is in words |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
518 int MethodData::compute_allocation_size_in_words(methodHandle method) { |
| 0 | 519 int byte_size = compute_allocation_size_in_bytes(method); |
| 520 int word_size = align_size_up(byte_size, BytesPerWord) / BytesPerWord; | |
| 521 return align_object_size(word_size); | |
| 522 } | |
| 523 | |
| 524 // Initialize an individual data segment. Returns the size of | |
| 525 // the segment in bytes. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
526 int MethodData::initialize_data(BytecodeStream* stream, |
| 0 | 527 int data_index) { |
| 8883 | 528 #if defined(COMPILER1) && !(defined(COMPILER2) || defined(GRAAL)) |
| 8860 | 529 return 0; |
| 530 #else | |
| 0 | 531 int cell_count = -1; |
| 532 int tag = DataLayout::no_tag; | |
| 533 DataLayout* data_layout = data_layout_at(data_index); | |
| 534 Bytecodes::Code c = stream->code(); | |
| 535 switch (c) { | |
| 536 case Bytecodes::_checkcast: | |
| 537 case Bytecodes::_instanceof: | |
| 538 case Bytecodes::_aastore: | |
| 539 if (TypeProfileCasts) { | |
| 540 cell_count = ReceiverTypeData::static_cell_count(); | |
| 541 tag = DataLayout::receiver_type_data_tag; | |
| 542 } else { | |
| 543 cell_count = BitData::static_cell_count(); | |
| 544 tag = DataLayout::bit_data_tag; | |
| 545 } | |
| 546 break; | |
| 547 case Bytecodes::_invokespecial: | |
| 548 case Bytecodes::_invokestatic: | |
| 549 cell_count = CounterData::static_cell_count(); | |
| 550 tag = DataLayout::counter_data_tag; | |
| 551 break; | |
| 552 case Bytecodes::_goto: | |
| 553 case Bytecodes::_goto_w: | |
| 554 case Bytecodes::_jsr: | |
| 555 case Bytecodes::_jsr_w: | |
| 556 cell_count = JumpData::static_cell_count(); | |
| 557 tag = DataLayout::jump_data_tag; | |
| 558 break; | |
| 559 case Bytecodes::_invokevirtual: | |
| 560 case Bytecodes::_invokeinterface: | |
| 561 cell_count = VirtualCallData::static_cell_count(); | |
| 562 tag = DataLayout::virtual_call_data_tag; | |
| 563 break; | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
196
diff
changeset
|
564 case Bytecodes::_invokedynamic: |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
196
diff
changeset
|
565 // %%% should make a type profile for any invokedynamic that takes a ref argument |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
196
diff
changeset
|
566 cell_count = CounterData::static_cell_count(); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
196
diff
changeset
|
567 tag = DataLayout::counter_data_tag; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
196
diff
changeset
|
568 break; |
| 0 | 569 case Bytecodes::_ret: |
| 570 cell_count = RetData::static_cell_count(); | |
| 571 tag = DataLayout::ret_data_tag; | |
| 572 break; | |
| 573 case Bytecodes::_ifeq: | |
| 574 case Bytecodes::_ifne: | |
| 575 case Bytecodes::_iflt: | |
| 576 case Bytecodes::_ifge: | |
| 577 case Bytecodes::_ifgt: | |
| 578 case Bytecodes::_ifle: | |
| 579 case Bytecodes::_if_icmpeq: | |
| 580 case Bytecodes::_if_icmpne: | |
| 581 case Bytecodes::_if_icmplt: | |
| 582 case Bytecodes::_if_icmpge: | |
| 583 case Bytecodes::_if_icmpgt: | |
| 584 case Bytecodes::_if_icmple: | |
| 585 case Bytecodes::_if_acmpeq: | |
| 586 case Bytecodes::_if_acmpne: | |
| 587 case Bytecodes::_ifnull: | |
| 588 case Bytecodes::_ifnonnull: | |
| 589 cell_count = BranchData::static_cell_count(); | |
| 590 tag = DataLayout::branch_data_tag; | |
| 591 break; | |
| 592 case Bytecodes::_lookupswitch: | |
| 593 case Bytecodes::_tableswitch: | |
| 594 cell_count = MultiBranchData::compute_cell_count(stream); | |
| 595 tag = DataLayout::multi_branch_data_tag; | |
| 596 break; | |
| 597 } | |
| 598 assert(tag == DataLayout::multi_branch_data_tag || | |
| 599 cell_count == bytecode_cell_count(c), "cell counts must agree"); | |
| 600 if (cell_count >= 0) { | |
| 601 assert(tag != DataLayout::no_tag, "bad tag"); | |
| 602 assert(bytecode_has_profile(c), "agree w/ BHP"); | |
| 603 data_layout->initialize(tag, stream->bci(), cell_count); | |
| 604 return DataLayout::compute_size_in_bytes(cell_count); | |
| 605 } else { | |
| 606 assert(!bytecode_has_profile(c), "agree w/ !BHP"); | |
| 607 return 0; | |
| 608 } | |
| 8860 | 609 #endif |
| 0 | 610 } |
| 611 | |
| 612 // Get the data at an arbitrary (sort of) data index. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
613 ProfileData* MethodData::data_at(int data_index) const { |
| 0 | 614 if (out_of_bounds(data_index)) { |
| 615 return NULL; | |
| 616 } | |
| 617 DataLayout* data_layout = data_layout_at(data_index); | |
| 941 | 618 return data_layout->data_in(); |
| 619 } | |
| 0 | 620 |
| 941 | 621 ProfileData* DataLayout::data_in() { |
| 622 switch (tag()) { | |
| 0 | 623 case DataLayout::no_tag: |
| 624 default: | |
| 625 ShouldNotReachHere(); | |
| 626 return NULL; | |
| 627 case DataLayout::bit_data_tag: | |
| 941 | 628 return new BitData(this); |
| 0 | 629 case DataLayout::counter_data_tag: |
| 941 | 630 return new CounterData(this); |
| 0 | 631 case DataLayout::jump_data_tag: |
| 941 | 632 return new JumpData(this); |
| 0 | 633 case DataLayout::receiver_type_data_tag: |
| 941 | 634 return new ReceiverTypeData(this); |
| 0 | 635 case DataLayout::virtual_call_data_tag: |
| 941 | 636 return new VirtualCallData(this); |
| 0 | 637 case DataLayout::ret_data_tag: |
| 941 | 638 return new RetData(this); |
| 0 | 639 case DataLayout::branch_data_tag: |
| 941 | 640 return new BranchData(this); |
| 0 | 641 case DataLayout::multi_branch_data_tag: |
| 941 | 642 return new MultiBranchData(this); |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
643 case DataLayout::arg_info_data_tag: |
| 941 | 644 return new ArgInfoData(this); |
| 0 | 645 }; |
| 646 } | |
| 647 | |
| 648 // Iteration over data. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
649 ProfileData* MethodData::next_data(ProfileData* current) const { |
| 0 | 650 int current_index = dp_to_di(current->dp()); |
| 651 int next_index = current_index + current->size_in_bytes(); | |
| 652 ProfileData* next = data_at(next_index); | |
| 653 return next; | |
| 654 } | |
| 655 | |
| 656 // Give each of the data entries a chance to perform specific | |
| 657 // data initialization. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
658 void MethodData::post_initialize(BytecodeStream* stream) { |
| 0 | 659 ResourceMark rm; |
| 660 ProfileData* data; | |
| 661 for (data = first_data(); is_valid(data); data = next_data(data)) { | |
| 662 stream->set_start(data->bci()); | |
| 663 stream->next(); | |
| 664 data->post_initialize(stream, this); | |
| 665 } | |
| 666 } | |
| 667 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
668 // Initialize the MethodData* corresponding to a given method. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
669 MethodData::MethodData(methodHandle method, int size, TRAPS) { |
|
8611
6c4db417385a
added API to reset the profiling information for a method
Christian Haeubl <haeubl@ssw.jku.at>
parents:
8125
diff
changeset
|
670 // Set the method back-pointer. |
|
6c4db417385a
added API to reset the profiling information for a method
Christian Haeubl <haeubl@ssw.jku.at>
parents:
8125
diff
changeset
|
671 _method = method(); |
|
6c4db417385a
added API to reset the profiling information for a method
Christian Haeubl <haeubl@ssw.jku.at>
parents:
8125
diff
changeset
|
672 initialize(); |
|
6c4db417385a
added API to reset the profiling information for a method
Christian Haeubl <haeubl@ssw.jku.at>
parents:
8125
diff
changeset
|
673 } |
|
6c4db417385a
added API to reset the profiling information for a method
Christian Haeubl <haeubl@ssw.jku.at>
parents:
8125
diff
changeset
|
674 |
|
6c4db417385a
added API to reset the profiling information for a method
Christian Haeubl <haeubl@ssw.jku.at>
parents:
8125
diff
changeset
|
675 void MethodData::initialize() { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
676 No_Safepoint_Verifier no_safepoint; // init function atomic wrt GC |
| 0 | 677 ResourceMark rm; |
| 1783 | 678 |
|
9080
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
8860
diff
changeset
|
679 init(); |
| 0 | 680 set_creation_mileage(mileage_of(method())); |
| 681 | |
| 682 // Go through the bytecodes and allocate and initialize the | |
| 683 // corresponding data cells. | |
| 684 int data_size = 0; | |
| 685 int empty_bc_count = 0; // number of bytecodes lacking data | |
|
8712
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
7956
diff
changeset
|
686 _data[0] = 0; // apparently not set below. |
|
8611
6c4db417385a
added API to reset the profiling information for a method
Christian Haeubl <haeubl@ssw.jku.at>
parents:
8125
diff
changeset
|
687 BytecodeStream stream(method()); |
| 0 | 688 Bytecodes::Code c; |
| 689 while ((c = stream.next()) >= 0) { | |
| 690 int size_in_bytes = initialize_data(&stream, data_size); | |
| 691 data_size += size_in_bytes; | |
|
4568
8e1d9c27989a
better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately
Christian Haeubl <christian.haeubl@oracle.com>
parents:
4439
diff
changeset
|
692 |
|
8e1d9c27989a
better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately
Christian Haeubl <christian.haeubl@oracle.com>
parents:
4439
diff
changeset
|
693 if (is_empty_data(size_in_bytes, c)) empty_bc_count++; |
| 0 | 694 } |
| 695 _data_size = data_size; | |
| 696 int object_size = in_bytes(data_offset()) + data_size; | |
| 697 | |
| 698 // Add some extra DataLayout cells (at least one) to track stray traps. | |
| 699 int extra_data_count = compute_extra_data_count(data_size, empty_bc_count); | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
700 int extra_size = extra_data_count * DataLayout::compute_size_in_bytes(0); |
|
4568
8e1d9c27989a
better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately
Christian Haeubl <christian.haeubl@oracle.com>
parents:
4439
diff
changeset
|
701 object_size += extra_size; |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
702 |
|
8611
6c4db417385a
added API to reset the profiling information for a method
Christian Haeubl <haeubl@ssw.jku.at>
parents:
8125
diff
changeset
|
703 Copy::zero_to_bytes((HeapWord*) extra_data_base(), extra_size); |
|
6c4db417385a
added API to reset the profiling information for a method
Christian Haeubl <haeubl@ssw.jku.at>
parents:
8125
diff
changeset
|
704 |
|
7154
5d0bb7d52783
changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API
Doug Simon <doug.simon@oracle.com>
parents:
6948
diff
changeset
|
705 #ifndef GRAALVM |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
706 // Add a cell to record information about modified arguments. |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
707 // Set up _args_modified array after traps cells so that |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
708 // the code for traps cells works. |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
709 DataLayout *dp = data_layout_at(data_size + extra_size); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
710 |
| 8615 | 711 int arg_size = method()->size_of_parameters(); |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
712 dp->initialize(DataLayout::arg_info_data_tag, 0, arg_size+1); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
713 |
|
4568
8e1d9c27989a
better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately
Christian Haeubl <christian.haeubl@oracle.com>
parents:
4439
diff
changeset
|
714 object_size += DataLayout::compute_size_in_bytes(arg_size+1); |
|
8e1d9c27989a
better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately
Christian Haeubl <christian.haeubl@oracle.com>
parents:
4439
diff
changeset
|
715 #endif |
| 0 | 716 |
| 717 // Set an initial hint. Don't use set_hint_di() because | |
| 718 // first_di() may be out of bounds if data_size is 0. | |
| 719 // In that situation, _hint_di is never used, but at | |
| 720 // least well-defined. | |
| 721 _hint_di = first_di(); | |
| 722 | |
| 723 post_initialize(&stream); | |
| 724 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
725 set_size(object_size); |
|
9080
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
8860
diff
changeset
|
726 } |
|
8712
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
7956
diff
changeset
|
727 |
|
9080
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
8860
diff
changeset
|
728 void MethodData::init() { |
|
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
8860
diff
changeset
|
729 _invocation_counter.init(); |
|
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
8860
diff
changeset
|
730 _backedge_counter.init(); |
|
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
8860
diff
changeset
|
731 _invocation_counter_start = 0; |
|
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
8860
diff
changeset
|
732 _backedge_counter_start = 0; |
|
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
8860
diff
changeset
|
733 _num_loops = 0; |
|
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
8860
diff
changeset
|
734 _num_blocks = 0; |
|
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
8860
diff
changeset
|
735 _highest_comp_level = 0; |
|
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
8860
diff
changeset
|
736 _highest_osr_comp_level = 0; |
|
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
8860
diff
changeset
|
737 _would_profile = true; |
|
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
8860
diff
changeset
|
738 |
|
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
8860
diff
changeset
|
739 // Initialize flags and trap history. |
|
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
8860
diff
changeset
|
740 _nof_decompiles = 0; |
|
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
8860
diff
changeset
|
741 _nof_overflow_recompiles = 0; |
|
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
8860
diff
changeset
|
742 _nof_overflow_traps = 0; |
|
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
8860
diff
changeset
|
743 clear_escape_info(); |
|
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
8860
diff
changeset
|
744 assert(sizeof(_trap_hist) % sizeof(HeapWord) == 0, "align"); |
|
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
8860
diff
changeset
|
745 Copy::zero_to_words((HeapWord*) &_trap_hist, |
|
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
8860
diff
changeset
|
746 sizeof(_trap_hist) / sizeof(HeapWord)); |
| 0 | 747 } |
| 748 | |
|
6948
e522a00b91aa
Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works
Doug Simon <doug.simon@oracle.com>
diff
changeset
|
749 bool MethodData::is_empty_data(int size_in_bytes, Bytecodes::Code code) { |
|
8616
d343737786fe
changed profiling of exceptions so that the ExceptionSeen flag also works without GRAALVM
Christian Haeubl <haeubl@ssw.jku.at>
parents:
8615
diff
changeset
|
750 #ifdef GRAAL |
|
4568
8e1d9c27989a
better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately
Christian Haeubl <christian.haeubl@oracle.com>
parents:
4439
diff
changeset
|
751 return size_in_bytes == 0 && Bytecodes::can_trap(code); |
|
8e1d9c27989a
better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately
Christian Haeubl <christian.haeubl@oracle.com>
parents:
4439
diff
changeset
|
752 #else |
|
8e1d9c27989a
better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately
Christian Haeubl <christian.haeubl@oracle.com>
parents:
4439
diff
changeset
|
753 return size_in_bytes == 0; |
|
8e1d9c27989a
better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately
Christian Haeubl <christian.haeubl@oracle.com>
parents:
4439
diff
changeset
|
754 #endif |
|
8e1d9c27989a
better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately
Christian Haeubl <christian.haeubl@oracle.com>
parents:
4439
diff
changeset
|
755 } |
|
8e1d9c27989a
better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately
Christian Haeubl <christian.haeubl@oracle.com>
parents:
4439
diff
changeset
|
756 |
| 0 | 757 // Get a measure of how much mileage the method has on it. |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
758 int MethodData::mileage_of(Method* method) { |
| 0 | 759 int mileage = 0; |
| 1783 | 760 if (TieredCompilation) { |
| 761 mileage = MAX2(method->invocation_count(), method->backedge_count()); | |
| 762 } else { | |
| 763 int iic = method->interpreter_invocation_count(); | |
| 764 if (mileage < iic) mileage = iic; | |
| 765 InvocationCounter* ic = method->invocation_counter(); | |
| 766 InvocationCounter* bc = method->backedge_counter(); | |
| 767 int icval = ic->count(); | |
| 768 if (ic->carry()) icval += CompileThreshold; | |
| 769 if (mileage < icval) mileage = icval; | |
| 770 int bcval = bc->count(); | |
| 771 if (bc->carry()) bcval += CompileThreshold; | |
| 772 if (mileage < bcval) mileage = bcval; | |
| 773 } | |
| 0 | 774 return mileage; |
| 775 } | |
| 776 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
777 bool MethodData::is_mature() const { |
| 1783 | 778 return CompilationPolicy::policy()->is_mature(_method); |
| 0 | 779 } |
| 780 | |
| 781 // Translate a bci to its corresponding data index (di). | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
782 address MethodData::bci_to_dp(int bci) { |
| 0 | 783 ResourceMark rm; |
| 784 ProfileData* data = data_before(bci); | |
| 785 ProfileData* prev = NULL; | |
| 786 for ( ; is_valid(data); data = next_data(data)) { | |
| 787 if (data->bci() >= bci) { | |
| 788 if (data->bci() == bci) set_hint_di(dp_to_di(data->dp())); | |
| 789 else if (prev != NULL) set_hint_di(dp_to_di(prev->dp())); | |
| 790 return data->dp(); | |
| 791 } | |
| 792 prev = data; | |
| 793 } | |
| 794 return (address)limit_data_position(); | |
| 795 } | |
| 796 | |
| 797 // Translate a bci to its corresponding data, or NULL. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
798 ProfileData* MethodData::bci_to_data(int bci) { |
| 0 | 799 ProfileData* data = data_before(bci); |
| 800 for ( ; is_valid(data); data = next_data(data)) { | |
| 801 if (data->bci() == bci) { | |
| 802 set_hint_di(dp_to_di(data->dp())); | |
| 803 return data; | |
| 804 } else if (data->bci() > bci) { | |
| 805 break; | |
| 806 } | |
| 807 } | |
| 808 return bci_to_extra_data(bci, false); | |
| 809 } | |
| 810 | |
| 811 // Translate a bci to its corresponding extra data, or NULL. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
812 ProfileData* MethodData::bci_to_extra_data(int bci, bool create_if_missing) { |
| 0 | 813 DataLayout* dp = extra_data_base(); |
| 814 DataLayout* end = extra_data_limit(); | |
| 815 DataLayout* avail = NULL; | |
| 816 for (; dp < end; dp = next_extra(dp)) { | |
| 817 // No need for "OrderAccess::load_acquire" ops, | |
| 818 // since the data structure is monotonic. | |
| 819 if (dp->tag() == DataLayout::no_tag) break; | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
820 if (dp->tag() == DataLayout::arg_info_data_tag) { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
821 dp = end; // ArgInfoData is at the end of extra data section. |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
822 break; |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
823 } |
| 0 | 824 if (dp->bci() == bci) { |
| 825 assert(dp->tag() == DataLayout::bit_data_tag, "sane"); | |
| 826 return new BitData(dp); | |
| 827 } | |
| 828 } | |
| 829 if (create_if_missing && dp < end) { | |
| 830 // Allocate this one. There is no mutual exclusion, | |
| 831 // so two threads could allocate different BCIs to the | |
| 832 // same data layout. This means these extra data | |
| 833 // records, like most other MDO contents, must not be | |
| 834 // trusted too much. | |
| 835 DataLayout temp; | |
| 836 temp.initialize(DataLayout::bit_data_tag, bci, 0); | |
| 837 dp->release_set_header(temp.header()); | |
| 838 assert(dp->tag() == DataLayout::bit_data_tag, "sane"); | |
| 839 //NO: assert(dp->bci() == bci, "no concurrent allocation"); | |
| 840 return new BitData(dp); | |
| 841 } | |
| 842 return NULL; | |
| 843 } | |
| 844 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
845 ArgInfoData *MethodData::arg_info() { |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
846 DataLayout* dp = extra_data_base(); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
847 DataLayout* end = extra_data_limit(); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
848 for (; dp < end; dp = next_extra(dp)) { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
849 if (dp->tag() == DataLayout::arg_info_data_tag) |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
850 return new ArgInfoData(dp); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
851 } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
852 return NULL; |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
853 } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
854 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
855 // Printing |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
856 |
| 0 | 857 #ifndef PRODUCT |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
858 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
859 void MethodData::print_on(outputStream* st) const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
860 assert(is_methodData(), "should be method data"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
861 st->print("method data for "); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
862 method()->print_value_on(st); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
863 st->cr(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
864 print_data_on(st); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
865 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
866 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
867 #endif //PRODUCT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
868 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
869 void MethodData::print_value_on(outputStream* st) const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
870 assert(is_methodData(), "should be method data"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
871 st->print("method data for "); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
872 method()->print_value_on(st); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
873 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
874 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
875 #ifndef PRODUCT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
876 void MethodData::print_data_on(outputStream* st) const { |
| 0 | 877 ResourceMark rm; |
| 878 ProfileData* data = first_data(); | |
| 879 for ( ; is_valid(data); data = next_data(data)) { | |
| 880 st->print("%d", dp_to_di(data->dp())); | |
| 881 st->fill_to(6); | |
| 882 data->print_data_on(st); | |
| 883 } | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
884 st->print_cr("--- Extra data:"); |
| 0 | 885 DataLayout* dp = extra_data_base(); |
| 886 DataLayout* end = extra_data_limit(); | |
| 887 for (; dp < end; dp = next_extra(dp)) { | |
| 888 // No need for "OrderAccess::load_acquire" ops, | |
| 889 // since the data structure is monotonic. | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
890 if (dp->tag() == DataLayout::no_tag) continue; |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
891 if (dp->tag() == DataLayout::bit_data_tag) { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
892 data = new BitData(dp); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
893 } else { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
894 assert(dp->tag() == DataLayout::arg_info_data_tag, "must be BitData or ArgInfo"); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
895 data = new ArgInfoData(dp); |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
896 dp = end; // ArgInfoData is at the end of extra data section. |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
897 } |
| 0 | 898 st->print("%d", dp_to_di(data->dp())); |
| 899 st->fill_to(6); | |
| 900 data->print_data_on(st); | |
| 901 } | |
| 902 } | |
| 903 #endif | |
| 904 | |
| 7956 | 905 #if INCLUDE_SERVICES |
| 906 // Size Statistics | |
| 907 void MethodData::collect_statistics(KlassSizeStats *sz) const { | |
| 908 int n = sz->count(this); | |
| 909 sz->_method_data_bytes += n; | |
| 910 sz->_method_all_bytes += n; | |
| 911 sz->_rw_bytes += n; | |
| 912 } | |
| 913 #endif // INCLUDE_SERVICES | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
914 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
915 // Verification |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
916 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
917 void MethodData::verify_on(outputStream* st) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
918 guarantee(is_methodData(), "object must be method data"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
919 // guarantee(m->is_perm(), "should be in permspace"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
920 this->verify_data_on(st); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
921 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
922 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2264
diff
changeset
|
923 void MethodData::verify_data_on(outputStream* st) { |
| 0 | 924 NEEDS_CLEANUP; |
| 925 // not yet implemented. | |
| 926 } |