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

8224665: Parallel GC: Use WorkGang (7: remove task manager)

*** 28,38 ****
  #include "classfile/javaClasses.inline.hpp"
  #include "classfile/stringTable.hpp"
  #include "classfile/symbolTable.hpp"
  #include "classfile/systemDictionary.hpp"
  #include "code/codeCache.hpp"
- #include "gc/parallel/gcTaskManager.hpp"
  #include "gc/parallel/parallelArguments.hpp"
  #include "gc/parallel/parallelScavengeHeap.inline.hpp"
  #include "gc/parallel/parMarkBitMap.inline.hpp"
  #include "gc/parallel/psAdaptiveSizePolicy.hpp"
  #include "gc/parallel/psCompactionManager.inline.hpp"
--- 28,37 ----
***************
*** 1016,1028 ****
    }
  
    DEBUG_ONLY(mark_bitmap()->verify_clear();)
    DEBUG_ONLY(summary_data().verify_clear();)
  
-   // 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()
  {
--- 1015,1024 ----
***************
*** 1784,1808 ****
  
    PreGCValues pre_gc_values(heap);
  
    // Get the compaction manager reserved for the VM thread.
    ParCompactionManager* const vmthread_cm =
!     ParCompactionManager::manager_array(gc_task_manager()->workers());
  
    {
      ResourceMark rm;
      HandleMark hm;
  
      ParallelScavengeHeap::heap()->workers().update_active_workers(WorkerPolicy::calc_active_workers(
        ParallelScavengeHeap::heap()->workers().total_workers(),
        ParallelScavengeHeap::heap()->workers().active_workers(),
        Threads::number_of_non_daemon_threads()));
  
-     // Set the number of GC threads to be used in this collection
-     gc_task_manager()->set_active_gang();
-     gc_task_manager()->task_idle_workers();
- 
      GCTraceCPUTime tcpu;
      GCTraceTime(Info, gc) tm("Pause Full", NULL, gc_cause, true);
  
      heap->pre_full_gc_dump(&_gc_timer);
  
--- 1780,1800 ----
  
    PreGCValues pre_gc_values(heap);
  
    // Get the compaction manager reserved for the VM thread.
    ParCompactionManager* const vmthread_cm =
!     ParCompactionManager::manager_array(ParallelScavengeHeap::heap()->workers().total_workers());
  
    {
      ResourceMark rm;
      HandleMark hm;
  
      ParallelScavengeHeap::heap()->workers().update_active_workers(WorkerPolicy::calc_active_workers(
        ParallelScavengeHeap::heap()->workers().total_workers(),
        ParallelScavengeHeap::heap()->workers().active_workers(),
        Threads::number_of_non_daemon_threads()));
  
      GCTraceCPUTime tcpu;
      GCTraceTime(Info, gc) tm("Pause Full", NULL, gc_cause, true);
  
      heap->pre_full_gc_dump(&_gc_timer);
  
***************
*** 1936,1946 ****
      MetaspaceUtils::print_metaspace_change(pre_gc_values.metadata_used());
  
      // Track memory usage and detect low memory
      MemoryService::track_memory_usage();
      heap->update_counters();
-     gc_task_manager()->release_idle_workers();
  
      heap->post_full_gc_dump(&_gc_timer);
    }
  
  #ifdef ASSERT
--- 1928,1937 ----
***************
*** 1975,1985 ****
    heap->trace_heap_after_gc(&_gc_tracer);
  
    log_debug(gc, task, time)("VM-Thread " JLONG_FORMAT " " JLONG_FORMAT " " JLONG_FORMAT,
                           marking_start.ticks(), compaction_start.ticks(),
                           collection_exit.ticks());
-   gc_task_manager()->print_task_time_stamps();
  
  #ifdef TRACESPINNING
    ParallelTaskTerminator::print_termination_counts();
  #endif
  
--- 1966,1975 ----
***************
*** 1999,2009 ****
    MutableSpace* const eden_space = young_gen->eden_space();
    assert(!eden_space->is_empty(), "eden must be non-empty");
    assert(young_gen->virtual_space()->alignment() ==
           old_gen->virtual_space()->alignment(), "alignments do not match");
  
!   // We also return false when it's a heterogenous heap because old generation cannot absorb data from eden
    // when it is allocated on different memory (example, nv-dimm) than young.
    if (!(UseAdaptiveSizePolicy && UseAdaptiveGCBoundary) ||
        ParallelArguments::is_heterogeneous_heap()) {
      return false;
    }
--- 1989,1999 ----
    MutableSpace* const eden_space = young_gen->eden_space();
    assert(!eden_space->is_empty(), "eden must be non-empty");
    assert(young_gen->virtual_space()->alignment() ==
           old_gen->virtual_space()->alignment(), "alignments do not match");
  
!   // We also return false when it's a heterogeneous heap because old generation cannot absorb data from eden
    // when it is allocated on different memory (example, nv-dimm) than young.
    if (!(UseAdaptiveSizePolicy && UseAdaptiveGCBoundary) ||
        ParallelArguments::is_heterogeneous_heap()) {
      return false;
    }
***************
*** 2080,2095 ****
  
    size_policy->set_bytes_absorbed_from_eden(absorb_size);
    return true;
  }
  
- GCTaskManager* const PSParallelCompact::gc_task_manager() {
-   assert(ParallelScavengeHeap::gc_task_manager() != NULL,
-     "shouldn't return NULL");
-   return ParallelScavengeHeap::gc_task_manager();
- }
- 
  class PCAddThreadRootsMarkingTaskClosure : public ThreadClosure {
  private:
    uint _worker_id;
  
  public:
--- 2070,2079 ----
***************
*** 2266,2279 ****
                                        ParallelOldTracer *gc_tracer) {
    // Recursively traverse all live objects and mark them
    GCTraceTime(Info, gc, phases) tm("Marking Phase", &_gc_timer);
  
    ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
!   uint parallel_gc_threads = heap->gc_task_manager()->workers();
!   uint active_gc_threads = heap->gc_task_manager()->active_workers();
!   TaskQueueSetSuper* qset = ParCompactionManager::stack_array();
!   TaskTerminator terminator(active_gc_threads, qset);
  
    PCMarkAndPushClosure mark_and_push_closure(cm);
    ParCompactionManager::FollowStackClosure follow_stack_closure(cm);
  
    // Need new claim bits before marking starts.
--- 2250,2260 ----
                                        ParallelOldTracer *gc_tracer) {
    // Recursively traverse all live objects and mark them
    GCTraceTime(Info, gc, phases) tm("Marking Phase", &_gc_timer);
  
    ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
!   uint active_gc_threads = ParallelScavengeHeap::heap()->workers().active_workers();
  
    PCMarkAndPushClosure mark_and_push_closure(cm);
    ParCompactionManager::FollowStackClosure follow_stack_closure(cm);
  
    // Need new claim bits before marking starts.