# HG changeset patch
# User jmasa
# Date 1463691590 25200
#      Thu May 19 13:59:50 2016 -0700
# Node ID 9d64057df144442164abbbe06c671fffc5286c95
# Parent  c31d418fc552c126515aab184025840544f7d8fe
8157240: GC task trace logging is incomprehensible
Reviewed-by: tschatzl

diff --git a/src/share/vm/gc/parallel/gcTaskManager.cpp b/src/share/vm/gc/parallel/gcTaskManager.cpp
--- a/src/share/vm/gc/parallel/gcTaskManager.cpp
+++ b/src/share/vm/gc/parallel/gcTaskManager.cpp
@@ -386,6 +386,8 @@
 
 void GCTaskManager::add_workers(bool initializing) {
   os::ThreadType worker_type = os::pgc_thread;
+  uint previous_created_workers = _created_workers;
+
   _created_workers = WorkerManager::add_workers(this,
                                                 _active_workers,
                                                 (uint) _workers,
@@ -393,6 +395,12 @@
                                                 worker_type,
                                                 initializing);
   _active_workers = MIN2(_created_workers, _active_workers);
+
+  WorkerManager::log_worker_creation(this, previous_created_workers, _active_workers, _created_workers, initializing);
+}
+
+const char* GCTaskManager::group_name() {
+  return GCTaskThread::task_name();
 }
 
 void GCTaskManager::initialize() {
diff --git a/src/share/vm/gc/parallel/gcTaskManager.hpp b/src/share/vm/gc/parallel/gcTaskManager.hpp
--- a/src/share/vm/gc/parallel/gcTaskManager.hpp
+++ b/src/share/vm/gc/parallel/gcTaskManager.hpp
@@ -556,6 +556,8 @@
   GCTaskThread* install_worker(uint worker_id);
   // Add GC workers as needed.
   void add_workers(bool initializing);
+  // Base name (without worker id #) of threads.
+  const char* group_name();
 };
 
 //
diff --git a/src/share/vm/gc/parallel/gcTaskThread.cpp b/src/share/vm/gc/parallel/gcTaskThread.cpp
--- a/src/share/vm/gc/parallel/gcTaskThread.cpp
+++ b/src/share/vm/gc/parallel/gcTaskThread.cpp
@@ -36,6 +36,8 @@
 #include "runtime/os.hpp"
 #include "runtime/thread.hpp"
 
+#define PARGCTHREAD "ParGC Thread"
+
 GCTaskThread::GCTaskThread(GCTaskManager* manager,
                            uint           which,
                            uint           processor_id) :
@@ -45,7 +47,7 @@
   _time_stamp_index(0)
 {
   set_id(which);
-  set_name("ParGC Thread#%d", which);
+  set_name(PARGCTHREAD "#%d", which);
 }
 
 GCTaskThread::~GCTaskThread() {
@@ -54,6 +56,8 @@
   }
 }
 
