< prev index next >

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

Print this page

        

@@ -28,10 +28,11 @@
 #include "gc/parallel/psMarkSweepDecorator.hpp"
 #include "gc/parallel/psScavenge.hpp"
 #include "gc/parallel/psYoungGen.hpp"
 #include "gc/shared/gcUtil.hpp"
 #include "gc/shared/spaceDecorator.hpp"
+#include "logging/log.hpp"
 #include "oops/oop.inline.hpp"
 #include "runtime/java.hpp"
 
 PSYoungGen::PSYoungGen(size_t        initial_size,
                        size_t        min_size,

@@ -266,19 +267,17 @@
     // Then we lay out the spaces inside the generation
     resize_spaces(eden_size, survivor_size);
 
     space_invariants();
 
-    if (PrintAdaptiveSizePolicy && Verbose) {
-      gclog_or_tty->print_cr("Young generation size: "
+    log_trace(gc, ergo)("Young generation size: "
         "desired eden: " SIZE_FORMAT " survivor: " SIZE_FORMAT
         " used: " SIZE_FORMAT " capacity: " SIZE_FORMAT
         " gen limits: " SIZE_FORMAT " / " SIZE_FORMAT,
         eden_size, survivor_size, used_in_bytes(), capacity_in_bytes(),
         _max_gen_size, min_gen_size());
     }
-  }
 }
 
 
 bool PSYoungGen::resize_generation(size_t eden_size, size_t survivor_size) {
   const size_t alignment = virtual_space()->alignment();

@@ -328,30 +327,21 @@
       reset_survivors_after_shrink();
 
       size_changed = true;
     }
   } else {
-    if (Verbose && PrintGC) {
       if (orig_size == gen_size_limit()) {
-        gclog_or_tty->print_cr("PSYoung generation size at maximum: "
-          SIZE_FORMAT "K", orig_size/K);
+      log_trace(gc)("PSYoung generation size at maximum: " SIZE_FORMAT "K", orig_size/K);
       } else if (orig_size == min_gen_size()) {
-        gclog_or_tty->print_cr("PSYoung generation size at minium: "
-          SIZE_FORMAT "K", orig_size/K);
-      }
+      log_trace(gc)("PSYoung generation size at minium: " SIZE_FORMAT "K", orig_size/K);
     }
   }
 
   if (size_changed) {
     post_resize();
-
-    if (Verbose && PrintGC) {
-      size_t current_size  = virtual_space()->committed_size();
-      gclog_or_tty->print_cr("PSYoung generation size changed: "
-                             SIZE_FORMAT "K->" SIZE_FORMAT "K",
-                             orig_size/K, current_size/K);
-    }
+    log_trace(gc)("PSYoung generation size changed: " SIZE_FORMAT "K->" SIZE_FORMAT "K",
+                  orig_size/K, virtual_space()->committed_size()/K);
   }
 
   guarantee(eden_plus_survivors <= virtual_space()->committed_size() ||
             virtual_space()->committed_size() == max_size(), "Sanity");
 

@@ -410,32 +400,29 @@
   MemRegion delta2_right;
   if (delta_start < s2MR.end()) {
     s2->mangle_region(delta2_right);
   }
 
