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

*** 30,39 ****
--- 30,40 ----
  #include "gc/parallel/psCompactionManager.inline.hpp"
  #include "gc/parallel/psParallelCompact.hpp"
  #include "gc/shared/collectedHeap.hpp"
  #include "gc/shared/gcTimer.hpp"
  #include "gc/shared/gcTraceTime.hpp"
+ #include "logging/log.hpp"
  #include "memory/universe.hpp"
  #include "oops/objArrayKlass.inline.hpp"
  #include "oops/oop.inline.hpp"
  #include "prims/jvmtiExport.hpp"
  #include "runtime/fprofiler.hpp"
*** 50,61 ****
  void ThreadRootsMarkingTask::do_it(GCTaskManager* manager, uint which) {
    assert(ParallelScavengeHeap::heap()->is_gc_active(), "called outside gc");
  
    ResourceMark rm;
  
-   NOT_PRODUCT(GCTraceTime tm("ThreadRootsMarkingTask",
-     PrintGCDetails && TraceParallelOldGCTasks, true, NULL));
    ParCompactionManager* cm =
      ParCompactionManager::gc_thread_compaction_manager(which);
  
    ParCompactionManager::MarkAndPushClosure mark_and_push_closure(cm);
    CLDToOopClosure mark_and_push_from_clds(&mark_and_push_closure, true);
--- 51,60 ----
*** 78,90 ****
  }
  
  
  void MarkFromRootsTask::do_it(GCTaskManager* manager, uint which) {
    assert(ParallelScavengeHeap::heap()->is_gc_active(), "called outside gc");
- 
-   NOT_PRODUCT(GCTraceTime tm("MarkFromRootsTask",
-     PrintGCDetails && TraceParallelOldGCTasks, true, NULL));
    ParCompactionManager* cm =
      ParCompactionManager::gc_thread_compaction_manager(which);
    ParCompactionManager::MarkAndPushClosure mark_and_push_closure(cm);
    ParCompactionManager::FollowKlassClosure follow_klass_closure(&mark_and_push_closure);
  
--- 77,86 ----
*** 149,163 ****
  //
  
  void RefProcTaskProxy::do_it(GCTaskManager* manager, uint which)
  {
    assert(ParallelScavengeHeap::heap()->is_gc_active(), "called outside gc");
! 
!   NOT_PRODUCT(GCTraceTime tm("RefProcTask",
!     PrintGCDetails && TraceParallelOldGCTasks, true, NULL));
!   ParCompactionManager* cm =
!     ParCompactionManager::gc_thread_compaction_manager(which);
    ParCompactionManager::MarkAndPushClosure mark_and_push_closure(cm);
    ParCompactionManager::FollowStackClosure follow_stack_closure(cm);
    _rp_task.work(_work_id, *PSParallelCompact::is_alive_closure(),
                  mark_and_push_closure, follow_stack_closure);
  }
--- 145,155 ----
  //
  
  void RefProcTaskProxy::do_it(GCTaskManager* manager, uint which)
  {
    assert(ParallelScavengeHeap::heap()->is_gc_active(), "called outside gc");
!   ParCompactionManager* cm = ParCompactionManager::gc_thread_compaction_manager(which);
    ParCompactionManager::MarkAndPushClosure mark_and_push_closure(cm);
    ParCompactionManager::FollowStackClosure follow_stack_closure(cm);
    _rp_task.work(_work_id, *PSParallelCompact::is_alive_closure(),
                  mark_and_push_closure, follow_stack_closure);
  }
*** 206,220 ****
    _terminator(t) {}
  
  void StealMarkingTask::do_it(GCTaskManager* manager, uint which) {
    assert(ParallelScavengeHeap::heap()->is_gc_active(), "called outside gc");
  
!   NOT_PRODUCT(GCTraceTime tm("StealMarkingTask",
!     PrintGCDetails && TraceParallelOldGCTasks, true, NULL));
! 
!   ParCompactionManager* cm =
!     ParCompactionManager::gc_thread_compaction_manager(which);
    ParCompactionManager::MarkAndPushClosure mark_and_push_closure(cm);
  
    oop obj = NULL;
    ObjArrayTask task;
    int random_seed = 17;
--- 198,208 ----
    _terminator(t) {}
  
  void StealMarkingTask::do_it(GCTaskManager* manager, uint which) {
    assert(ParallelScavengeHeap::heap()->is_gc_active(), "called outside gc");
  
!   ParCompactionManager* cm = ParCompactionManager::gc_thread_compaction_manager(which);
    ParCompactionManager::MarkAndPushClosure mark_and_push_closure(cm);
  
    oop obj = NULL;
    ObjArrayTask task;
    int random_seed = 17;
*** 238,253 ****
    _terminator(t) {}
  
  void StealRegionCompactionTask::do_it(GCTaskManager* manager, uint which) {
    assert(ParallelScavengeHeap::heap()->is_gc_active(), "called outside gc");
  
!   NOT_PRODUCT(GCTraceTime tm("StealRegionCompactionTask",
!     PrintGCDetails && TraceParallelOldGCTasks, true, NULL));
! 
!   ParCompactionManager* cm =
!     ParCompactionManager::gc_thread_compaction_manager(which);
! 
  
    // If not all threads are active, get a draining stack
    // from the list.  Else, just use this threads draining stack.
    uint which_stack_index;
    bool use_all_workers = manager->all_workers_active();
--- 226,236 ----
    _terminator(t) {}
  
  void StealRegionCompactionTask::do_it(GCTaskManager* manager, uint which) {
    assert(ParallelScavengeHeap::heap()->is_gc_active(), "called outside gc");
  
!   ParCompactionManager* cm =  ParCompactionManager::gc_thread_compaction_manager(which);
  
    // If not all threads are active, get a draining stack
    // from the list.  Else, just use this threads draining stack.
    uint which_stack_index;
    bool use_all_workers = manager->all_workers_active();
*** 261,278 ****
      which_stack_index = ParCompactionManager::pop_recycled_stack_index();
    }
  
    cm->set_region_stack_index(which_stack_index);
    cm->set_region_stack(ParCompactionManager::region_list(which_stack_index));
-   if (TraceDynamicGCThreads) {
-     gclog_or_tty->print_cr("StealRegionCompactionTask::do_it "
-                            "region_stack_index %d region_stack = " PTR_FORMAT " "
-                            " empty (%d) use all workers %d",
-     which_stack_index, p2i(ParCompactionManager::region_list(which_stack_index)),
-     cm->region_stack()->is_empty(),
-     use_all_workers);
-   }
  
    // Has to drain stacks first because there may be regions on
    // preloaded onto the stack and this thread may never have
    // done a draining task.  Are the draining tasks needed?
  
--- 244,253 ----
*** 304,334 ****
                                     size_t region_index_end) :
    _space_id(space_id), _region_index_start(region_index_start),
    _region_index_end(region_index_end) {}
  
  void UpdateDensePrefixTask::do_it(GCTaskManager* manager, uint which) {
! 
!   NOT_PRODUCT(GCTraceTime tm("UpdateDensePrefixTask",
!     PrintGCDetails && TraceParallelOldGCTasks, true, NULL));
! 
!   ParCompactionManager* cm =
!     ParCompactionManager::gc_thread_compaction_manager(which);
  
    PSParallelCompact::update_and_deadwood_in_dense_prefix(cm,
                                                           _space_id,
                                                           _region_index_start,
                                                           _region_index_end);
  }
  
  void DrainStacksCompactionTask::do_it(GCTaskManager* manager, uint which) {
    assert(ParallelScavengeHeap::heap()->is_gc_active(), "called outside gc");
! 
!   NOT_PRODUCT(GCTraceTime tm("DrainStacksCompactionTask",
!     PrintGCDetails && TraceParallelOldGCTasks, true, NULL));
! 
!   ParCompactionManager* cm =
!     ParCompactionManager::gc_thread_compaction_manager(which);
  
    uint which_stack_index;
    bool use_all_workers = manager->all_workers_active();
    if (use_all_workers) {
      which_stack_index = which;
--- 279,299 ----
                                     size_t region_index_end) :
    _space_id(space_id), _region_index_start(region_index_start),
    _region_index_end(region_index_end) {}
  
  void UpdateDensePrefixTask::do_it(GCTaskManager* manager, uint which) {
!   ParCompactionManager* cm = ParCompactionManager::gc_thread_compaction_manager(which);
  
    PSParallelCompact::update_and_deadwood_in_dense_prefix(cm,
                                                           _space_id,
                                                           _region_index_start,
                                                           _region_index_end);
  }
  
  void DrainStacksCompactionTask::do_it(GCTaskManager* manager, uint which) {
    assert(ParallelScavengeHeap::heap()->is_gc_active(), "called outside gc");
!   ParCompactionManager* cm =  ParCompactionManager::gc_thread_compaction_manager(which);
  
    uint which_stack_index;
    bool use_all_workers = manager->all_workers_active();
    if (use_all_workers) {
      which_stack_index = which;
*** 339,356 ****
    } else {
      which_stack_index = stack_index();
    }
  
    cm->set_region_stack(ParCompactionManager::region_list(which_stack_index));
-   if (TraceDynamicGCThreads) {
-     gclog_or_tty->print_cr("DrainStacksCompactionTask::do_it which = %d "
-                            "which_stack_index = %d/empty(%d) "
-                            "use all workers %d",
-                            which, which_stack_index,
-                            cm->region_stack()->is_empty(),
-                            use_all_workers);
-   }
  
    cm->set_region_stack_index(which_stack_index);
  
    // Process any regions already in the compaction managers stacks.
    cm->drain_region_stacks();
--- 304,313 ----
*** 362,377 ****
      assert(cm->region_stack() ==
             ParCompactionManager::region_list(cm->region_stack_index()),
             "region_stack and region_stack_index are inconsistent");
      ParCompactionManager::push_recycled_stack_index(cm->region_stack_index());
  
-     if (TraceDynamicGCThreads) {
-       void* old_region_stack = (void*) cm->region_stack();
-       int old_region_stack_index = cm->region_stack_index();
-       gclog_or_tty->print_cr("Pushing region stack " PTR_FORMAT "/%d",
-         p2i(old_region_stack), old_region_stack_index);
-     }
- 
      cm->set_region_stack(NULL);
      cm->set_region_stack_index((uint)max_uintx);
    }
  }
--- 319,327 ----