+const char* GCTaskThread::task_name() { return PARGCTHREAD; }
+
 GCTaskTimeStamp* GCTaskThread::time_stamp_at(uint index) {
   guarantee(index < GCTaskTimeStampEntries, "increase GCTaskTimeStampEntries");
   if (_time_stamps == NULL) {
diff --git a/src/share/vm/gc/parallel/gcTaskThread.hpp b/src/share/vm/gc/parallel/gcTaskThread.hpp
--- a/src/share/vm/gc/parallel/gcTaskThread.hpp
+++ b/src/share/vm/gc/parallel/gcTaskThread.hpp
@@ -55,6 +55,8 @@
     return new GCTaskThread(manager, which, processor_id);
   }
  public:
+  static const char* task_name();
+
   static void destroy(GCTaskThread* manager) {
     if (manager != NULL) {
       delete manager;
diff --git a/src/share/vm/gc/shared/workerManager.hpp b/src/share/vm/gc/shared/workerManager.hpp
--- a/src/share/vm/gc/shared/workerManager.hpp
+++ b/src/share/vm/gc/shared/workerManager.hpp
@@ -47,11 +47,11 @@
   // threads and a failure would not be optimal but should not be fatal.
   template <class WorkerType>
   static uint add_workers (WorkerType* holder,
-                   uint active_workers,
-                   uint total_workers,
-                   uint created_workers,
-                   os::ThreadType worker_type,
-                   bool initializing) {
+                           uint active_workers,
+                           uint total_workers,
+                           uint created_workers,
+                           os::ThreadType worker_type,
+                           bool initializing) {
     uint start = created_workers;
     uint end = MIN2(active_workers, total_workers);
     for (uint worker_id = start; worker_id < end; worker_id += 1) {
@@ -67,11 +67,21 @@
       os::start_thread(new_worker);
     }
 
-    log_trace(gc, task)("AdaptiveSizePolicy::add_workers() : "
-       "active_workers: %u created_workers: %u",
-       active_workers, created_workers);
+    return created_workers;
+  }
 
-    return created_workers;
+  // Log (at trace level) a change in the number of created workers.
+  template <class WorkerType>
+  static void log_worker_creation(WorkerType* holder,
+                                  uint previous_created_workers,
+                                  uint active_workers,
+                                  uint created_workers,
+                                  bool initializing) {
+    if (previous_created_workers < created_workers) {
+      const char* initializing_msg =  initializing ? "Adding initial" : "Creating additional";
+      log_trace(gc, task)("%s %s(s) active workers %u created workers %u",
+        initializing_msg, holder->group_name(), active_workers, created_workers);
+    }
   }
 };
 #endif // SHARE_VM_GC_SHARED_WORKERMANAGER_HPP
diff --git a/src/share/vm/gc/shared/workgroup.cpp b/src/share/vm/gc/shared/workgroup.cpp
--- a/src/share/vm/gc/shared/workgroup.cpp
+++ b/src/share/vm/gc/shared/workgroup.cpp
@@ -66,6 +66,7 @@
   } else {
     worker_type = os::pgc_thread;
   }
+  uint previous_created_workers = _created_workers;
 
   _created_workers = WorkerManager::add_workers(this,
                                                 active_workers,
@@ -74,6 +75,8 @@
                                                 worker_type,
                                                 initializing);
   _active_workers = MIN2(_created_workers, _active_workers);
+
+  WorkerManager::log_worker_creation(this, previous_created_workers, _active_workers, _created_workers, initializing);
 }
 
 AbstractGangWorker* AbstractWorkGang::worker(uint i) const {
diff --git a/src/share/vm/gc/shared/workgroup.hpp b/src/share/vm/gc/shared/workgroup.hpp
--- a/src/share/vm/gc/shared/workgroup.hpp
+++ b/src/share/vm/gc/shared/workgroup.hpp
@@ -176,6 +176,9 @@
   // Return the Ith worker.
   AbstractGangWorker* worker(uint i) const;
 
+  // Base name (without worker id #) of threads.
+  const char* group_name() { return name(); }
+
   void threads_do(ThreadClosure* tc) const;
 
   // Create a GC worker and install it into the work gang.
diff --git a/test/gc/ergonomics/TestInitialGCThreadLogging.java b/test/gc/ergonomics/TestInitialGCThreadLogging.java
new file mode 100644
--- /dev/null
+++ b/test/gc/ergonomics/TestInitialGCThreadLogging.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test TestInitialGCThreadLogging
+ * @bug 8157240
+ * @summary Check trace logging of initial GC threads.
+ * @requires vm.gc=="null"
+ * @key gc
+ * @modules java.base/jdk.internal.misc
+ * @library /testlibrary
+ */
+
+import jdk.test.lib.ProcessTools;
+import jdk.test.lib.OutputAnalyzer;
+
+public class TestInitialGCThreadLogging {
+  public static void main(String[] args) throws Exception {
+
+    testInitialGCThreadLogging("UseConcMarkSweepGC", "GC Thread");
+
+    testInitialGCThreadLogging("UseG1GC", "GC Thread");
+
+    testInitialGCThreadLogging("UseParallelGC", "ParGC Thread");
+  }
+
+  private static void verifyDynamicNumberOfGCThreads(OutputAnalyzer output, String threadName) {
+    output.shouldHaveExitValue(0); // test should run succesfully
+    output.shouldContain(threadName);
+  }
+
+  private static void testInitialGCThreadLogging(String gcFlag, String threadName) throws Exception {
+    // UseDynamicNumberOfGCThreads and TraceDynamicGCThreads enabled
+    String[] baseArgs = {"-XX:+" + gcFlag, "-Xmx10M", "-XX:+UseDynamicNumberOfGCThreads", "-Xlog:gc+task=trace", "-version"};
+
+    // Base test with gc and +UseDynamicNumberOfGCThreads:
+    ProcessBuilder pb_enabled = ProcessTools.createJavaProcessBuilder(baseArgs);
+    verifyDynamicNumberOfGCThreads(new OutputAnalyzer(pb_enabled.start()), threadName);
+  }
+}
# HG changeset patch
# User jmasa
# Date 1467951008 25200
#      Thu Jul 07 21:10:08 2016 -0700
# Node ID 7be879a1b8b6a47f609412a5317d0e89c42ae367
# Parent  9d64057df144442164abbbe06c671fffc5286c95
imported patch code_review2

diff --git a/src/share/vm/gc/parallel/gcTaskManager.cpp b/src/share/vm/gc/parallel/gcTaskManager.cpp
--- a/src/share/vm/gc/parallel/gcTaskManager.cpp
+++ b/src/share/vm/gc/parallel/gcTaskManager.cpp
@@ -390,7 +390,7 @@
 
   _created_workers = WorkerManager::add_workers(this,
                                                 _active_workers,
-                                                (uint) _workers,
+                                                _workers,
                                                 _created_workers,
                                                 worker_type,
                                                 initializing);
@@ -400,7 +400,7 @@
 }
 
 const char* GCTaskManager::group_name() {
-  return GCTaskThread::task_name();
+  return "ParGC Thread";
 }
 
 void GCTaskManager::initialize() {
diff --git a/src/share/vm/gc/parallel/gcTaskThread.cpp b/src/share/vm/gc/parallel/gcTaskThread.cpp
--- a/src/share/vm/gc/parallel/gcTaskThread.cpp
+++ b/src/share/vm/gc/parallel/gcTaskThread.cpp
@@ -36,8 +36,6 @@
 #include "runtime/os.hpp"
 #include "runtime/thread.hpp"
 
-#define PARGCTHREAD "ParGC Thread"
-
 GCTaskThread::GCTaskThread(GCTaskManager* manager,
                            uint           which,
                            uint           processor_id) :
@@ -47,7 +45,7 @@
   _time_stamp_index(0)
 {
   set_id(which);
-  set_name(PARGCTHREAD "#%d", which);
+  set_name("%s#%d", manager->group_name(), which);
 }
 
 GCTaskThread::~GCTaskThread() {
@@ -56,8 +54,6 @@
   }
 }
 
