Automatic merge of jdk:master into master

Author: duke

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

@@ -70,7 +70,7 @@ void ParCompactionManager::initialize(ParMarkBitMap* mbm) {
   uint parallel_gc_threads = ParallelScavengeHeap::heap()->workers().max_workers();
 
   assert(_manager_array == NULL, "Attempt to initialize twice");
-  _manager_array = NEW_C_HEAP_ARRAY(ParCompactionManager*, parallel_gc_threads+1, mtGC);
+  _manager_array = NEW_C_HEAP_ARRAY(ParCompactionManager*, parallel_gc_threads, mtGC);
 
   _oop_task_queues = new OopTaskQueueSet(parallel_gc_threads);
   _objarray_task_queues = new ObjArrayTaskQueueSet(parallel_gc_threads);
@@ -84,9 +84,6 @@ void ParCompactionManager::initialize(ParMarkBitMap* mbm) {
     region_task_queues()->register_queue(i, _manager_array[i]->region_stack());
   }
 
-  // The VMThread gets its own ParCompactionManager, which is not available
-  // for work stealing.
-  _manager_array[parallel_gc_threads] = new ParCompactionManager();
   assert(ParallelScavengeHeap::heap()->workers().max_workers() != 0,
     "Not initialized?");
 
@@ -97,14 +94,14 @@ void ParCompactionManager::initialize(ParMarkBitMap* mbm) {
 
 void ParCompactionManager::reset_all_bitmap_query_caches() {
   uint parallel_gc_threads = ParallelScavengeHeap::heap()->workers().max_workers();
-  for (uint i=0; i<=parallel_gc_threads; i++) {
+  for (uint i=0; i<parallel_gc_threads; i++) {
     _manager_array[i]->reset_bitmap_query_cache();
   }
 }
 
 void ParCompactionManager::flush_all_string_dedup_requests() {
   uint parallel_gc_threads = ParallelScavengeHeap::heap()->workers().max_workers();
-  for (uint i=0; i<=parallel_gc_threads; i++) {
+  for (uint i=0; i<parallel_gc_threads; i++) {
     _manager_array[i]->flush_string_dedup_requests();
   }
 }
@@ -184,14 +181,14 @@ void ParCompactionManager::remove_all_shadow_regions() {
 #ifdef ASSERT
 void ParCompactionManager::verify_all_marking_stack_empty() {
   uint parallel_gc_threads = ParallelGCThreads;
-  for (uint i = 0; i <= parallel_gc_threads; i++) {
+  for (uint i = 0; i < parallel_gc_threads; i++) {
     assert(_manager_array[i]->marking_stacks_empty(), "Marking stack should be empty");
   }
 }
 
 void ParCompactionManager::verify_all_region_stack_empty() {
   uint parallel_gc_threads = ParallelGCThreads;
-  for (uint i = 0; i <= parallel_gc_threads; i++) {
+  for (uint i = 0; i < parallel_gc_threads; i++) {
     assert(_manager_array[i]->region_stack()->is_empty(), "Region stack should be empty");
   }
 }

src/hotspot/share/gc/parallel/psCompactionManager.hpp

@@ -147,7 +147,9 @@ class ParCompactionManager : public CHeapObj<mtGC> {
 
   RegionTaskQueue* region_stack()                { return &_region_stack; }
 
-  static ParCompactionManager* get_vmthread_cm() { return _manager_array[ParallelGCThreads]; }
+  // Get the compaction manager when doing evacuation work from the VM thread.
+  // Simply use the first compaction manager here.
+  static ParCompactionManager* get_vmthread_cm() { return _manager_array[0]; }
 
   ParCompactionManager();
 

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

@@ -1595,8 +1595,7 @@ void PSParallelCompact::summary_phase_msg(SpaceId dst_space_id,
 }
 #endif  // #ifndef PRODUCT
 
-void PSParallelCompact::summary_phase(ParCompactionManager* cm,
-                                      bool maximum_compaction)
+void PSParallelCompact::summary_phase(bool maximum_compaction)
 {
   GCTraceTime(Info, gc, phases) tm("Summary Phase", &_gc_timer);
 
@@ -1756,9 +1755,6 @@ bool PSParallelCompact::invoke_no_policy(bool maximum_heap_compaction) {
 
   const PreGenGCValues pre_gc_values = heap->get_pre_gc_values();
 
-  // Get the compaction manager reserved for the VM thread.
-  ParCompactionManager* const vmthread_cm = ParCompactionManager::get_vmthread_cm();
-
   {
     const uint active_workers =
       WorkerPolicy::calc_active_workers(ParallelScavengeHeap::heap()->workers().max_workers(),
@@ -1787,11 +1783,11 @@ bool PSParallelCompact::invoke_no_policy(bool maximum_heap_compaction) {
 
     ref_processor()->start_discovery(maximum_heap_compaction);
 
-    marking_phase(vmthread_cm, &_gc_tracer);
+    marking_phase(&_gc_tracer);
 
     bool max_on_system_gc = UseMaximumCompactionOnSystemGC
       && GCCause::is_user_requested_gc(gc_cause);
-    summary_phase(vmthread_cm, maximum_heap_compaction || max_on_system_gc);
+    summary_phase(maximum_heap_compaction || max_on_system_gc);
 
 #if COMPILER2_OR_JVMCI
     assert(DerivedPointerTable::is_active(), "Sanity");
@@ -2063,8 +2059,7 @@ class ParallelCompactRefProcProxyTask : public RefProcProxyTask {
   }
 };
 
-void PSParallelCompact::marking_phase(ParCompactionManager* cm,
-                                      ParallelOldTracer *gc_tracer) {
+void PSParallelCompact::marking_phase(ParallelOldTracer *gc_tracer) {
   // Recursively traverse all live objects and mark them
   GCTraceTime(Info, gc, phases) tm("Marking Phase", &_gc_timer);
 
@@ -2125,19 +2120,6 @@ void PSParallelCompact::marking_phase(ParCompactionManager* cm,
   _gc_tracer.report_object_count_after_gc(is_alive_closure());
 }
 
-#ifdef ASSERT
-void PCAdjustPointerClosure::verify_cm(ParCompactionManager* cm) {
-  assert(cm != NULL, "associate ParCompactionManage should not be NULL");
-  auto vmthread_cm = ParCompactionManager::get_vmthread_cm();
-  if (Thread::current()->is_VM_thread()) {
-    assert(cm == vmthread_cm, "VM threads should use ParCompactionManager from get_vmthread_cm()");
-  } else {
-    assert(Thread::current()->is_Worker_thread(), "Must be a GC thread");
-    assert(cm != vmthread_cm, "GC threads should use ParCompactionManager from gc_thread_compaction_manager()");
-  }
-}
-#endif
-
 class PSAdjustTask final : public WorkerTask {
   SubTasksDone                               _sub_tasks;
   WeakProcessor::Task                        _weak_proc_task;
@@ -2528,9 +2510,7 @@ void PSParallelCompact::compact() {
 
   {
     GCTraceTime(Trace, gc, phases) tm("Deferred Updates", &_gc_timer);
-    // Update the deferred objects, if any. In principle, any compaction
-    // manager can be used. However, since the current thread is VM thread, we
-    // use the rightful one to keep the verification logic happy.
+    // Update the deferred objects, if any.
     ParCompactionManager* cm = ParCompactionManager::get_vmthread_cm();
     for (unsigned int id = old_space_id; id < last_space_id; ++id) {
       update_deferred_objects(cm, SpaceId(id));

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

@@ -1062,8 +1062,7 @@ class PSParallelCompact : AllStatic {
   static void post_compact();
 
   // Mark live objects
-  static void marking_phase(ParCompactionManager* cm,
-                            ParallelOldTracer *gc_tracer);
+  static void marking_phase(ParallelOldTracer *gc_tracer);
 
   // Compute the dense prefix for the designated space.  This is an experimental
   // implementation currently not used in production.
@@ -1123,7 +1122,7 @@ class PSParallelCompact : AllStatic {
 
   static void summarize_spaces_quick();
   static void summarize_space(SpaceId id, bool maximum_compaction);
-  static void summary_phase(ParCompactionManager* cm, bool maximum_compaction);
+  static void summary_phase(bool maximum_compaction);
 
   // Adjust addresses in roots.  Does not adjust addresses in heap.
   static void adjust_roots();

src/hotspot/share/gc/parallel/psParallelCompact.inline.hpp

@@ -126,9 +126,7 @@ inline void PSParallelCompact::adjust_pointer(T* p, ParCompactionManager* cm) {
 
 class PCAdjustPointerClosure: public BasicOopIterateClosure {
 public:
-  PCAdjustPointerClosure(ParCompactionManager* cm) {
-    verify_cm(cm);
-    _cm = cm;
+  PCAdjustPointerClosure(ParCompactionManager* cm) : _cm(cm) {
   }
   template <typename T> void do_oop_nv(T* p) { PSParallelCompact::adjust_pointer(p, _cm); }
   virtual void do_oop(oop* p)                { do_oop_nv(p); }
@@ -137,8 +135,6 @@ class PCAdjustPointerClosure: public BasicOopIterateClosure {
   virtual ReferenceIterationMode reference_iteration_mode() { return DO_FIELDS; }
 private:
   ParCompactionManager* _cm;
-
-  static void verify_cm(ParCompactionManager* cm) NOT_DEBUG_RETURN;
 };
 
 #endif // SHARE_GC_PARALLEL_PSPARALLELCOMPACT_INLINE_HPP

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

@@ -54,7 +54,7 @@ void PSPromotionManager::initialize() {
   _old_gen = heap->old_gen();
   _young_space = heap->young_gen()->to_space();
 
-  const uint promotion_manager_num = ParallelGCThreads + 1;
+  const uint promotion_manager_num = ParallelGCThreads;
 
   // To prevent false sharing, we pad the PSPromotionManagers
   // and make sure that the first instance starts at a cache line.
@@ -95,7 +95,7 @@ PSPromotionManager* PSPromotionManager::gc_thread_promotion_manager(uint index)
 
 PSPromotionManager* PSPromotionManager::vm_thread_promotion_manager() {
   assert(_manager_array != NULL, "Sanity");
-  return &_manager_array[ParallelGCThreads];
+  return &_manager_array[0];
 }
 
 void PSPromotionManager::pre_scavenge() {
@@ -104,7 +104,7 @@ void PSPromotionManager::pre_scavenge() {
   _preserved_marks_set->assert_empty();
   _young_space = heap->young_gen()->to_space();
 
-  for(uint i=0; i<ParallelGCThreads+1; i++) {
+  for(uint i=0; i<ParallelGCThreads; i++) {
     manager_array(i)->reset();
   }
 }
@@ -113,7 +113,7 @@ bool PSPromotionManager::post_scavenge(YoungGCTracer& gc_tracer) {
   bool promotion_failure_occurred = false;
 
   TASKQUEUE_STATS_ONLY(print_taskqueue_stats());
-  for (uint i = 0; i < ParallelGCThreads + 1; i++) {
+  for (uint i = 0; i < ParallelGCThreads; i++) {
     PSPromotionManager* manager = manager_array(i);
     assert(manager->claimed_stack_depth()->is_empty(), "should be empty");
     if (manager->_promotion_failed_info.has_failed()) {
@@ -162,7 +162,7 @@ PSPromotionManager::print_taskqueue_stats() {
   TaskQueueStats totals;
   out->print("thr "); TaskQueueStats::print_header(1, out); out->cr();
   out->print("--- "); TaskQueueStats::print_header(2, out); out->cr();
-  for (uint i = 0; i < ParallelGCThreads + 1; ++i) {
+  for (uint i = 0; i < ParallelGCThreads; ++i) {
     TaskQueueStats& next = manager_array(i)->_claimed_stack_depth.stats;
     out->print("%3d ", i); next.print(out); out->cr();
     totals += next;
@@ -171,7 +171,7 @@ PSPromotionManager::print_taskqueue_stats() {
 
   const uint hlines = sizeof(pm_stats_hdr) / sizeof(pm_stats_hdr[0]);
   for (uint i = 0; i < hlines; ++i) out->print_cr("%s", pm_stats_hdr[i]);
-  for (uint i = 0; i < ParallelGCThreads + 1; ++i) {
+  for (uint i = 0; i < ParallelGCThreads; ++i) {
     manager_array(i)->print_local_stats(out, i);
   }
 }

src/hotspot/share/gc/parallel/psPromotionManager.inline.hpp

@@ -44,7 +44,7 @@
 
 inline PSPromotionManager* PSPromotionManager::manager_array(uint index) {
   assert(_manager_array != NULL, "access of NULL manager_array");
-  assert(index <= ParallelGCThreads, "out of range manager_array access");
+  assert(index < ParallelGCThreads, "out of range manager_array access");
   return &_manager_array[index];
 }