hotspot Udiff src/share/vm/oops/objArrayKlass.inline.hpp (original) (raw)

< prev index next >

Print this page

@@ -1,7 +1,7 @@ /*

• • Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.

• • Copyright (c) 2010, 2015, 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.

@@ -23,80 +23,167 @@ / #ifndef SHARE_VM_OOPS_OBJARRAYKLASS_INLINE_HPP #define SHARE_VM_OOPS_OBJARRAYKLASS_INLINE_HPP -#include "gc_implementation/shared/markSweep.inline.hpp" +#include "memory/memRegion.hpp" +#include "memory/iterator.inline.hpp" #include "oops/objArrayKlass.hpp" +#include "oops/objArrayOop.inline.hpp" +#include "oops/oop.inline.hpp" #include "utilities/macros.hpp" -#if INCLUDE_ALL_GCS -#include "gc_implementation/parallelScavenge/psCompactionManager.inline.hpp" -#include "gc_implementation/parallelScavenge/psParallelCompact.hpp" -#endif // INCLUDE_ALL_GCS -void ObjArrayKlass::oop_follow_contents(oop obj, int index) { - if (UseCompressedOops) { - objarray_follow_contents(obj, index); - } else { - objarray_follow_contents(obj, index); +template <bool nv, typename T, class OopClosureType> +void ObjArrayKlass::oop_oop_iterate_elements_specialized(objArrayOop a, OopClosureType closure) { + T* p = (T*)a->base(); + T* const end = p + a->length(); + + for (;p < end; p++) { + Devirtualizer::do_oop(closure, p); } } -template -void ObjArrayKlass::objarray_follow_contents(oop obj, int index) { - objArrayOop a = objArrayOop(obj); - const size_t len = size_t(a->length()); - const size_t beg_index = size_t(index); - assert(beg_index < len || len == 0, "index too large");

• const size_t stride = MIN2(len - beg_index, ObjArrayMarkingStride);
• const size_t end_index = beg_index + stride;
• T* const base = (T*)a->base();
• T* const beg = base + beg_index;
• T* const end = base + end_index;
• // Push the non-NULL elements of the next stride on the marking stack.
• for (T* e = beg; e < end; e++) {
• MarkSweep::mark_and_push(e);

+template <bool nv, typename T, class OopClosureType> +void ObjArrayKlass::oop_oop_iterate_elements_specialized_bounded(

• objArrayOop a, OopClosureType* closure, void* low, void* high) {
• T* const l = (T*)low;
• T* const h = (T*)high;
• T* p = (T*)a->base();
• T* end = p + a->length();
• if (p < l) {
• p = l;
• }
• if (end > h) {
• end = h;

}

• if (end_index < len) {
• MarkSweep::push_objarray(a, end_index); // Push the continuation.

• for (;p < end; ++p) {
• Devirtualizer::do_oop(closure, p);

} }

-#if INCLUDE_ALL_GCS -void ObjArrayKlass::oop_follow_contents(ParCompactionManager* cm, oop obj,

•                                    int index) {

+template <bool nv, class OopClosureType> +void ObjArrayKlass::oop_oop_iterate_elements(objArrayOop a, OopClosureType* closure) {

• if (UseCompressedOops) {
• oop_oop_iterate_elements_specialized<nv, narrowOop>(a, closure);
• } else {
• oop_oop_iterate_elements_specialized<nv, oop>(a, closure);
• } +}
• +template <bool nv, class OopClosureType> +void ObjArrayKlass::oop_oop_iterate_elements_bounded(objArrayOop a, OopClosureType* closure, MemRegion mr) { if (UseCompressedOops) {

• objarray_follow_contents(cm, obj, index);

• oop_oop_iterate_elements_specialized_bounded<nv, narrowOop>(a, closure, mr.start(), mr.end());

} else {

• objarray_follow_contents(cm, obj, index);

• oop_oop_iterate_elements_specialized_bounded<nv, oop>(a, closure, mr.start(), mr.end());
• } +}
• +template <bool nv, typename OopClosureType> +int ObjArrayKlass::oop_oop_iterate(oop obj, OopClosureType* closure) {
• assert (obj->is_array(), "obj must be array");
• objArrayOop a = objArrayOop(obj);
• // Get size before changing pointers.
• // Don't call size() or oop_size() since that is a virtual call.
• int size = a->object_size();
• if (Devirtualizer::do_metadata(closure)) {
• Devirtualizer::do_klass(closure, obj->klass());

} +

• oop_oop_iterate_elements(a, closure);
• return size; }

-template -void ObjArrayKlass::objarray_follow_contents(ParCompactionManager* cm, oop obj,

•                                         int index) {

+template <bool nv, typename OopClosureType> +int ObjArrayKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) {

• assert(obj->is_array(), "obj must be array"); objArrayOop a = objArrayOop(obj);

• const size_t len = size_t(a->length());

• const size_t beg_index = size_t(index);

• assert(beg_index < len || len == 0, "index too large");

• const size_t stride = MIN2(len - beg_index, ObjArrayMarkingStride);

• const size_t end_index = beg_index + stride;

• T* const base = (T*)a->base();

• T* const beg = base + beg_index;

• T* const end = base + end_index;

• // Get size before changing pointers.
• // Don't call size() or oop_size() since that is a virtual call
• int size = a->object_size();
• if (Devirtualizer::do_metadata(closure)) {
• Devirtualizer::do_klass(closure, a->klass());
• }
• oop_oop_iterate_elements_bounded(a, closure, mr);
• return size; +}

• // Push the non-NULL elements of the next stride on the marking stack.
• for (T* e = beg; e < end; e++) {
• PSParallelCompact::mark_and_push(cm, e);

+template <bool nv, typename T, class OopClosureType> +void ObjArrayKlass::oop_oop_iterate_range_specialized(objArrayOop a, OopClosureType* closure, int start, int end) {

• if (Devirtualizer::do_metadata(closure)) {
• Devirtualizer::do_klass(closure, a->klass());

}

• if (end_index < len) {
• cm->push_objarray(a, end_index); // Push the continuation.

• T* low = start == 0 ? cast_from_oop<T*>(a) : a->obj_at_addr(start);
• T* high = (T*)a->base() + end;
• oop_oop_iterate_elements_specialized_bounded<nv, T>(a, closure, low, high); +}
• +// Like oop_oop_iterate but only iterates over a specified range and only used +// for objArrayOops. +template <bool nv, class OopClosureType> +int ObjArrayKlass::oop_oop_iterate_range(oop obj, OopClosureType* closure, int start, int end) {
• assert(obj->is_array(), "obj must be array");
• objArrayOop a = objArrayOop(obj);
• // Get size before changing pointers.
• // Don't call size() or oop_size() since that is a virtual call
• int size = a->object_size();
• if (UseCompressedOops) {
• oop_oop_iterate_range_specialized<nv, narrowOop>(a, closure, start, end);
• } else {
• oop_oop_iterate_range_specialized<nv, oop>(a, closure, start, end);

} +

• return size; } -#endif // INCLUDE_ALL_GCS
• +#define ObjArrayKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \

•                                                                               \

+int ObjArrayKlass::oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure) { \

• return oop_oop_iterate<nvs_to_bool(nv_suffix)>(obj, closure);
  +}
• +#if INCLUDE_ALL_GCS

+#define ObjArrayKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix)
+int ObjArrayKlass::oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* closure) { \

• /* No reverse implementation ATM. */ \
• return oop_oop_iterate<nvs_to_bool(nv_suffix)>(obj, closure);
  +} +#else +#define ObjArrayKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) +#endif
• +#define ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix) \

•                                                                                                 \

+int ObjArrayKlass::oop_oop_iterate##nv_suffix##_m(oop obj, OopClosureType* closure, MemRegion mr) { \

• return oop_oop_iterate_bounded<nvs_to_bool(nv_suffix)>(obj, closure, mr);
  +}
• +#define ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r(OopClosureType, nv_suffix) \

•                                                                                                         \

+int ObjArrayKlass::oop_oop_iterate_range##nv_suffix(oop obj, OopClosureType* closure, int start, int end) { \

• return oop_oop_iterate_range<nvs_to_bool(nv_suffix)>(obj, closure, start, end);
  +}
• +#define ALL_OBJ_ARRAY_KLASS_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \
• ObjArrayKlass_OOP_OOP_ITERATE_DEFN( OopClosureType, nv_suffix) \
• ObjArrayKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \
• ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m( OopClosureType, nv_suffix) \
• ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r( OopClosureType, nv_suffix)

#endif // SHARE_VM_OOPS_OBJARRAYKLASS_INLINE_HPP

< prev index next >