-const char* GCTaskThread::task_name() { return PARGCTHREAD; }
-
 GCTaskTimeStamp* GCTaskThread::time_stamp_at(uint index) {
   guarantee(index < GCTaskTimeStampEntries, "increase GCTaskTimeStampEntries");
   if (_time_stamps == NULL) {
diff --git a/src/share/vm/gc/parallel/gcTaskThread.hpp b/src/share/vm/gc/parallel/gcTaskThread.hpp
--- a/src/share/vm/gc/parallel/gcTaskThread.hpp
+++ b/src/share/vm/gc/parallel/gcTaskThread.hpp
@@ -55,7 +55,6 @@
     return new GCTaskThread(manager, which, processor_id);
   }
  public:
-  static const char* task_name();
 
   static void destroy(GCTaskThread* manager) {
     if (manager != NULL) {
diff --git a/src/share/vm/gc/shared/workerManager.hpp b/src/share/vm/gc/shared/workerManager.hpp
--- a/src/share/vm/gc/shared/workerManager.hpp
+++ b/src/share/vm/gc/shared/workerManager.hpp
@@ -58,7 +58,7 @@
       WorkerThread* new_worker = holder->install_worker(worker_id);
       assert(new_worker != NULL, "Failed to allocate GangWorker");
       if (new_worker == NULL || !os::create_thread(new_worker, worker_type)) {
-        if(initializing) {
+        if (initializing) {
           vm_exit_out_of_memory(0, OOM_MALLOC_ERROR,
                   "Cannot create worker GC thread. Out of system resources.");
         }
@@ -79,8 +79,8 @@
                                   bool initializing) {
     if (previous_created_workers < created_workers) {
       const char* initializing_msg =  initializing ? "Adding initial" : "Creating additional";
-      log_trace(gc, task)("%s %s(s) active workers %u created workers %u",
-        initializing_msg, holder->group_name(), active_workers, created_workers);
+      log_trace(gc, task)("%s %s(s) previously created workers %u active workers %u total created workers %u",
+                          initializing_msg, holder->group_name(), previous_created_workers, active_workers, created_workers);
     }
   }
 };