< prev index next >

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

Print this page

        

@@ -30,10 +30,11 @@
 #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,12 +51,10 @@
 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);

@@ -78,13 +77,10 @@
 }
 
 
 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);
 

@@ -149,15 +145,11 @@
 //
 
 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* 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,15 +198,11 @@
   _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* cm = ParCompactionManager::gc_thread_compaction_manager(which);
   ParCompactionManager::MarkAndPushClosure mark_and_push_closure(cm);
 
   oop obj = NULL;
   ObjArrayTask task;
   int random_seed = 17;

@@ -238,16 +226,11 @@
   _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);
-
+  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,18 +244,10 @@
     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?
 

@@ -304,31 +279,21 @@
                                    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);
+  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);
+  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,18 +304,10 @@
   } 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();

@@ -362,16 +319,9 @@
     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);
   }
 }
< prev index next >