/* * Copyright (c) 1997, 2022, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. *
*/
size_t oopDesc::size_given_klass(Klass* klass) { int lh = klass->layout_helper();
size_t s;
// lh is now a value computed at class initialization that may hint // at the size. For instances, this is positive and equal to the // size. For arrays, this is negative and provides log2 of the // array element size. For other oops, it is zero and thus requires // a virtual call. // // We go to all this trouble because the size computation is at the // heart of phase 2 of mark-compaction, and called for every object, // alive or dead. So the speed here is equal in importance to the // speed of allocation.
if (lh > Klass::_lh_neutral_value) { if (!Klass::layout_helper_needs_slow_path(lh)) {
s = lh >> LogHeapWordSize; // deliver size scaled by wordSize
} else {
s = klass->oop_size(this);
}
} elseif (lh <= Klass::_lh_neutral_value) { // The most common case is instances; fall through if so. if (lh < Klass::_lh_neutral_value) { // Second most common case is arrays. We have to fetch the // length of the array, shift (multiply) it appropriately, // up to wordSize, add the header, and align to object size.
size_t size_in_bytes;
size_t array_length = (size_t) ((arrayOop)this)->length();
size_in_bytes = array_length << Klass::layout_helper_log2_element_size(lh);
size_in_bytes += Klass::layout_helper_header_size(lh);
// This code could be simplified, but by keeping array_header_in_bytes // in units of bytes and doing it this way we can round up just once, // skipping the intermediate round to HeapWordSize.
s = align_up(size_in_bytes, MinObjAlignmentInBytes) / HeapWordSize;
assert(s == klass->oop_size(this) || size_might_change(), "wrong array object size");
} else { // Must be zero, so bite the bullet and take the virtual call.
s = klass->oop_size(this);
}
}
assert(s > 0, "Oop size must be greater than zero, not " SIZE_FORMAT, s);
assert(is_object_aligned(s), "Oop size is not properly aligned: " SIZE_FORMAT, s); return s;
}
// Used only for markSweep, scavenging bool oopDesc::is_gc_marked() const { return mark().is_marked();
}
// Used by scavengers bool oopDesc::is_forwarded() const { // The extra heap check is needed since the obj might be locked, in which case the // mark would point to a stack location and have the sentinel bit cleared return mark().is_marked();
}
// Used by scavengers void oopDesc::forward_to(oop p) {
verify_forwardee(p);
markWord m = markWord::encode_pointer_as_mark(p);
assert(m.decode_pointer() == p, "encoding must be reversible");
set_mark(m);
}
oop oopDesc::forward_to_atomic(oop p, markWord compare, atomic_memory_order order) {
verify_forwardee(p);
markWord m = markWord::encode_pointer_as_mark(p);
assert(m.decode_pointer() == p, "encoding must be reversible");
markWord old_mark = cas_set_mark(m, compare, order); if (old_mark == compare) { return NULL;
} else { return cast_to_oop(old_mark.decode_pointer());
}
}
// Note that the forwardee is not the same thing as the displaced_mark. // The forwardee is used when copying during scavenge and mark-sweep. // It does need to clear the low two locking- and GC-related bits.
oop oopDesc::forwardee() const {
assert(is_forwarded(), "only decode when actually forwarded"); return cast_to_oop(mark().decode_pointer());
}
// The following method needs to be MT safe.
uint oopDesc::age() const {
assert(!mark().is_marked(), "Attempt to read age from forwarded mark"); if (has_displaced_mark()) { return displaced_mark().age();
} else { return mark().age();
}
}
void oopDesc::incr_age() {
assert(!mark().is_marked(), "Attempt to increment age of forwarded mark"); if (has_displaced_mark()) {
set_displaced_mark(displaced_mark().incr_age());
} else {
set_mark(mark().incr_age());
}
}
intptr_t oopDesc::identity_hash() { // Fast case; if the object is unlocked and the hash value is set, no locking is needed // Note: The mark must be read into local variable to avoid concurrent updates.
markWord mrk = mark(); if (mrk.is_unlocked() && !mrk.has_no_hash()) { return mrk.hash();
} elseif (mrk.is_marked()) { return mrk.hash();
} else { return slow_identity_hash();
}
}
// This checks fast simple case of whether the oop has_no_hash, // to optimize JVMTI table lookup. bool oopDesc::fast_no_hash_check() {
markWord mrk = mark_acquire();
assert(!mrk.is_marked(), "should never be marked"); return mrk.is_unlocked() && mrk.has_no_hash();
}
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
