src/hotspot/share/gc/shenandoah/shenandoahConcurrentMark.cpp

rev 57914 : 8238162: Shenandoah: Remove ShenandoahTaskTerminator wrapper

*** 153,166 ****
  };
  
  class ShenandoahConcurrentMarkingTask : public AbstractGangTask {
  private:
    ShenandoahConcurrentMark* _cm;
!   ShenandoahTaskTerminator* _terminator;
  
  public:
!   ShenandoahConcurrentMarkingTask(ShenandoahConcurrentMark* cm, ShenandoahTaskTerminator* terminator) :
      AbstractGangTask("Root Region Scan"), _cm(cm), _terminator(terminator) {
    }
  
    void work(uint worker_id) {
      ShenandoahHeap* heap = ShenandoahHeap::heap();
--- 153,166 ----
  };
  
  class ShenandoahConcurrentMarkingTask : public AbstractGangTask {
  private:
    ShenandoahConcurrentMark* _cm;
!   TaskTerminator* _terminator;
  
  public:
!   ShenandoahConcurrentMarkingTask(ShenandoahConcurrentMark* cm, TaskTerminator* terminator) :
      AbstractGangTask("Root Region Scan"), _cm(cm), _terminator(terminator) {
    }
  
    void work(uint worker_id) {
      ShenandoahHeap* heap = ShenandoahHeap::heap();
*** 200,214 ****
  };
  
  class ShenandoahFinalMarkingTask : public AbstractGangTask {
  private:
    ShenandoahConcurrentMark* _cm;
!   ShenandoahTaskTerminator* _terminator;
    bool _dedup_string;
  
  public:
!   ShenandoahFinalMarkingTask(ShenandoahConcurrentMark* cm, ShenandoahTaskTerminator* terminator, bool dedup_string) :
      AbstractGangTask("Shenandoah Final Marking"), _cm(cm), _terminator(terminator), _dedup_string(dedup_string) {
    }
  
    void work(uint worker_id) {
      ShenandoahHeap* heap = ShenandoahHeap::heap();
--- 200,214 ----
  };
  
  class ShenandoahFinalMarkingTask : public AbstractGangTask {
  private:
    ShenandoahConcurrentMark* _cm;
!   TaskTerminator*           _terminator;
    bool _dedup_string;
  
  public:
!   ShenandoahFinalMarkingTask(ShenandoahConcurrentMark* cm, TaskTerminator* terminator, bool dedup_string) :
      AbstractGangTask("Shenandoah Final Marking"), _cm(cm), _terminator(terminator), _dedup_string(dedup_string) {
    }
  
    void work(uint worker_id) {
      ShenandoahHeap* heap = ShenandoahHeap::heap();
*** 403,413 ****
  
    task_queues()->reserve(nworkers);
  
    {
      ShenandoahTerminationTracker term(ShenandoahPhaseTimings::conc_termination);
!     ShenandoahTaskTerminator terminator(nworkers, task_queues());
      ShenandoahConcurrentMarkingTask task(this, &terminator);
      workers->run_task(&task);
    }
  
    assert(task_queues()->is_empty() || _heap->cancelled_gc(), "Should be empty when not cancelled");
--- 403,413 ----
  
    task_queues()->reserve(nworkers);
  
    {
      ShenandoahTerminationTracker term(ShenandoahPhaseTimings::conc_termination);
!     TaskTerminator terminator(nworkers, task_queues());
      ShenandoahConcurrentMarkingTask task(this, &terminator);
      workers->run_task(&task);
    }
  
    assert(task_queues()->is_empty() || _heap->cancelled_gc(), "Should be empty when not cancelled");
*** 438,448 ****
      ShenandoahTerminationTracker termination_tracker(full_gc ?
                                                       ShenandoahPhaseTimings::full_gc_mark_termination :
                                                       ShenandoahPhaseTimings::termination);
  
      StrongRootsScope scope(nworkers);
!     ShenandoahTaskTerminator terminator(nworkers, task_queues());
      ShenandoahFinalMarkingTask task(this, &terminator, ShenandoahStringDedup::is_enabled());
      _heap->workers()->run_task(&task);
    }
  
    assert(task_queues()->is_empty(), "Should be empty");
--- 438,448 ----
      ShenandoahTerminationTracker termination_tracker(full_gc ?
                                                       ShenandoahPhaseTimings::full_gc_mark_termination :
                                                       ShenandoahPhaseTimings::termination);
  
      StrongRootsScope scope(nworkers);
!     TaskTerminator terminator(nworkers, task_queues());
      ShenandoahFinalMarkingTask task(this, &terminator, ShenandoahStringDedup::is_enabled());
      _heap->workers()->run_task(&task);
    }
  
    assert(task_queues()->is_empty(), "Should be empty");
*** 458,472 ****
  }
  
  // Weak Reference Closures
  class ShenandoahCMDrainMarkingStackClosure: public VoidClosure {
    uint _worker_id;
!   ShenandoahTaskTerminator* _terminator;
    bool _reset_terminator;
  
  public:
!   ShenandoahCMDrainMarkingStackClosure(uint worker_id, ShenandoahTaskTerminator* t, bool reset_terminator = false):
      _worker_id(worker_id),
      _terminator(t),
      _reset_terminator(reset_terminator) {
    }
  
--- 458,472 ----
  }
  
  // Weak Reference Closures
  class ShenandoahCMDrainMarkingStackClosure: public VoidClosure {
    uint _worker_id;
!   TaskTerminator* _terminator;
    bool _reset_terminator;
  
  public:
!   ShenandoahCMDrainMarkingStackClosure(uint worker_id, TaskTerminator* t, bool reset_terminator = false):
      _worker_id(worker_id),
      _terminator(t),
      _reset_terminator(reset_terminator) {
    }
  
*** 550,564 ****
  };
  
  class ShenandoahRefProcTaskProxy : public AbstractGangTask {
  private:
    AbstractRefProcTaskExecutor::ProcessTask& _proc_task;
!   ShenandoahTaskTerminator* _terminator;
  
  public:
    ShenandoahRefProcTaskProxy(AbstractRefProcTaskExecutor::ProcessTask& proc_task,
!                              ShenandoahTaskTerminator* t) :
      AbstractGangTask("Process reference objects in parallel"),
      _proc_task(proc_task),
      _terminator(t) {
    }
  
--- 550,564 ----
  };
  
  class ShenandoahRefProcTaskProxy : public AbstractGangTask {
  private:
    AbstractRefProcTaskExecutor::ProcessTask& _proc_task;
!   TaskTerminator* _terminator;
  
  public:
    ShenandoahRefProcTaskProxy(AbstractRefProcTaskExecutor::ProcessTask& proc_task,
!                              TaskTerminator* t) :
      AbstractGangTask("Process reference objects in parallel"),
      _proc_task(proc_task),
      _terminator(t) {
    }
  
*** 598,608 ****
      ShenandoahPushWorkerQueuesScope scope(_workers, cm->task_queues(),
                                            ergo_workers,
                                            /* do_check = */ false);
      uint nworkers = _workers->active_workers();
      cm->task_queues()->reserve(nworkers);
!     ShenandoahTaskTerminator terminator(nworkers, cm->task_queues());
      ShenandoahRefProcTaskProxy proc_task_proxy(task, &terminator);
      _workers->run_task(&proc_task_proxy);
    }
  };
  
--- 598,608 ----
      ShenandoahPushWorkerQueuesScope scope(_workers, cm->task_queues(),
                                            ergo_workers,
                                            /* do_check = */ false);
      uint nworkers = _workers->active_workers();
      cm->task_queues()->reserve(nworkers);
!     TaskTerminator terminator(nworkers, cm->task_queues());
      ShenandoahRefProcTaskProxy proc_task_proxy(task, &terminator);
      _workers->run_task(&proc_task_proxy);
    }
  };
  
