Merge tag 'jdk-11.0.19-ga' into private-release-11.0.19.7.1

make/autoconf/version-numbers

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2011, 2020, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2011, 2023, 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
@@ -37,7 +37,7 @@ DEFAULT_VERSION_DATE=2023-04-18
 DEFAULT_VERSION_CLASSFILE_MAJOR=55  # "`$EXPR $DEFAULT_VERSION_FEATURE + 44`"
 DEFAULT_VERSION_CLASSFILE_MINOR=0
 DEFAULT_ACCEPTABLE_BOOT_VERSIONS="10 11"
-DEFAULT_PROMOTED_VERSION_PRE=ea
+DEFAULT_PROMOTED_VERSION_PRE=
 
 LAUNCHER_NAME=openjdk
 PRODUCT_NAME=OpenJDK

src/hotspot/share/gc/cms/concurrentMarkSweepGeneration.cpp

@@ -5068,8 +5068,9 @@ void CMSRefProcTaskProxy::work(uint worker_id) {
   CMSParDrainMarkingStackClosure par_drain_stack(_collector, _span,
                                                  _mark_bit_map,
                                                  work_queue(worker_id));
+  BarrierEnqueueDiscoveredFieldClosure enqueue;
   CMSIsAliveClosure is_alive_closure(_span, _mark_bit_map);
-  _task.work(worker_id, is_alive_closure, par_keep_alive, par_drain_stack);
+  _task.work(worker_id, is_alive_closure, par_keep_alive, enqueue, par_drain_stack);
   if (_task.marks_oops_alive()) {
     do_work_steal(worker_id, &par_drain_stack, &par_keep_alive,
                   _collector->hash_seed(worker_id));
@@ -5167,6 +5168,7 @@ void CMSCollector::refProcessingWork() {
     // Setup keep_alive and complete closures.
     CMSKeepAliveClosure cmsKeepAliveClosure(this, _span, &_markBitMap,
                                             &_markStack, false /* !preclean */);
+    BarrierEnqueueDiscoveredFieldClosure cmsEnqueue;
     CMSDrainMarkingStackClosure cmsDrainMarkingStackClosure(this,
                                   _span, &_markBitMap, &_markStack,
                                   &cmsKeepAliveClosure, false /* !preclean */);
@@ -5192,12 +5194,14 @@ void CMSCollector::refProcessingWork() {
       CMSRefProcTaskExecutor task_executor(*this);
       stats = rp->process_discovered_references(&_is_alive_closure,
                                         &cmsKeepAliveClosure,
+                                        &cmsEnqueue,
                                         &cmsDrainMarkingStackClosure,
                                         &task_executor,
                                         &pt);
     } else {
       stats = rp->process_discovered_references(&_is_alive_closure,
                                         &cmsKeepAliveClosure,
+                                        &cmsEnqueue,
                                         &cmsDrainMarkingStackClosure,
                                         NULL,
                                         &pt);

src/hotspot/share/gc/cms/parNewGeneration.cpp

@@ -780,8 +780,10 @@ void ParNewRefProcTaskProxy::work(uint worker_id) {
   HandleMark hm;
   ParScanThreadState& par_scan_state = _state_set.thread_state(worker_id);
   par_scan_state.set_young_old_boundary(_young_old_boundary);
+  BarrierEnqueueDiscoveredFieldClosure enqueue;
   _task.work(worker_id, par_scan_state.is_alive_closure(),
              par_scan_state.keep_alive_closure(),
+             enqueue,
              par_scan_state.evacuate_followers_closure());
 }
 
@@ -948,6 +950,7 @@ void ParNewGeneration::collect(bool   full,
   IsAliveClosure is_alive(this);
   ScanWeakRefClosure scan_weak_ref(this);
   KeepAliveClosure keep_alive(&scan_weak_ref);
+  BarrierEnqueueDiscoveredFieldClosure enqueue;
   ScanClosure               scan_without_gc_barrier(this, false);
   ScanClosureWithParBarrier scan_with_gc_barrier(this, true);
   set_promo_failure_scan_stack_closure(&scan_without_gc_barrier);
@@ -960,13 +963,13 @@ void ParNewGeneration::collect(bool   full,
   ReferenceProcessorPhaseTimes pt(_gc_timer, rp->max_num_queues());
   if (rp->processing_is_mt()) {
     ParNewRefProcTaskExecutor task_executor(*this, *_old_gen, thread_state_set);
-    stats = rp->process_discovered_references(&is_alive, &keep_alive,
+    stats = rp->process_discovered_references(&is_alive, &keep_alive, &enqueue,
                                               &evacuate_followers, &task_executor,
                                               &pt);
   } else {
     thread_state_set.flush();
     gch->save_marks();
-    stats = rp->process_discovered_references(&is_alive, &keep_alive,
+    stats = rp->process_discovered_references(&is_alive, &keep_alive, &enqueue,
                                               &evacuate_followers, NULL,
                                               &pt);
   }

src/hotspot/share/gc/g1/dirtyCardQueue.hpp

@@ -160,7 +160,6 @@ class DirtyCardQueueSet: public PtrQueueSet {
 
   // If any threads have partial logs, add them to the global list of logs.
   void concatenate_logs();
-  void clear_n_completed_buffers() { _n_completed_buffers = 0;}
 
   jint processed_buffers_mut() {
     return _processed_buffers_mut;

src/hotspot/share/gc/g1/g1CollectedHeap.cpp

@@ -1865,7 +1865,6 @@ void G1CollectedHeap::iterate_dirty_card_closure(CardTableEntryClosure* cl, uint
     n_completed_buffers++;
   }
   g1_policy()->phase_times()->record_thread_work_item(G1GCPhaseTimes::UpdateRS, worker_i, n_completed_buffers, G1GCPhaseTimes::UpdateRSProcessedBuffers);
-  dcqs.clear_n_completed_buffers();
   assert(!dcqs.completed_buffers_exist_dirty(), "Completed buffers exist!");
 }
 
@@ -3806,6 +3805,31 @@ class G1CopyingKeepAliveClosure: public OopClosure {
   }
 };
 
+// Special closure for enqueuing discovered fields: during enqueue the card table
+// may not be in shape to properly handle normal barrier calls (e.g. card marks
+// in regions that failed evacuation, scribbling of various values by card table
+// scan code). Additionally the regular barrier enqueues into the "global"
+// DCQS, but during GC we need these to-be-refined entries in the GC local queue
+// so that after clearing the card table, the redirty cards phase will properly
+// mark all dirty cards to be picked up by refinement.
+class G1EnqueueDiscoveredFieldClosure : public EnqueueDiscoveredFieldClosure {
+  G1CollectedHeap* _g1h;
+  G1ParScanThreadState* _pss;
+
+public:
+  G1EnqueueDiscoveredFieldClosure(G1CollectedHeap* g1h, G1ParScanThreadState* pss) : _g1h(g1h), _pss(pss) { }
+
+  virtual void enqueue(HeapWord* discovered_field_addr, oop value) {
+    assert(_g1h->is_in(discovered_field_addr), PTR_FORMAT " is not in heap ", p2i(discovered_field_addr));
+    // Store the value first, whatever it is.
+    RawAccess<>::oop_store(discovered_field_addr, value);
+    if (value == NULL) {
+      return;
+    }
+    _pss->write_ref_field_post(discovered_field_addr, value);
+  }
+};
+
 // Serial drain queue closure. Called as the 'complete_gc'
 // closure for each discovered list in some of the
 // reference processing phases.
@@ -3895,11 +3919,12 @@ class G1STWRefProcTaskProxy: public AbstractGangTask {
     // Keep alive closure.
     G1CopyingKeepAliveClosure keep_alive(_g1h, pss->closures()->raw_strong_oops(), pss);
 
+    G1EnqueueDiscoveredFieldClosure enqueue(_g1h, pss);
     // Complete GC closure
     G1ParEvacuateFollowersClosure drain_queue(_g1h, pss, _task_queues, _terminator);
 
     // Call the reference processing task's work routine.
-    _proc_task.work(worker_id, is_alive, keep_alive, drain_queue);
+    _proc_task.work(worker_id, is_alive, keep_alive, enqueue, drain_queue);
 
     // Note we cannot assert that the refs array is empty here as not all
     // of the processing tasks (specifically phase2 - pp2_work) execute
@@ -3947,6 +3972,7 @@ void G1CollectedHeap::process_discovered_references(G1ParScanThreadStateSet* per
   // Keep alive closure.
   G1CopyingKeepAliveClosure keep_alive(this, pss->closures()->raw_strong_oops(), pss);
 
+  G1EnqueueDiscoveredFieldClosure enqueue(this, pss);
   // Serial Complete GC closure
   G1STWDrainQueueClosure drain_queue(this, pss);
 
@@ -3960,6 +3986,7 @@ void G1CollectedHeap::process_discovered_references(G1ParScanThreadStateSet* per
     // Serial reference processing...
     stats = rp->process_discovered_references(&is_alive,
                                               &keep_alive,
+                                              &enqueue,
                                               &drain_queue,
                                               NULL,
                                               pt);
@@ -3974,6 +4001,7 @@ void G1CollectedHeap::process_discovered_references(G1ParScanThreadStateSet* per
     G1STWRefProcTaskExecutor par_task_executor(this, per_thread_states, workers(), _task_queues);
     stats = rp->process_discovered_references(&is_alive,
                                               &keep_alive,
+                                              &enqueue,
                                               &drain_queue,
                                               &par_task_executor,
                                               pt);

src/hotspot/share/gc/g1/g1ConcurrentMark.cpp

@@ -1550,9 +1550,10 @@ class G1CMRefProcTaskProxy : public AbstractGangTask {
     G1CMTask* task = _cm->task(worker_id);
     G1CMIsAliveClosure g1_is_alive(_g1h);
     G1CMKeepAliveAndDrainClosure g1_par_keep_alive(_cm, task, false /* is_serial */);
+    BarrierEnqueueDiscoveredFieldClosure enqueue;
     G1CMDrainMarkingStackClosure g1_par_drain(_cm, task, false /* is_serial */);
 
-    _proc_task.work(worker_id, g1_is_alive, g1_par_keep_alive, g1_par_drain);
+    _proc_task.work(worker_id, g1_is_alive, g1_par_keep_alive, enqueue, g1_par_drain);
   }
 };
 
@@ -1609,6 +1610,7 @@ void G1ConcurrentMark::weak_refs_work(bool clear_all_soft_refs) {
     // their own instances of these closures, which do their own
     // synchronization among themselves.
     G1CMKeepAliveAndDrainClosure g1_keep_alive(this, task(0), true /* is_serial */);
+    BarrierEnqueueDiscoveredFieldClosure g1_enqueue;
     G1CMDrainMarkingStackClosure g1_drain_mark_stack(this, task(0), true /* is_serial */);
 
     // We need at least one active thread. If reference processing
@@ -1640,6 +1642,7 @@ void G1ConcurrentMark::weak_refs_work(bool clear_all_soft_refs) {
     const ReferenceProcessorStats& stats =
         rp->process_discovered_references(&g1_is_alive,
                                           &g1_keep_alive,
+                                          &g1_enqueue,
                                           &g1_drain_mark_stack,
                                           executor,
                                           &pt);

src/hotspot/share/gc/g1/g1FullGCReferenceProcessorExecutor.cpp

@@ -58,10 +58,12 @@ G1FullGCReferenceProcessingExecutor::G1RefProcTaskProxy::G1RefProcTaskProxy(Proc
 void G1FullGCReferenceProcessingExecutor::G1RefProcTaskProxy::work(uint worker_id) {
   G1FullGCMarker* marker = _collector->marker(worker_id);
   G1IsAliveClosure is_alive(_collector->mark_bitmap());
+  BarrierEnqueueDiscoveredFieldClosure enqueue;
   G1FullKeepAliveClosure keep_alive(marker);
   _proc_task.work(worker_id,
                   is_alive,
                   keep_alive,
+                  enqueue,
                   *marker->stack_closure());
 }
 
@@ -84,6 +86,7 @@ void G1FullGCReferenceProcessingExecutor::execute(STWGCTimer* timer, G1FullGCTra
   G1FullGCMarker* marker = _collector->marker(0);
   G1IsAliveClosure is_alive(_collector->mark_bitmap());
   G1FullKeepAliveClosure keep_alive(marker);
+  BarrierEnqueueDiscoveredFieldClosure enqueue;
   ReferenceProcessorPhaseTimes pt(timer, _reference_processor->max_num_queues());
   AbstractRefProcTaskExecutor* executor = _reference_processor->processing_is_mt() ? this : NULL;
 
@@ -92,6 +95,7 @@ void G1FullGCReferenceProcessingExecutor::execute(STWGCTimer* timer, G1FullGCTra
   const ReferenceProcessorStats& stats =
       _reference_processor->process_discovered_references(&is_alive,
                                                           &keep_alive,
+                                                          &enqueue,
                                                           marker->stack_closure(),
                                                           executor,
                                                           &pt);

src/hotspot/share/gc/g1/g1ParScanThreadState.hpp

@@ -105,6 +105,12 @@ class G1ParScanThreadState : public CHeapObj<mtGC> {
   template <class T> void do_oop_ext(T* ref);
   template <class T> void push_on_queue(T* ref);
 
+  // Apply the post barrier to the given reference field. Enqueues the card of p
+  // if the barrier does not filter out the reference for some reason (e.g.
+  // p and q are in the same region, p is in survivor, p is in collection set)
+  // To be called during GC if nothing particular about p and obj are known.
+  template <class T> void write_ref_field_post(T* p, oop obj);
+
   template <class T> void update_rs(HeapRegion* from, T* p, oop o) {
     assert(!HeapRegion::is_in_same_region(p, o), "Caller should have filtered out cross-region references already.");
     // If the field originates from the to-space, we don't need to include it

src/hotspot/share/gc/g1/g1ParScanThreadState.inline.hpp

@@ -55,11 +55,16 @@ template <class T> void G1ParScanThreadState::do_oop_evac(T* p) {
            "In_cset_state must be NotInCSet here, but is " CSETSTATE_FORMAT, in_cset_state.value());
   }
 
+  write_ref_field_post(p, obj);
+}
+
+template <class T> void G1ParScanThreadState::write_ref_field_post(T* p, oop obj) {
   assert(obj != NULL, "Must be");
-  if (!HeapRegion::is_in_same_region(p, obj)) {
-    HeapRegion* from = _g1h->heap_region_containing(p);
-    update_rs(from, p, obj);
+  if (HeapRegion::is_in_same_region(p, obj)) {
+    return;
   }
+  HeapRegion* from = _g1h->heap_region_containing(p);
+  update_rs(from, p, obj);
 }
 
 template <class T> inline void G1ParScanThreadState::push_on_queue(T* ref) {

src/hotspot/share/gc/g1/ptrQueue.hpp

@@ -329,7 +329,7 @@ class PtrQueueSet {
   bool process_or_enqueue_complete_buffer(BufferNode* node);
 
   bool completed_buffers_exist_dirty() {
-    return _n_completed_buffers > 0;
+    return _n_completed_buffers > 0 || _completed_buffers_head != NULL;
   }
 
   bool process_completed_buffers() { return _process_completed; }

src/hotspot/share/gc/parallel/pcTasks.cpp

@@ -137,9 +137,10 @@ void RefProcTaskProxy::do_it(GCTaskManager* manager, uint which)
   ParCompactionManager* cm =
     ParCompactionManager::gc_thread_compaction_manager(which);
   ParCompactionManager::MarkAndPushClosure mark_and_push_closure(cm);
+  BarrierEnqueueDiscoveredFieldClosure enqueue;
   ParCompactionManager::FollowStackClosure follow_stack_closure(cm);
   _rp_task.work(_work_id, *PSParallelCompact::is_alive_closure(),
-                mark_and_push_closure, follow_stack_closure);
+                mark_and_push_closure, enqueue, follow_stack_closure);
 }
 
 //

src/hotspot/share/gc/parallel/psMarkSweep.cpp

@@ -534,9 +534,10 @@ void PSMarkSweep::mark_sweep_phase1(bool clear_all_softrefs) {
 
     ref_processor()->setup_policy(clear_all_softrefs);
     ReferenceProcessorPhaseTimes pt(_gc_timer, ref_processor()->max_num_queues());
+    BarrierEnqueueDiscoveredFieldClosure enqueue;
     const ReferenceProcessorStats& stats =
       ref_processor()->process_discovered_references(
-        is_alive_closure(), mark_and_push_closure(), follow_stack_closure(), NULL, &pt);
+        is_alive_closure(), mark_and_push_closure(), &enqueue, follow_stack_closure(), NULL, &pt);
     gc_tracer()->report_gc_reference_stats(stats);
     pt.print_all_references();
   }

src/hotspot/share/gc/parallel/psParallelCompact.cpp

@@ -2118,16 +2118,18 @@ void PSParallelCompact::marking_phase(ParCompactionManager* cm,
     ReferenceProcessorStats stats;
     ReferenceProcessorPhaseTimes pt(&_gc_timer, ref_processor()->max_num_queues());
 
+    BarrierEnqueueDiscoveredFieldClosure enqueue;
+
     if (ref_processor()->processing_is_mt()) {
       ref_processor()->set_active_mt_degree(active_gc_threads);
 
       RefProcTaskExecutor task_executor;
       stats = ref_processor()->process_discovered_references(
-        is_alive_closure(), &mark_and_push_closure, &follow_stack_closure,
+        is_alive_closure(), &mark_and_push_closure, &enqueue, &follow_stack_closure,
         &task_executor, &pt);
     } else {
       stats = ref_processor()->process_discovered_references(
-        is_alive_closure(), &mark_and_push_closure, &follow_stack_closure, NULL,
+        is_alive_closure(), &mark_and_push_closure, &enqueue, &follow_stack_closure, NULL,
         &pt);
     }
 

src/hotspot/share/gc/parallel/psScavenge.cpp

@@ -145,9 +145,10 @@ void PSRefProcTaskProxy::do_it(GCTaskManager* manager, uint which)
     PSPromotionManager::gc_thread_promotion_manager(which);
   assert(promotion_manager != NULL, "sanity check");
   PSKeepAliveClosure keep_alive(promotion_manager);
+  BarrierEnqueueDiscoveredFieldClosure enqueue;
   PSEvacuateFollowersClosure evac_followers(promotion_manager);
   PSIsAliveClosure is_alive;
-  _rp_task.work(_work_id, is_alive, keep_alive, evac_followers);
+  _rp_task.work(_work_id, is_alive, keep_alive, enqueue, evac_followers);
 }
 
 class PSRefProcTaskExecutor: public AbstractRefProcTaskExecutor {
@@ -405,17 +406,18 @@ bool PSScavenge::invoke_no_policy() {
       reference_processor()->setup_policy(false); // not always_clear
       reference_processor()->set_active_mt_degree(active_workers);
       PSKeepAliveClosure keep_alive(promotion_manager);
+      BarrierEnqueueDiscoveredFieldClosure enqueue;
       PSEvacuateFollowersClosure evac_followers(promotion_manager);
       ReferenceProcessorStats stats;
       ReferenceProcessorPhaseTimes pt(&_gc_timer, reference_processor()->max_num_queues());
       if (reference_processor()->processing_is_mt()) {
         PSRefProcTaskExecutor task_executor;
         stats = reference_processor()->process_discovered_references(
-          &_is_alive_closure, &keep_alive, &evac_followers, &task_executor,
+          &_is_alive_closure, &keep_alive, &enqueue, &evac_followers, &task_executor,
           &pt);
       } else {
         stats = reference_processor()->process_discovered_references(
-          &_is_alive_closure, &keep_alive, &evac_followers, NULL, &pt);
+          &_is_alive_closure, &keep_alive, &enqueue, &evac_followers, NULL, &pt);
       }
 
       _gc_tracer.report_gc_reference_stats(stats);

src/hotspot/share/gc/serial/defNewGeneration.cpp

@@ -619,11 +619,12 @@ void DefNewGeneration::collect(bool   full,
   evacuate_followers.do_void();
 
   FastKeepAliveClosure keep_alive(this, &scan_weak_ref);
+  BarrierEnqueueDiscoveredFieldClosure enqueue;
   ReferenceProcessor* rp = ref_processor();
   rp->setup_policy(clear_all_soft_refs);
   ReferenceProcessorPhaseTimes pt(_gc_timer, rp->max_num_queues());
   const ReferenceProcessorStats& stats =
-  rp->process_discovered_references(&is_alive, &keep_alive, &evacuate_followers,
+  rp->process_discovered_references(&is_alive, &keep_alive, &enqueue, &evacuate_followers,
                                     NULL, &pt);
   gc_tracer.report_gc_reference_stats(stats);
   gc_tracer.report_tenuring_threshold(tenuring_threshold());

src/hotspot/share/gc/serial/genMarkSweep.cpp

@@ -210,9 +210,10 @@ void GenMarkSweep::mark_sweep_phase1(bool clear_all_softrefs) {
 
     ref_processor()->setup_policy(clear_all_softrefs);
     ReferenceProcessorPhaseTimes pt(_gc_timer, ref_processor()->max_num_queues());
+    BarrierEnqueueDiscoveredFieldClosure enqueue;
     const ReferenceProcessorStats& stats =
       ref_processor()->process_discovered_references(
-        &is_alive, &keep_alive, &follow_stack_closure, NULL, &pt);
+        &is_alive, &keep_alive, &enqueue, &follow_stack_closure, NULL, &pt);
     pt.print_all_references();
     gc_tracer()->report_gc_reference_stats(stats);
   }