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 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "aot/aotLoader.hpp"
27 #include "classfile/stringTable.hpp"
28 #include "classfile/symbolTable.hpp"
29 #include "classfile/systemDictionary.hpp"
30 #include "code/codeCache.hpp"
31 #include "gc/parallel/gcTaskManager.hpp"
32 #include "gc/parallel/parallelScavengeHeap.inline.hpp"
33 #include "gc/parallel/parMarkBitMap.inline.hpp"
34 #include "gc/parallel/pcTasks.hpp"
35 #include "gc/parallel/psAdaptiveSizePolicy.hpp"
36 #include "gc/parallel/psCompactionManager.inline.hpp"
37 #include "gc/parallel/psOldGen.hpp"
38 #include "gc/parallel/psParallelCompact.inline.hpp"
39 #include "gc/parallel/psPromotionManager.inline.hpp"
40 #include "gc/parallel/psScavenge.hpp"
41 #include "gc/parallel/psYoungGen.hpp"
42 #include "gc/shared/gcCause.hpp"
43 #include "gc/shared/gcHeapSummary.hpp"
44 #include "gc/shared/gcId.hpp"
45 #include "gc/shared/gcLocker.hpp"
46 #include "gc/shared/gcTimer.hpp"
47 #include "gc/shared/gcTrace.hpp"
48 #include "gc/shared/gcTraceTime.inline.hpp"
49 #include "gc/shared/isGCActiveMark.hpp"
50 #include "gc/shared/referencePolicy.hpp"
51 #include "gc/shared/referenceProcessor.hpp"
52 #include "gc/shared/referenceProcessorPhaseTimes.hpp"
53 #include "gc/shared/spaceDecorator.hpp"
54 #include "gc/shared/weakProcessor.hpp"
55 #include "logging/log.hpp"
56 #include "memory/resourceArea.hpp"
57 #include "oops/access.inline.hpp"
58 #include "oops/instanceKlass.inline.hpp"
59 #include "oops/instanceMirrorKlass.inline.hpp"
60 #include "oops/methodData.hpp"
61 #include "oops/objArrayKlass.inline.hpp"
62 #include "oops/oop.inline.hpp"
63 #include "runtime/atomic.hpp"
64 #include "runtime/handles.inline.hpp"
65 #include "runtime/safepoint.hpp"
66 #include "runtime/vmThread.hpp"
67 #include "services/management.hpp"
68 #include "services/memTracker.hpp"
69 #include "services/memoryService.hpp"
70 #include "utilities/align.hpp"
71 #include "utilities/debug.hpp"
72 #include "utilities/events.hpp"
73 #include "utilities/formatBuffer.hpp"
74 #include "utilities/macros.hpp"
75 #include "utilities/stack.inline.hpp"
76
77 #include <math.h>
3052 {
3053 size_t words = words_remaining();
3054
3055 HeapWord* const range_end = MIN2(source() + words, bitmap()->region_end());
3056 HeapWord* const end_addr = bitmap()->find_obj_end(source(), range_end);
3057 if (end_addr < range_end) {
3058 words = bitmap()->obj_size(source(), end_addr);
3059 }
3060
3061 // This test is necessary; if omitted, the pointer updates to a partial object
3062 // that crosses the dense prefix boundary could be overwritten.
3063 if (source() != destination()) {
3064 DEBUG_ONLY(PSParallelCompact::check_new_location(source(), destination());)
3065 Copy::aligned_conjoint_words(source(), destination(), words);
3066 }
3067 update_state(words);
3068 }
3069
3070 void InstanceKlass::oop_pc_update_pointers(oop obj, ParCompactionManager* cm) {
3071 PSParallelCompact::AdjustPointerClosure closure(cm);
3072 oop_oop_iterate_oop_maps<true>(obj, &closure);
3073 }
3074
3075 void InstanceMirrorKlass::oop_pc_update_pointers(oop obj, ParCompactionManager* cm) {
3076 InstanceKlass::oop_pc_update_pointers(obj, cm);
3077
3078 PSParallelCompact::AdjustPointerClosure closure(cm);
3079 oop_oop_iterate_statics<true>(obj, &closure);
3080 }
3081
3082 void InstanceClassLoaderKlass::oop_pc_update_pointers(oop obj, ParCompactionManager* cm) {
3083 InstanceKlass::oop_pc_update_pointers(obj, cm);
3084 }
3085
3086 #ifdef ASSERT
3087 template <class T> static void trace_reference_gc(const char *s, oop obj,
3088 T* referent_addr,
3089 T* discovered_addr) {
3090 log_develop_trace(gc, ref)("%s obj " PTR_FORMAT, s, p2i(obj));
3091 log_develop_trace(gc, ref)(" referent_addr/* " PTR_FORMAT " / " PTR_FORMAT,
3092 p2i(referent_addr), referent_addr ? p2i((oop)RawAccess<>::oop_load(referent_addr)) : NULL);
3093 log_develop_trace(gc, ref)(" discovered_addr/* " PTR_FORMAT " / " PTR_FORMAT,
3094 p2i(discovered_addr), discovered_addr ? p2i((oop)RawAccess<>::oop_load(discovered_addr)) : NULL);
3095 }
3096 #endif
3097
3098 template <class T>
3099 static void oop_pc_update_pointers_specialized(oop obj, ParCompactionManager* cm) {
3101 PSParallelCompact::adjust_pointer(referent_addr, cm);
3102 T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr_raw(obj);
3103 PSParallelCompact::adjust_pointer(discovered_addr, cm);
3104 debug_only(trace_reference_gc("InstanceRefKlass::oop_update_ptrs", obj,
3105 referent_addr, discovered_addr);)
3106 }
3107
3108 void InstanceRefKlass::oop_pc_update_pointers(oop obj, ParCompactionManager* cm) {
3109 InstanceKlass::oop_pc_update_pointers(obj, cm);
3110
3111 if (UseCompressedOops) {
3112 oop_pc_update_pointers_specialized<narrowOop>(obj, cm);
3113 } else {
3114 oop_pc_update_pointers_specialized<oop>(obj, cm);
3115 }
3116 }
3117
3118 void ObjArrayKlass::oop_pc_update_pointers(oop obj, ParCompactionManager* cm) {
3119 assert(obj->is_objArray(), "obj must be obj array");
3120 PSParallelCompact::AdjustPointerClosure closure(cm);
3121 oop_oop_iterate_elements<true>(objArrayOop(obj), &closure);
3122 }
3123
3124 void TypeArrayKlass::oop_pc_update_pointers(oop obj, ParCompactionManager* cm) {
3125 assert(obj->is_typeArray(),"must be a type array");
3126 }
3127
3128 ParMarkBitMapClosure::IterationStatus
3129 MoveAndUpdateClosure::do_addr(HeapWord* addr, size_t words) {
3130 assert(destination() != NULL, "sanity");
3131 assert(bitmap()->obj_size(addr) == words, "bad size");
3132
3133 _source = addr;
3134 assert(PSParallelCompact::summary_data().calc_new_pointer(source(), compaction_manager()) ==
3135 destination(), "wrong destination");
3136
3137 if (words > words_remaining()) {
3138 return ParMarkBitMap::would_overflow;
3139 }
3140
3141 // The start_array must be updated even if the object is not moving.
|
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 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "aot/aotLoader.hpp"
27 #include "classfile/javaClasses.inline.hpp"
28 #include "classfile/stringTable.hpp"
29 #include "classfile/symbolTable.hpp"
30 #include "classfile/systemDictionary.hpp"
31 #include "code/codeCache.hpp"
32 #include "gc/parallel/gcTaskManager.hpp"
33 #include "gc/parallel/parallelScavengeHeap.inline.hpp"
34 #include "gc/parallel/parMarkBitMap.inline.hpp"
35 #include "gc/parallel/pcTasks.hpp"
36 #include "gc/parallel/psAdaptiveSizePolicy.hpp"
37 #include "gc/parallel/psCompactionManager.inline.hpp"
38 #include "gc/parallel/psOldGen.hpp"
39 #include "gc/parallel/psParallelCompact.inline.hpp"
40 #include "gc/parallel/psPromotionManager.inline.hpp"
41 #include "gc/parallel/psScavenge.hpp"
42 #include "gc/parallel/psYoungGen.hpp"
43 #include "gc/shared/gcCause.hpp"
44 #include "gc/shared/gcHeapSummary.hpp"
45 #include "gc/shared/gcId.hpp"
46 #include "gc/shared/gcLocker.hpp"
47 #include "gc/shared/gcTimer.hpp"
48 #include "gc/shared/gcTrace.hpp"
49 #include "gc/shared/gcTraceTime.inline.hpp"
50 #include "gc/shared/isGCActiveMark.hpp"
51 #include "gc/shared/referencePolicy.hpp"
52 #include "gc/shared/referenceProcessor.hpp"
53 #include "gc/shared/referenceProcessorPhaseTimes.hpp"
54 #include "gc/shared/spaceDecorator.hpp"
55 #include "gc/shared/weakProcessor.hpp"
56 #include "logging/log.hpp"
57 #include "memory/iterator.inline.hpp"
58 #include "memory/resourceArea.hpp"
59 #include "oops/access.inline.hpp"
60 #include "oops/instanceClassLoaderKlass.inline.hpp"
61 #include "oops/instanceKlass.inline.hpp"
62 #include "oops/instanceMirrorKlass.inline.hpp"
63 #include "oops/methodData.hpp"
64 #include "oops/objArrayKlass.inline.hpp"
65 #include "oops/oop.inline.hpp"
66 #include "runtime/atomic.hpp"
67 #include "runtime/handles.inline.hpp"
68 #include "runtime/safepoint.hpp"
69 #include "runtime/vmThread.hpp"
70 #include "services/management.hpp"
71 #include "services/memTracker.hpp"
72 #include "services/memoryService.hpp"
73 #include "utilities/align.hpp"
74 #include "utilities/debug.hpp"
75 #include "utilities/events.hpp"
76 #include "utilities/formatBuffer.hpp"
77 #include "utilities/macros.hpp"
78 #include "utilities/stack.inline.hpp"
79
80 #include <math.h>
3055 {
3056 size_t words = words_remaining();
3057
3058 HeapWord* const range_end = MIN2(source() + words, bitmap()->region_end());
3059 HeapWord* const end_addr = bitmap()->find_obj_end(source(), range_end);
3060 if (end_addr < range_end) {
3061 words = bitmap()->obj_size(source(), end_addr);
3062 }
3063
3064 // This test is necessary; if omitted, the pointer updates to a partial object
3065 // that crosses the dense prefix boundary could be overwritten.
3066 if (source() != destination()) {
3067 DEBUG_ONLY(PSParallelCompact::check_new_location(source(), destination());)
3068 Copy::aligned_conjoint_words(source(), destination(), words);
3069 }
3070 update_state(words);
3071 }
3072
3073 void InstanceKlass::oop_pc_update_pointers(oop obj, ParCompactionManager* cm) {
3074 PSParallelCompact::AdjustPointerClosure closure(cm);
3075 if (UseCompressedOops) {
3076 oop_oop_iterate_oop_maps<narrowOop>(obj, &closure);
3077 } else {
3078 oop_oop_iterate_oop_maps<oop>(obj, &closure);
3079 }
3080 }
3081
3082 void InstanceMirrorKlass::oop_pc_update_pointers(oop obj, ParCompactionManager* cm) {
3083 InstanceKlass::oop_pc_update_pointers(obj, cm);
3084
3085 PSParallelCompact::AdjustPointerClosure closure(cm);
3086 if (UseCompressedOops) {
3087 oop_oop_iterate_statics<narrowOop>(obj, &closure);
3088 } else {
3089 oop_oop_iterate_statics<oop>(obj, &closure);
3090 }
3091 }
3092
3093 void InstanceClassLoaderKlass::oop_pc_update_pointers(oop obj, ParCompactionManager* cm) {
3094 InstanceKlass::oop_pc_update_pointers(obj, cm);
3095 }
3096
3097 #ifdef ASSERT
3098 template <class T> static void trace_reference_gc(const char *s, oop obj,
3099 T* referent_addr,
3100 T* discovered_addr) {
3101 log_develop_trace(gc, ref)("%s obj " PTR_FORMAT, s, p2i(obj));
3102 log_develop_trace(gc, ref)(" referent_addr/* " PTR_FORMAT " / " PTR_FORMAT,
3103 p2i(referent_addr), referent_addr ? p2i((oop)RawAccess<>::oop_load(referent_addr)) : NULL);
3104 log_develop_trace(gc, ref)(" discovered_addr/* " PTR_FORMAT " / " PTR_FORMAT,
3105 p2i(discovered_addr), discovered_addr ? p2i((oop)RawAccess<>::oop_load(discovered_addr)) : NULL);
3106 }
3107 #endif
3108
3109 template <class T>
3110 static void oop_pc_update_pointers_specialized(oop obj, ParCompactionManager* cm) {
3112 PSParallelCompact::adjust_pointer(referent_addr, cm);
3113 T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr_raw(obj);
3114 PSParallelCompact::adjust_pointer(discovered_addr, cm);
3115 debug_only(trace_reference_gc("InstanceRefKlass::oop_update_ptrs", obj,
3116 referent_addr, discovered_addr);)
3117 }
3118
3119 void InstanceRefKlass::oop_pc_update_pointers(oop obj, ParCompactionManager* cm) {
3120 InstanceKlass::oop_pc_update_pointers(obj, cm);
3121
3122 if (UseCompressedOops) {
3123 oop_pc_update_pointers_specialized<narrowOop>(obj, cm);
3124 } else {
3125 oop_pc_update_pointers_specialized<oop>(obj, cm);
3126 }
3127 }
3128
3129 void ObjArrayKlass::oop_pc_update_pointers(oop obj, ParCompactionManager* cm) {
3130 assert(obj->is_objArray(), "obj must be obj array");
3131 PSParallelCompact::AdjustPointerClosure closure(cm);
3132 if (UseCompressedOops) {
3133 oop_oop_iterate_elements<narrowOop>(objArrayOop(obj), &closure);
3134 } else {
3135 oop_oop_iterate_elements<oop>(objArrayOop(obj), &closure);
3136 }
3137 }
3138
3139 void TypeArrayKlass::oop_pc_update_pointers(oop obj, ParCompactionManager* cm) {
3140 assert(obj->is_typeArray(),"must be a type array");
3141 }
3142
3143 ParMarkBitMapClosure::IterationStatus
3144 MoveAndUpdateClosure::do_addr(HeapWord* addr, size_t words) {
3145 assert(destination() != NULL, "sanity");
3146 assert(bitmap()->obj_size(addr) == words, "bad size");
3147
3148 _source = addr;
3149 assert(PSParallelCompact::summary_data().calc_new_pointer(source(), compaction_manager()) ==
3150 destination(), "wrong destination");
3151
3152 if (words > words_remaining()) {
3153 return ParMarkBitMap::would_overflow;
3154 }
3155
3156 // The start_array must be updated even if the object is not moving.
|