*** 656,666 ****
    // complete_gc and keep_alive closures instantiated here are only needed for
    // single-threaded path in RP. They share the queue 0 for tracking work, which
    // simplifies implementation. Since RP may decide to call complete_gc several
    // times, we need to be able to reuse the terminator.
    uint serial_worker_id = 0;
!   ShenandoahTaskTerminator terminator(1, task_queues());
    ShenandoahCMDrainMarkingStackClosure complete_gc(serial_worker_id, &terminator, /* reset_terminator = */ true);
  
    ShenandoahRefProcTaskExecutor executor(workers);
  
    ReferenceProcessorPhaseTimes pt(_heap->gc_timer(), rp->num_queues());
--- 656,666 ----
    // complete_gc and keep_alive closures instantiated here are only needed for
    // single-threaded path in RP. They share the queue 0 for tracking work, which
    // simplifies implementation. Since RP may decide to call complete_gc several
    // times, we need to be able to reuse the terminator.
    uint serial_worker_id = 0;
!   TaskTerminator terminator(1, task_queues());
    ShenandoahCMDrainMarkingStackClosure complete_gc(serial_worker_id, &terminator, /* reset_terminator = */ true);
  
    ShenandoahRefProcTaskExecutor executor(workers);
  
    ReferenceProcessorPhaseTimes pt(_heap->gc_timer(), rp->num_queues());
