packages/openjdk-1.8.0
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

I7VHXC: revert 8146987 Improve Parallel GC Full GC by caching results of live_words_in_range()

Browse Source
This commit is contained in:
DXwangg 2023-08-24 09:11:36 +08:00
parent 0c762d22d5
commit 9d66eff506
2 changed files with 4 additions and 493 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

490
0053-8146987-Improve-Parallel-GC-Full-GC-by-caching-resul.patch
View File

@ -1,490 +0,0 @@
Date: Mon, 5 Jun 2023 20:28:58 +0800
Subject: [PATCH 53/59] 8146987: Improve Parallel GC Full GC by caching results of live_words_in_range()
Bug url: https://bugs.openjdk.org/browse/JDK-8146987
---
.../parallelScavenge/parMarkBitMap.cpp | 48 ++++++++++++++-
.../parallelScavenge/parMarkBitMap.hpp | 10 +++-
.../parallelScavenge/psCompactionManager.cpp | 10 ++++
.../parallelScavenge/psCompactionManager.hpp | 21 +++++++
.../parallelScavenge/psParallelCompact.cpp | 60 ++++++++++---------
.../parallelScavenge/psParallelCompact.hpp | 31 ++++++----
hotspot/src/share/vm/oops/instanceKlass.cpp | 2 +-
.../src/share/vm/oops/instanceMirrorKlass.cpp | 2 +-
.../src/share/vm/oops/instanceRefKlass.cpp | 6 +-
hotspot/src/share/vm/oops/objArrayKlass.cpp | 2 +-
10 files changed, 146 insertions(+), 46 deletions(-)
diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/parMarkBitMap.cpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/parMarkBitMap.cpp
index 1dde10746..06e930ca7 100644
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/parMarkBitMap.cpp
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/parMarkBitMap.cpp
@@ -24,6 +24,7 @@
#include "precompiled.hpp"
#include "gc_implementation/parallelScavenge/parMarkBitMap.hpp"
+#include "gc_implementation/parallelScavenge/psCompactionManager.hpp"
#include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
#include "oops/oop.inline.hpp"
#include "runtime/os.hpp"
@@ -110,7 +111,18 @@ ParMarkBitMap::mark_obj(HeapWord* addr, size_t size)
return false;
}
-size_t ParMarkBitMap::live_words_in_range(HeapWord* beg_addr, oop end_obj) const
+inline bool ParMarkBitMap::is_live_words_in_range_in_cache(ParCompactionManager* cm, HeapWord* beg_addr) const {
+ return cm->last_query_begin() == beg_addr;
+}
+
+inline void ParMarkBitMap::update_live_words_in_range_cache(ParCompactionManager* cm, HeapWord* beg_addr, oop end_obj,
+ size_t result) const {
+ cm->set_last_query_begin(beg_addr);
+ cm->set_last_query_object(end_obj);
+ cm->set_last_query_return(result);
+}
+
+size_t ParMarkBitMap::live_words_in_range_helper(HeapWord* beg_addr, oop end_obj) const
{
assert(beg_addr <= (HeapWord*)end_obj, "bad range");
assert(is_marked(end_obj), "end_obj must be live");
@@ -131,6 +143,40 @@ size_t ParMarkBitMap::live_words_in_range(HeapWord* beg_addr, oop end_obj) const
return bits_to_words(live_bits);
}
+size_t ParMarkBitMap::live_words_in_range_use_cache(ParCompactionManager* cm, HeapWord* beg_addr, oop end_obj) const
+{
+ HeapWord* last_beg = cm->last_query_begin();
+ oop last_obj = cm->last_query_object();
+ size_t last_ret = cm->last_query_return();
+ if (end_obj > last_obj) {
+ last_ret = last_ret + live_words_in_range_helper((HeapWord*)last_obj, end_obj);
+ last_obj = end_obj;
+ } else if (end_obj < last_obj) {
+ // The cached value is for an object that is to the left (lower address) of the current
+ // end_obj. Calculate back from that cached value.
+ if (pointer_delta((HeapWord*)end_obj, (HeapWord*)beg_addr) > pointer_delta((HeapWord*)last_obj, (HeapWord*)end_obj)) {
+ last_ret = last_ret - live_words_in_range_helper((HeapWord*)end_obj, last_obj);
+ } else {
+ last_ret = live_words_in_range_helper(beg_addr, end_obj);
+ }
+ last_obj = end_obj;
+ }
+
+ update_live_words_in_range_cache(cm, last_beg, last_obj, last_ret);
+ return last_ret;
+}
+
+size_t ParMarkBitMap::live_words_in_range(ParCompactionManager* cm, HeapWord* beg_addr, oop end_obj) const
+{
+ // Try to reuse result from ParCompactionManager cache first.
+ if (is_live_words_in_range_in_cache(cm, beg_addr)) {
+ return live_words_in_range_use_cache(cm, beg_addr, end_obj);
+ }
+ size_t ret = live_words_in_range_helper(beg_addr, end_obj);
+ update_live_words_in_range_cache(cm, beg_addr, end_obj, ret);
+ return ret;
+}
+
ParMarkBitMap::IterationStatus
ParMarkBitMap::iterate(ParMarkBitMapClosure* live_closure,
idx_t range_beg, idx_t range_end) const
diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/parMarkBitMap.hpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/parMarkBitMap.hpp
index 8d0153d48..2d8ad9dd7 100644
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/parMarkBitMap.hpp
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/parMarkBitMap.hpp
@@ -31,6 +31,7 @@
class ParMarkBitMapClosure;
class PSVirtualSpace;
+class ParCompactionManager;
class ParMarkBitMap: public CHeapObj<mtGC>
{
@@ -124,7 +125,7 @@ public:
// the range are included in the result. The end of the range must be a live object,
// which is the case when updating pointers. This allows a branch to be removed
// from inside the loop.
- size_t live_words_in_range(HeapWord* beg_addr, oop end_obj) const;
+ size_t live_words_in_range(ParCompactionManager* cm, HeapWord* beg_addr, oop end_obj) const;
inline HeapWord* region_start() const;
inline HeapWord* region_end() const;
@@ -167,6 +168,13 @@ public:
#endif // #ifdef ASSERT
private:
+
+ size_t live_words_in_range_helper(HeapWord* beg_addr, oop end_obj) const;
+
+ inline bool is_live_words_in_range_in_cache(ParCompactionManager* cm, HeapWord* beg_addr) const;
+ size_t live_words_in_range_use_cache(ParCompactionManager* cm, HeapWord* beg_addr, oop end_obj) const;
+ inline void update_live_words_in_range_cache(ParCompactionManager* cm, HeapWord* beg_addr, oop end_obj, size_t result) const;
+
// Each bit in the bitmap represents one unit of 'object granularity.' Objects
// are double-word aligned in 32-bit VMs, but not in 64-bit VMs, so the 32-bit
// granularity is 2, 64-bit is 1.
diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp
index 415d62947..e38997bc6 100644
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp
@@ -65,6 +65,8 @@ ParCompactionManager::ParCompactionManager() :
marking_stack()->initialize();
_objarray_stack.initialize();
+
+ reset_bitmap_query_cache();
}
ParCompactionManager::~ParCompactionManager() {
@@ -121,6 +123,14 @@ void ParCompactionManager::initialize(ParMarkBitMap* mbm) {
"Not initialized?");
}
+void ParCompactionManager::reset_all_bitmap_query_caches() {
+ uint parallel_gc_threads = PSParallelCompact::gc_task_manager()->workers();
+ for (uint i=0; i<=parallel_gc_threads; i++) {
+ _manager_array[i]->reset_bitmap_query_cache();
+ }
+}
+
+
int ParCompactionManager::pop_recycled_stack_index() {
assert(_recycled_bottom <= _recycled_top, "list is empty");
// Get the next available index
diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp
index a16a16762..9b1c4f9a0 100644
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp
@@ -114,6 +114,10 @@ private:
Action _action;
+ HeapWord* _last_query_beg;
+ oop _last_query_obj;
+ size_t _last_query_ret;
+
static PSOldGen* old_gen() { return _old_gen; }
static ObjectStartArray* start_array() { return _start_array; }
static OopTaskQueueSet* stack_array() { return _stack_array; }
@@ -132,9 +136,26 @@ private:
// marking stack and overflow stack directly.
public:
+ void reset_bitmap_query_cache() {
+ _last_query_beg = NULL;
+ _last_query_obj = NULL;
+ _last_query_ret = 0;
+ }
+
Action action() { return _action; }
void set_action(Action v) { _action = v; }
+ // Bitmap query support, cache last query and result
+ HeapWord* last_query_begin() { return _last_query_beg; }
+ oop last_query_object() { return _last_query_obj; }
+ size_t last_query_return() { return _last_query_ret; }
+
+ void set_last_query_begin(HeapWord *new_beg) { _last_query_beg = new_beg; }
+ void set_last_query_object(oop new_obj) { _last_query_obj = new_obj; }
+ void set_last_query_return(size_t new_ret) { _last_query_ret = new_ret; }
+
+ static void reset_all_bitmap_query_caches();
+
RegionTaskQueue* region_stack() { return _region_stack; }
void set_region_stack(RegionTaskQueue* v) { _region_stack = v; }
diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp
index 26d64a135..2c75c4d68 100644
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp
@@ -748,7 +748,7 @@ bool ParallelCompactData::summarize(SplitInfo& split_info,
return true;
}
-HeapWord* ParallelCompactData::calc_new_pointer(HeapWord* addr) {
+HeapWord* ParallelCompactData::calc_new_pointer(HeapWord* addr, ParCompactionManager* cm) {
assert(addr != NULL, "Should detect NULL oop earlier");
assert(PSParallelCompact::gc_heap()->is_in(addr), "not in heap");
assert(PSParallelCompact::mark_bitmap()->is_marked(addr), "not marked");
@@ -785,7 +785,7 @@ HeapWord* ParallelCompactData::calc_new_pointer(HeapWord* addr) {
const size_t block_offset = addr_to_block_ptr(addr)->offset();
const ParMarkBitMap* bitmap = PSParallelCompact::mark_bitmap();
- const size_t live = bitmap->live_words_in_range(search_start, oop(addr));
+ const size_t live = bitmap->live_words_in_range(cm, search_start, oop(addr));
result += block_offset + live;
DEBUG_ONLY(PSParallelCompact::check_new_location(addr, result));
return result;
@@ -825,11 +825,8 @@ bool PSParallelCompact::IsAliveClosure::do_object_b(oop p) { return mark_bitmap(
void PSParallelCompact::KeepAliveClosure::do_oop(oop* p) { PSParallelCompact::KeepAliveClosure::do_oop_work(p); }
void PSParallelCompact::KeepAliveClosure::do_oop(narrowOop* p) { PSParallelCompact::KeepAliveClosure::do_oop_work(p); }
-PSParallelCompact::AdjustPointerClosure PSParallelCompact::_adjust_pointer_closure;
-PSParallelCompact::AdjustKlassClosure PSParallelCompact::_adjust_klass_closure;
-
-void PSParallelCompact::AdjustPointerClosure::do_oop(oop* p) { adjust_pointer(p); }
-void PSParallelCompact::AdjustPointerClosure::do_oop(narrowOop* p) { adjust_pointer(p); }
+void PSParallelCompact::AdjustPointerClosure::do_oop(oop* p) { adjust_pointer(p, _cm); }
+void PSParallelCompact::AdjustPointerClosure::do_oop(narrowOop* p) { adjust_pointer(p, _cm); }
void PSParallelCompact::FollowStackClosure::do_void() { _compaction_manager->follow_marking_stacks(); }
@@ -842,7 +839,8 @@ void PSParallelCompact::FollowKlassClosure::do_klass(Klass* klass) {
klass->oops_do(_mark_and_push_closure);
}
void PSParallelCompact::AdjustKlassClosure::do_klass(Klass* klass) {
- klass->oops_do(&PSParallelCompact::_adjust_pointer_closure);
+ PSParallelCompact::AdjustPointerClosure closure(_cm);
+ klass->oops_do(&closure);
}
void PSParallelCompact::post_initialize() {
@@ -1021,6 +1019,8 @@ void PSParallelCompact::pre_compact(PreGCValues* pre_gc_values)
// Have worker threads release resources the next time they run a task.
gc_task_manager()->release_all_resources();
+
+ ParCompactionManager::reset_all_bitmap_query_caches();
}
void PSParallelCompact::post_compact()
@@ -2093,7 +2093,7 @@ bool PSParallelCompact::invoke_no_policy(bool maximum_heap_compaction) {
// adjust_roots() updates Universe::_intArrayKlassObj which is
// needed by the compaction for filling holes in the dense prefix.
- adjust_roots();
+ adjust_roots(vmthread_cm);
compaction_start.update();
compact();
@@ -2450,40 +2450,46 @@ void PSParallelCompact::follow_class_loader(ParCompactionManager* cm,
cld->oops_do(&mark_and_push_closure, &follow_klass_closure, true);
}
-void PSParallelCompact::adjust_roots() {
+void PSParallelCompact::adjust_roots(ParCompactionManager* cm) {
// Adjust the pointers to reflect the new locations
GCTraceTime tm("adjust roots", print_phases(), true, &_gc_timer, _gc_tracer.gc_id());
// Need new claim bits when tracing through and adjusting pointers.
ClassLoaderDataGraph::clear_claimed_marks();
+ PSParallelCompact::AdjustPointerClosure oop_closure(cm);
+ PSParallelCompact::AdjustKlassClosure klass_closure(cm);
+
// General strong roots.
- Universe::oops_do(adjust_pointer_closure());
- JNIHandles::oops_do(adjust_pointer_closure()); // Global (strong) JNI handles
- CLDToOopClosure adjust_from_cld(adjust_pointer_closure());
- Threads::oops_do(adjust_pointer_closure(), &adjust_from_cld, NULL);
- ObjectSynchronizer::oops_do(adjust_pointer_closure());
- FlatProfiler::oops_do(adjust_pointer_closure());
- Management::oops_do(adjust_pointer_closure());
- JvmtiExport::oops_do(adjust_pointer_closure());
- SystemDictionary::oops_do(adjust_pointer_closure());
- ClassLoaderDataGraph::oops_do(adjust_pointer_closure(), adjust_klass_closure(), true);
+ Universe::oops_do(&oop_closure);
+ JNIHandles::oops_do(&oop_closure); // Global (strong) JNI handles
+ CLDToOopClosure adjust_from_cld(&oop_closure);
+ Threads::oops_do(&oop_closure, &adjust_from_cld, NULL);
+ ObjectSynchronizer::oops_do(&oop_closure);
+ FlatProfiler::oops_do(&oop_closure);
+ Management::oops_do(&oop_closure);
+ JvmtiExport::oops_do(&oop_closure);
+ SystemDictionary::oops_do(&oop_closure);
+ ClassLoaderDataGraph::oops_do(&oop_closure, &klass_closure, true);
+
// Now adjust pointers in remaining weak roots. (All of which should
// have been cleared if they pointed to non-surviving objects.)
// Global (weak) JNI handles
- JNIHandles::weak_oops_do(adjust_pointer_closure());
- JFR_ONLY(Jfr::weak_oops_do(adjust_pointer_closure()));
+ JNIHandles::weak_oops_do(&oop_closure);
+ // adjust weak pointers in jfr oops. for TestJcmdDump.java
+ JFR_ONLY(Jfr::weak_oops_do(&oop_closure));
- CodeBlobToOopClosure adjust_from_blobs(adjust_pointer_closure(), CodeBlobToOopClosure::FixRelocations);
+ CodeBlobToOopClosure adjust_from_blobs(&oop_closure, CodeBlobToOopClosure::FixRelocations);
CodeCache::blobs_do(&adjust_from_blobs);
- StringTable::oops_do(adjust_pointer_closure());
- ref_processor()->weak_oops_do(adjust_pointer_closure());
+ StringTable::oops_do(&oop_closure);
+ ref_processor()->weak_oops_do(&oop_closure);
+
// Roots were visited so references into the young gen in roots
// may have been scanned. Process them also.
// Should the reference processor have a span that excludes
// young gen objects?
- PSScavenge::reference_processor()->weak_oops_do(adjust_pointer_closure());
+ PSScavenge::reference_processor()->weak_oops_do(&oop_closure);
}
void PSParallelCompact::enqueue_region_draining_tasks(GCTaskQueue* q,
@@ -3342,7 +3348,7 @@ MoveAndUpdateClosure::do_addr(HeapWord* addr, size_t words) {
assert(bitmap()->obj_size(addr) == words, "bad size");
_source = addr;
- assert(PSParallelCompact::summary_data().calc_new_pointer(source()) ==
+ assert(PSParallelCompact::summary_data().calc_new_pointer(source(), compaction_manager()) ==
destination(), "wrong destination");
if (words > words_remaining()) {
diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp
index f971383a0..efec18746 100644
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp
@@ -452,10 +452,10 @@ public:
HeapWord* partial_obj_end(size_t region_idx) const;
// Return the location of the object after compaction.
- HeapWord* calc_new_pointer(HeapWord* addr);
+ HeapWord* calc_new_pointer(HeapWord* addr, ParCompactionManager* cm);
- HeapWord* calc_new_pointer(oop p) {
- return calc_new_pointer((HeapWord*) p);
+ HeapWord* calc_new_pointer(oop p, ParCompactionManager* cm) {
+ return calc_new_pointer((HeapWord*) p, cm);
}
#ifdef ASSERT
@@ -957,15 +957,28 @@ class PSParallelCompact : AllStatic {
class AdjustPointerClosure: public OopClosure {
public:
+ AdjustPointerClosure(ParCompactionManager* cm) {
+ assert(cm != NULL, "associate ParCompactionManage should not be NULL");
+ _cm = cm;
+ }
+
virtual void do_oop(oop* p);
virtual void do_oop(narrowOop* p);
// do not walk from thread stacks to the code cache on this phase
virtual void do_code_blob(CodeBlob* cb) const { }
+ private:
+ ParCompactionManager* _cm;
};
class AdjustKlassClosure : public KlassClosure {
public:
+ AdjustKlassClosure(ParCompactionManager* cm) {
+ assert(cm != NULL, "associate ParCompactionManage should not be NULL");
+ _cm = cm;
+ }
void do_klass(Klass* klass);
+ private:
+ ParCompactionManager* _cm;
};
friend class KeepAliveClosure;
@@ -989,8 +1002,6 @@ class PSParallelCompact : AllStatic {
static IsAliveClosure _is_alive_closure;
static SpaceInfo _space_info[last_space_id];
static bool _print_phases;
- static AdjustPointerClosure _adjust_pointer_closure;
- static AdjustKlassClosure _adjust_klass_closure;
// Reference processing (used in ...follow_contents)
static ReferenceProcessor* _ref_processor;
@@ -1114,7 +1125,7 @@ class PSParallelCompact : AllStatic {
static void summary_phase(ParCompactionManager* cm, bool maximum_compaction);
// Adjust addresses in roots. Does not adjust addresses in heap.
- static void adjust_roots();
+ static void adjust_roots(ParCompactionManager* cm);
DEBUG_ONLY(static void write_block_fill_histogram(outputStream* const out);)
@@ -1184,8 +1195,6 @@ class PSParallelCompact : AllStatic {
static bool initialize();
// Closure accessors
- static OopClosure* adjust_pointer_closure() { return (OopClosure*)&_adjust_pointer_closure; }
- static KlassClosure* adjust_klass_closure() { return (KlassClosure*)&_adjust_klass_closure; }
static BoolObjectClosure* is_alive_closure() { return (BoolObjectClosure*)&_is_alive_closure; }
// Public accessors
@@ -1205,7 +1214,7 @@ class PSParallelCompact : AllStatic {
// Check mark and maybe push on marking stack
template <class T> static inline void mark_and_push(ParCompactionManager* cm,
T* p);
- template <class T> static inline void adjust_pointer(T* p);
+ template <class T> static inline void adjust_pointer(T* p, ParCompactionManager* cm);
static inline void follow_klass(ParCompactionManager* cm, Klass* klass);
@@ -1368,11 +1377,11 @@ inline void PSParallelCompact::mark_and_push(ParCompactionManager* cm, T* p) {
}
template <class T>
-inline void PSParallelCompact::adjust_pointer(T* p) {
+inline void PSParallelCompact::adjust_pointer(T* p, ParCompactionManager* cm) {
T heap_oop = oopDesc::load_heap_oop(p);
if (!oopDesc::is_null(heap_oop)) {
oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
- oop new_obj = (oop)summary_data().calc_new_pointer(obj);
+ oop new_obj = (oop)summary_data().calc_new_pointer(obj, cm);
assert(new_obj != NULL, // is forwarding ptr?
"should be forwarded");
// Just always do the update unconditionally?
diff --git a/hotspot/src/share/vm/oops/instanceKlass.cpp b/hotspot/src/share/vm/oops/instanceKlass.cpp
index 538645bbe..ad9eb8b01 100644
--- a/hotspot/src/share/vm/oops/instanceKlass.cpp
+++ b/hotspot/src/share/vm/oops/instanceKlass.cpp
@@ -2544,7 +2544,7 @@ int InstanceKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
int size = size_helper();
InstanceKlass_OOP_MAP_ITERATE( \
obj, \
- PSParallelCompact::adjust_pointer(p), \
+ PSParallelCompact::adjust_pointer(p, cm), \
assert_is_in)
return size;
}
diff --git a/hotspot/src/share/vm/oops/instanceMirrorKlass.cpp b/hotspot/src/share/vm/oops/instanceMirrorKlass.cpp
index fdf2e42af..ee911d190 100644
--- a/hotspot/src/share/vm/oops/instanceMirrorKlass.cpp
+++ b/hotspot/src/share/vm/oops/instanceMirrorKlass.cpp
@@ -345,7 +345,7 @@ int InstanceMirrorKlass::oop_update_pointers(ParCompactionManager* cm, oop obj)
InstanceMirrorKlass_OOP_ITERATE( \
start_of_static_fields(obj), java_lang_Class::static_oop_field_count(obj),\
- PSParallelCompact::adjust_pointer(p), \
+ PSParallelCompact::adjust_pointer(p, cm), \
assert_nothing)
return size;
}
diff --git a/hotspot/src/share/vm/oops/instanceRefKlass.cpp b/hotspot/src/share/vm/oops/instanceRefKlass.cpp
index 2c3fe7496..eb6c12edd 100644
--- a/hotspot/src/share/vm/oops/instanceRefKlass.cpp
+++ b/hotspot/src/share/vm/oops/instanceRefKlass.cpp
@@ -429,11 +429,11 @@ template <class T>
void specialized_oop_update_pointers(InstanceRefKlass *ref,
ParCompactionManager* cm, oop obj) {
T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
- PSParallelCompact::adjust_pointer(referent_addr);
+ PSParallelCompact::adjust_pointer(referent_addr, cm);
T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
- PSParallelCompact::adjust_pointer(next_addr);
+ PSParallelCompact::adjust_pointer(next_addr, cm);
T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj);
- PSParallelCompact::adjust_pointer(discovered_addr);
+ PSParallelCompact::adjust_pointer(discovered_addr, cm);
debug_only(trace_reference_gc("InstanceRefKlass::oop_update_ptrs", obj,
referent_addr, next_addr, discovered_addr);)
}
diff --git a/hotspot/src/share/vm/oops/objArrayKlass.cpp b/hotspot/src/share/vm/oops/objArrayKlass.cpp
index 60d173e9e..c69abdc06 100644
--- a/hotspot/src/share/vm/oops/objArrayKlass.cpp
+++ b/hotspot/src/share/vm/oops/objArrayKlass.cpp
@@ -590,7 +590,7 @@ int ObjArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
assert (obj->is_objArray(), "obj must be obj array");
objArrayOop a = objArrayOop(obj);
int size = a->object_size();
- ObjArrayKlass_OOP_ITERATE(a, p, PSParallelCompact::adjust_pointer(p))
+ ObjArrayKlass_OOP_ITERATE(a, p, PSParallelCompact::adjust_pointer(p, cm))
return size;
}
#endif // INCLUDE_ALL_GCS
--
2.22.0

7
openjdk-1.8.0.spec
View File

@ -916,7 +916,7 @@ Provides: java-%{javaver}-%{origin}-accessibility%{?1} = %{epoch}:%{version}-%{r
Name: java-%{javaver}-%{origin}
Version: %{javaver}.%{updatever}.%{buildver}
Release: 1
Release: 2
# java-1.5.0-ibm from jpackage.org set Epoch to 1 for unknown reasons
# and this change was brought into RHEL-4. java-1.5.0-ibm packages
# also included the epoch in their virtual provides. This created a
@ -1235,7 +1235,6 @@ Patch354: 0049-Modify-G1GC-log-information.patch
Patch355: 0050-8181644-C1-crashes-with-XX-PrintCFGToFile.patch
Patch356: 0051-8071962-The-SA-code-needs-to-be-updated-to-support-S.patch
Patch357: 0052-8177959-G1CollectedHeap-print_on-prints-incorrect-ca.patch
Patch358: 0053-8146987-Improve-Parallel-GC-Full-GC-by-caching-resul.patch
Patch359: 0054-Fix-jmap-heapdump-symbols-when-the-class-is-loaded-f.patch
Patch360: 0055-Fix-CodelistTest.java-Failed-to-Execute-CodelistTest.patch
@ -1818,7 +1817,6 @@ pushd %{top_level_dir_name}
%patch355 -p1
%patch356 -p1
%patch357 -p1
%patch358 -p1
%patch359 -p1
%patch360 -p1
%patch361 -p1
@ -2451,6 +2449,9 @@ cjc.mainProgram(arg)
%endif
%changelog
* Thu Aug 24 2023 kuenking111 <wangkun49@huawei.com> - 1:1.8.0.382-b05.2
- deleted 0053-8146987-Improve-Parallel-GC-Full-GC-by-caching-resul.patch
* Thu Aug 3 2023 kuenking111 <wangkun49@huawei.com> - 1:1.8.0.382-b05.1
- add Revert-backport-8035986-KerberosKey-algorithm-names-are-not-specified.patch