-  if (TraceZapUnusedHeapArea) {
     // s1
-    gclog_or_tty->print_cr("Current region: [" PTR_FORMAT ", " PTR_FORMAT ") "
+  log_develop_trace(gc)("Current region: [" PTR_FORMAT ", " PTR_FORMAT ") "
       "New region: [" PTR_FORMAT ", " PTR_FORMAT ")",
       p2i(s1->bottom()), p2i(s1->end()),
       p2i(s1MR.start()), p2i(s1MR.end()));
-    gclog_or_tty->print_cr("    Mangle before: [" PTR_FORMAT ", "
+  log_develop_trace(gc)("    Mangle before: [" PTR_FORMAT ", "
       PTR_FORMAT ")  Mangle after: [" PTR_FORMAT ", " PTR_FORMAT ")",
       p2i(delta1_left.start()), p2i(delta1_left.end()),
       p2i(delta1_right.start()), p2i(delta1_right.end()));
 
     // s2
-    gclog_or_tty->print_cr("Current region: [" PTR_FORMAT ", " PTR_FORMAT ") "
+  log_develop_trace(gc)("Current region: [" PTR_FORMAT ", " PTR_FORMAT ") "
       "New region: [" PTR_FORMAT ", " PTR_FORMAT ")",
       p2i(s2->bottom()), p2i(s2->end()),
       p2i(s2MR.start()), p2i(s2MR.end()));
-    gclog_or_tty->print_cr("    Mangle before: [" PTR_FORMAT ", "
+  log_develop_trace(gc)("    Mangle before: [" PTR_FORMAT ", "
       PTR_FORMAT ")  Mangle after: [" PTR_FORMAT ", " PTR_FORMAT ")",
       p2i(delta2_left.start()), p2i(delta2_left.end()),
       p2i(delta2_right.start()), p2i(delta2_right.end()));
-  }
-
 }
 #endif // NOT PRODUCT
 
 void PSYoungGen::resize_spaces(size_t requested_eden_size,
                                size_t requested_survivor_size) {

@@ -446,45 +433,36 @@
   // We require eden and to space to be empty
   if ((!eden_space()->is_empty()) || (!to_space()->is_empty())) {
     return;
   }
 
-  if (PrintAdaptiveSizePolicy && Verbose) {
-    gclog_or_tty->print_cr("PSYoungGen::resize_spaces(requested_eden_size: "
-                  SIZE_FORMAT
-                  ", requested_survivor_size: " SIZE_FORMAT ")",
+  log_trace(gc, ergo)("PSYoungGen::resize_spaces(requested_eden_size: " SIZE_FORMAT ", requested_survivor_size: " SIZE_FORMAT ")",
                   requested_eden_size, requested_survivor_size);
-    gclog_or_tty->print_cr("    eden: [" PTR_FORMAT ".." PTR_FORMAT ") "
-                  SIZE_FORMAT,
+  log_trace(gc, ergo)("    eden: [" PTR_FORMAT ".." PTR_FORMAT ") " SIZE_FORMAT,
                   p2i(eden_space()->bottom()),
                   p2i(eden_space()->end()),
                   pointer_delta(eden_space()->end(),
                                 eden_space()->bottom(),
                                 sizeof(char)));
-    gclog_or_tty->print_cr("    from: [" PTR_FORMAT ".." PTR_FORMAT ") "
-                  SIZE_FORMAT,
+  log_trace(gc, ergo)("    from: [" PTR_FORMAT ".." PTR_FORMAT ") " SIZE_FORMAT,
                   p2i(from_space()->bottom()),
                   p2i(from_space()->end()),
                   pointer_delta(from_space()->end(),
                                 from_space()->bottom(),
                                 sizeof(char)));
-    gclog_or_tty->print_cr("      to: [" PTR_FORMAT ".." PTR_FORMAT ") "
-                  SIZE_FORMAT,
+  log_trace(gc, ergo)("      to: [" PTR_FORMAT ".." PTR_FORMAT ") " SIZE_FORMAT,
                   p2i(to_space()->bottom()),
                   p2i(to_space()->end()),
                   pointer_delta(  to_space()->end(),
                                   to_space()->bottom(),
                                   sizeof(char)));
-  }
 
   // There's nothing to do if the new sizes are the same as the current
   if (requested_survivor_size == to_space()->capacity_in_bytes() &&
       requested_survivor_size == from_space()->capacity_in_bytes() &&
       requested_eden_size == eden_space()->capacity_in_bytes()) {
-    if (PrintAdaptiveSizePolicy && Verbose) {
-      gclog_or_tty->print_cr("    capacities are the right sizes, returning");
-    }
+    log_trace(gc, ergo)("    capacities are the right sizes, returning");
     return;
   }
 
   char* eden_start = (char*)eden_space()->bottom();
   char* eden_end   = (char*)eden_space()->end();

@@ -501,13 +479,11 @@
   bool eden_from_to_order = from_start < to_start;
   // Check whether from space is below to space
   if (eden_from_to_order) {
     // Eden, from, to
     eden_from_to_order = true;
-    if (PrintAdaptiveSizePolicy && Verbose) {
-      gclog_or_tty->print_cr("  Eden, from, to:");
-    }
+    log_trace(gc, ergo)("  Eden, from, to:");
 
     // Set eden
     // "requested_eden_size" is a goal for the size of eden
     // and may not be attainable.  "eden_size" below is
     // calculated based on the location of from-space and

@@ -564,32 +540,25 @@
       to_start = MAX2(from_end, to_start);
     }
 
     guarantee(to_start != to_end, "to space is zero sized");
 
-    if (PrintAdaptiveSizePolicy && Verbose) {
-      gclog_or_tty->print_cr("    [eden_start .. eden_end): "
-                    "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
+    log_trace(gc, ergo)("    [eden_start .. eden_end): [" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
                     p2i(eden_start),
                     p2i(eden_end),
                     pointer_delta(eden_end, eden_start, sizeof(char)));
-      gclog_or_tty->print_cr("    [from_start .. from_end): "
-                    "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
+    log_trace(gc, ergo)("    [from_start .. from_end): [" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
                     p2i(from_start),
                     p2i(from_end),
                     pointer_delta(from_end, from_start, sizeof(char)));
-      gclog_or_tty->print_cr("    [  to_start ..   to_end): "
-                    "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
+    log_trace(gc, ergo)("    [  to_start ..   to_end): [" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
                     p2i(to_start),
                     p2i(to_end),
                     pointer_delta(  to_end,   to_start, sizeof(char)));
-    }
   } else {
     // Eden, to, from
-    if (PrintAdaptiveSizePolicy && Verbose) {
-      gclog_or_tty->print_cr("  Eden, to, from:");
-    }
+    log_trace(gc, ergo)("  Eden, to, from:");
 
     // To space gets priority over eden resizing. Note that we position
     // to space as if we were able to resize from space, even though from
     // space is not modified.
     // Giving eden priority was tried and gave poorer performance.

@@ -621,28 +590,23 @@
 
     // Don't let eden shrink down to 0 or less.
     eden_end = MAX2(eden_end, eden_start + alignment);
     to_start = MAX2(to_start, eden_end);
 
-    if (PrintAdaptiveSizePolicy && Verbose) {
-      gclog_or_tty->print_cr("    [eden_start .. eden_end): "
-                    "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
+    log_trace(gc, ergo)("    [eden_start .. eden_end): [" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
                     p2i(eden_start),
                     p2i(eden_end),
                     pointer_delta(eden_end, eden_start, sizeof(char)));
-      gclog_or_tty->print_cr("    [  to_start ..   to_end): "
-                    "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
+    log_trace(gc, ergo)("    [  to_start ..   to_end): [" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
                     p2i(to_start),
                     p2i(to_end),
                     pointer_delta(  to_end,   to_start, sizeof(char)));
-      gclog_or_tty->print_cr("    [from_start .. from_end): "
-                    "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
+    log_trace(gc, ergo)("    [from_start .. from_end): [" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
                     p2i(from_start),
                     p2i(from_end),
                     pointer_delta(from_end, from_start, sizeof(char)));
     }
-  }
 
 
   guarantee((HeapWord*)from_start <= from_space()->bottom(),
             "from start moved to the right");
   guarantee((HeapWord*)from_end >= from_space()->top(),

@@ -656,11 +620,11 @@
   MemRegion fromMR((HeapWord*)from_start, (HeapWord*)from_end);
 
   // Let's make sure the call to initialize doesn't reset "top"!
   HeapWord* old_from_top = from_space()->top();
 
-  // For PrintAdaptiveSizePolicy block  below
+  // For logging block  below
   size_t old_from = from_space()->capacity_in_bytes();
   size_t old_to   = to_space()->capacity_in_bytes();
 
   if (ZapUnusedHeapArea) {
     // NUMA is a special case because a numa space is not mangled

@@ -702,22 +666,15 @@
                            SpaceDecorator::DontClear,
                            SpaceDecorator::DontMangle);
 
   assert(from_space()->top() == old_from_top, "from top changed!");
 
-  if (PrintAdaptiveSizePolicy) {
-    ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
-    gclog_or_tty->print("AdaptiveSizePolicy::survivor space sizes: "
-                  "collection: %d "
-                  "(" SIZE_FORMAT ", " SIZE_FORMAT ") -> "
-                  "(" SIZE_FORMAT ", " SIZE_FORMAT ") ",
-                  heap->total_collections(),
+  log_trace(gc, ergo)("AdaptiveSizePolicy::survivor space sizes: collection: %d (" SIZE_FORMAT ", " SIZE_FORMAT ") -> (" SIZE_FORMAT ", " SIZE_FORMAT ") ",
+                      ParallelScavengeHeap::heap()->total_collections(),
                   old_from, old_to,
                   from_space()->capacity_in_bytes(),
                   to_space()->capacity_in_bytes());
-    gclog_or_tty->cr();
-  }
 }
 
 void PSYoungGen::swap_spaces() {
   MutableSpace* s    = from_space();
   _from_space        = to_space();

@@ -792,32 +749,22 @@
 }
 
 void PSYoungGen::print() const { print_on(tty); }
 void PSYoungGen::print_on(outputStream* st) const {
   st->print(" %-15s", "PSYoungGen");
-  if (PrintGCDetails && Verbose) {
-    st->print(" total " SIZE_FORMAT ", used " SIZE_FORMAT,
-               capacity_in_bytes(), used_in_bytes());
-  } else {
     st->print(" total " SIZE_FORMAT "K, used " SIZE_FORMAT "K",
                capacity_in_bytes()/K, used_in_bytes()/K);
-  }
   virtual_space()->print_space_boundaries_on(st);
   st->print("  eden"); eden_space()->print_on(st);
   st->print("  from"); from_space()->print_on(st);
   st->print("  to  "); to_space()->print_on(st);
 }
 
 // Note that a space is not printed before the [NAME:
 void PSYoungGen::print_used_change(size_t prev_used) const {
-  gclog_or_tty->print("[%s:", name());
-  gclog_or_tty->print(" "  SIZE_FORMAT "K"
-                      "->" SIZE_FORMAT "K"
-                      "("  SIZE_FORMAT "K)",
-                      prev_used / K, used_in_bytes() / K,
-                      capacity_in_bytes() / K);
-  gclog_or_tty->print("]");
+  log_info(gc, heap)("%s: "  SIZE_FORMAT "K->" SIZE_FORMAT "K("  SIZE_FORMAT "K)",
+      name(), prev_used / K, used_in_bytes() / K, capacity_in_bytes() / K);
 }
 
 size_t PSYoungGen::available_for_expansion() {
   ShouldNotReachHere();
   return 0;
< prev index next >