*** 701,711 ****
  public:
    void do_void() {
      ShenandoahHeap* sh = ShenandoahHeap::heap();
      ShenandoahConcurrentMark* scm = sh->concurrent_mark();
      assert(sh->process_references(), "why else would we be here?");
!     ShenandoahTaskTerminator terminator(1, scm->task_queues());
  
      ReferenceProcessor* rp = sh->ref_processor();
      shenandoah_assert_rp_isalive_installed();
  
      scm->mark_loop(0, &terminator, rp,
--- 701,711 ----
  public:
    void do_void() {
      ShenandoahHeap* sh = ShenandoahHeap::heap();
      ShenandoahConcurrentMark* scm = sh->concurrent_mark();
      assert(sh->process_references(), "why else would we be here?");
!     TaskTerminator terminator(1, scm->task_queues());
  
      ReferenceProcessor* rp = sh->ref_processor();
      shenandoah_assert_rp_isalive_installed();
  
      scm->mark_loop(0, &terminator, rp,
*** 824,834 ****
    assert(task_queues()->get_reserved() > worker_id, "No reserved queue for worker id: %d", worker_id);
    return _task_queues->queue(worker_id);
  }
  
  template <bool CANCELLABLE>
! void ShenandoahConcurrentMark::mark_loop_prework(uint w, ShenandoahTaskTerminator *t, ReferenceProcessor *rp,
                                                   bool strdedup) {
    ShenandoahObjToScanQueue* q = get_queue(w);
  
    jushort* ld = _heap->get_liveness_cache(w);
  
--- 824,834 ----
    assert(task_queues()->get_reserved() > worker_id, "No reserved queue for worker id: %d", worker_id);
    return _task_queues->queue(worker_id);
  }
  
  template <bool CANCELLABLE>
! void ShenandoahConcurrentMark::mark_loop_prework(uint w, TaskTerminator *t, ReferenceProcessor *rp,
                                                   bool strdedup) {
    ShenandoahObjToScanQueue* q = get_queue(w);
  
    jushort* ld = _heap->get_liveness_cache(w);
  
*** 874,884 ****
  
    _heap->flush_liveness_cache(w);
  }
  
  template <class T, bool CANCELLABLE>
! void ShenandoahConcurrentMark::mark_loop_work(T* cl, jushort* live_data, uint worker_id, ShenandoahTaskTerminator *terminator) {
    uintx stride = ShenandoahMarkLoopStride;
  
    ShenandoahHeap* heap = ShenandoahHeap::heap();
    ShenandoahObjToScanQueueSet* queues = task_queues();
    ShenandoahObjToScanQueue* q;
--- 874,884 ----
  
    _heap->flush_liveness_cache(w);
  }
  
  template <class T, bool CANCELLABLE>
! void ShenandoahConcurrentMark::mark_loop_work(T* cl, jushort* live_data, uint worker_id, TaskTerminator *terminator) {
    uintx stride = ShenandoahMarkLoopStride;
  
    ShenandoahHeap* heap = ShenandoahHeap::heap();
    ShenandoahObjToScanQueueSet* queues = task_queues();
    ShenandoahObjToScanQueue* q;