test/runtime/Thread/TestThreadDumpMonitorContention.java - platform/external/jetbrains/jdk8u_hotspot - Git at Google

 /*
  * Copyright (c) 2014, 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
  * @bug     8036823
  * @bug     8046287
  * @summary Creates two threads contending for the same lock and checks
  *      whether jstack reports "locked" by more than one thread.
  *
  * @library /testlibrary
  * @run main/othervm TestThreadDumpMonitorContention
  */

 import java.io.BufferedReader;
 import java.io.InputStreamReader;
 import java.lang.management.ManagementFactory;
 import java.lang.management.RuntimeMXBean;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 import com.oracle.java.testlibrary.*;

 public class TestThreadDumpMonitorContention {
     // jstack tends to be closely bound to the VM that we are running
     // so use getTestJDKTool() instead of getCompileJDKTool() or even
     // getJDKTool() which can fall back to "compile.jdk".
     final static String JSTACK = JDKToolFinder.getTestJDKTool("jstack");
     final static String PID = getPid();

     // looking for header lines with these patterns:
     // "ContendingThread-1" #19 prio=5 os_prio=64 tid=0x000000000079c000 nid=0x23 runnable [0xffff80ffb8b87000]
     // "ContendingThread-2" #21 prio=5 os_prio=64 tid=0x0000000000780000 nid=0x2f waiting for monitor entry [0xfffffd7fc1111000]
     // "ContendingThread-2" #24 prio=5 os_prio=64 tid=0x0000000000ec8800 nid=0x31 waiting on condition [0xfffffd7bbfffe000]
     final static Pattern HEADER_PREFIX_PATTERN = Pattern.compile(
         "^\"ContendingThread-.*");
     final static Pattern HEADER_WAITING_PATTERN1 = Pattern.compile(
         "^\"ContendingThread-.* waiting for monitor entry .*");
     final static Pattern HEADER_WAITING_PATTERN2 = Pattern.compile(
         "^\"ContendingThread-.* waiting on condition .*");
     final static Pattern HEADER_RUNNABLE_PATTERN = Pattern.compile(
         "^\"ContendingThread-.* runnable .*");

     // looking for thread state lines with these patterns:
     // java.lang.Thread.State: RUNNABLE
     // java.lang.Thread.State: BLOCKED (on object monitor)
     final static Pattern THREAD_STATE_PREFIX_PATTERN = Pattern.compile(
         " *java\\.lang\\.Thread\\.State: .*");
     final static Pattern THREAD_STATE_BLOCKED_PATTERN = Pattern.compile(
         " *java\\.lang\\.Thread\\.State: BLOCKED \\(on object monitor\\)");
     final static Pattern THREAD_STATE_RUNNABLE_PATTERN = Pattern.compile(
         " *java\\.lang\\.Thread\\.State: RUNNABLE");

     // looking for duplicates of this pattern:
     // - locked <0x000000076ac59e20> (a TestThreadDumpMonitorContention$1)
     final static Pattern LOCK_PATTERN = Pattern.compile(
         ".* locked \\<.*\\(a TestThreadDumpMonitorContention.*");

     // sanity checking header and thread state lines associated
     // with this pattern:
     // - waiting to lock <0x000000076ac59e20> (a TestThreadDumpMonitorContention$1)
     final static Pattern WAITING_PATTERN = Pattern.compile(
         ".* waiting to lock \\<.*\\(a TestThreadDumpMonitorContention.*");

     final static Object barrier = new Object();
     volatile static boolean done = false;

     static int barrier_cnt = 0;
     static int blank_line_match_cnt = 0;
     static int error_cnt = 0;
     static boolean have_header_line = false;
     static boolean have_thread_state_line = false;
     static String header_line = null;
     static int header_prefix_match_cnt = 0;
     static int locked_line_match_cnt = 0;
     static String[] locked_match_list = new String[2];
     static int n_samples = 15;
     static int sum_both_running_cnt = 0;
     static int sum_both_waiting_cnt = 0;
     static int sum_contended_cnt = 0;
     static int sum_locked_hdr_runnable_cnt = 0;
     static int sum_locked_hdr_waiting1_cnt = 0;
     static int sum_locked_hdr_waiting2_cnt = 0;
     static int sum_locked_thr_state_blocked_cnt = 0;
     static int sum_locked_thr_state_runnable_cnt = 0;
     static int sum_one_waiting_cnt = 0;
     static int sum_uncontended_cnt = 0;
     static int sum_waiting_hdr_waiting1_cnt = 0;
     static int sum_waiting_thr_state_blocked_cnt = 0;
     static String thread_state_line = null;
     static boolean verbose = false;
     static int waiting_line_match_cnt = 0;

     public static void main(String[] args) throws Exception {
         if (args.length != 0) {
             int arg_i = 0;
             if (args[arg_i].equals("-v")) {
                 verbose = true;
                 arg_i++;
             }

             try {
                 n_samples = Integer.parseInt(args[arg_i]);
             } catch (NumberFormatException nfe) {
                 System.err.println(nfe);
                 usage();
             }
         }

         Runnable runnable = new Runnable() {
             public void run() {
                 synchronized (barrier) {
                     // let the main thread know we're running
                     barrier_cnt++;
                     barrier.notify();
                 }
                 while (!done) {
                     synchronized (this) { }
                 }
             }
         };
         Thread[] thread_list = new Thread[2];
         thread_list[0] = new Thread(runnable, "ContendingThread-1");
         thread_list[1] = new Thread(runnable, "ContendingThread-2");
         synchronized (barrier) {
             thread_list[0].start();
             thread_list[1].start();

             // Wait until the contending threads are running so that
             // we don't sample any thread init states.
             while (barrier_cnt < 2) {
                 barrier.wait();
             }
         }

         doSamples();

         done = true;

         thread_list[0].join();
         thread_list[1].join();

         if (error_cnt == 0) {
             System.out.println("Test PASSED.");
         } else {
             System.out.println("Test FAILED.");
             throw new AssertionError("error_cnt=" + error_cnt);
         }
     }

     // Reached a blank line which is the end of the
     // stack trace without matching either LOCK_PATTERN
     // or WAITING_PATTERN. Rare, but it's not an error.
     //
     // Example:
     // "ContendingThread-1" #21 prio=5 os_prio=64 tid=0x00000000007b9000 nid=0x2f runnable [0xfffffd7fc1111000]
     //    java.lang.Thread.State: RUNNABLE
     //         at TestThreadDumpMonitorContention$1.run(TestThreadDumpMonitorContention.java:140)
     //         at java.lang.Thread.run(Thread.java:745)
     //
     static boolean checkBlankLine(String line) {
         if (line.length() == 0) {
             blank_line_match_cnt++;
             have_header_line = false;
             have_thread_state_line = false;
             return true;
         }

         return false;
     }

     // Process the locked line here if we found one.
     //
     // Example 1:
     // "ContendingThread-1" #21 prio=5 os_prio=64 tid=0x00000000007b9000 nid=0x2f runnable [0xfffffd7fc1111000]
     //    java.lang.Thread.State: RUNNABLE
     //         at TestThreadDumpMonitorContention$1.run(TestThreadDumpMonitorContention.java:140)
     //         - locked <0xfffffd7e6a2912f8> (a TestThreadDumpMonitorContention$1)
     //         at java.lang.Thread.run(Thread.java:745)
     //
     // Example 2:
     // "ContendingThread-1" #21 prio=5 os_prio=64 tid=0x00000000007b9000 nid=0x2f waiting for monitor entry [0xfffffd7fc1111000]
     //    java.lang.Thread.State: BLOCKED (on object monitor)
     //         at TestThreadDumpMonitorContention$1.run(TestThreadDumpMonitorContention.java:140)
     //         - locked <0xfffffd7e6a2912f8> (a TestThreadDumpMonitorContention$1)
     //         at java.lang.Thread.run(Thread.java:745)
     //
     // Example 3:
     // "ContendingThread-2" #24 prio=5 os_prio=64 tid=0x0000000000ec8800 nid=0x31 waiting on condition [0xfffffd7bbfffe000]
     //    java.lang.Thread.State: RUNNABLE
     //    JavaThread state: _thread_blocked
     // Thread: 0x0000000000ec8800  [0x31] State: _at_safepoint _has_called_back 0 _at_poll_safepoint 0
     //    JavaThread state: _thread_blocked
     //         at TestThreadDumpMonitorContention$1.run(TestThreadDumpMonitorContention.java:140)
     //         - locked <0xfffffd7e6d03eb28> (a TestThreadDumpMonitorContention$1)
     //         at java.lang.Thread.run(Thread.java:745)
     //
     static boolean checkLockedLine(String line) {
         Matcher matcher = LOCK_PATTERN.matcher(line);
         if (matcher.matches()) {
             if (verbose) {
                 System.out.println("locked_line='" + line + "'");
             }
             locked_match_list[locked_line_match_cnt] = new String(line);
             locked_line_match_cnt++;

             matcher = HEADER_RUNNABLE_PATTERN.matcher(header_line);
             if (matcher.matches()) {
                 sum_locked_hdr_runnable_cnt++;
             } else {
                 // It's strange, but a locked line can also
                 // match the HEADER_WAITING_PATTERN{1,2}.
                 matcher = HEADER_WAITING_PATTERN1.matcher(header_line);
                 if (matcher.matches()) {
                     sum_locked_hdr_waiting1_cnt++;
                 } else {
                     matcher = HEADER_WAITING_PATTERN2.matcher(header_line);
                     if (matcher.matches()) {
                         sum_locked_hdr_waiting2_cnt++;
                     } else {
                         System.err.println();
                         System.err.println("ERROR: header line does " +
                             "not match runnable or waiting patterns.");
                         System.err.println("ERROR: header_line='" +
                             header_line + "'");
                         System.err.println("ERROR: locked_line='" + line +
                             "'");
                         error_cnt++;
                     }
                 }
             }

             matcher = THREAD_STATE_RUNNABLE_PATTERN.matcher(thread_state_line);
             if (matcher.matches()) {
                 sum_locked_thr_state_runnable_cnt++;
             } else {
                 // It's strange, but a locked line can also
                 // match the THREAD_STATE_BLOCKED_PATTERN.
                 matcher = THREAD_STATE_BLOCKED_PATTERN.matcher(
                               thread_state_line);
                 if (matcher.matches()) {
                     sum_locked_thr_state_blocked_cnt++;
                 } else {
                     System.err.println();
                     System.err.println("ERROR: thread state line does not " +
                         "match runnable or waiting patterns.");
                     System.err.println("ERROR: " + "thread_state_line='" +
                         thread_state_line + "'");
                     System.err.println("ERROR: locked_line='" + line + "'");
                     error_cnt++;
                 }
             }

             // Have everything we need from this thread stack
             // that matches the LOCK_PATTERN.
             have_header_line = false;
             have_thread_state_line = false;
             return true;
         }

         return false;
     }

     // Process the waiting line here if we found one.
     //
     // Example:
     // "ContendingThread-2" #22 prio=5 os_prio=64 tid=0x00000000007b9800 nid=0x30 waiting for monitor entry [0xfffffd7fc1010000]
     //    java.lang.Thread.State: BLOCKED (on object monitor)
     //         at TestThreadDumpMonitorContention$1.run(TestThreadDumpMonitorContention.java:140)
     //         - waiting to lock <0xfffffd7e6a2912f8> (a TestThreadDumpMonitorContention$1)
     //         at java.lang.Thread.run(Thread.java:745)
     //
     static boolean checkWaitingLine(String line) {
         Matcher matcher = WAITING_PATTERN.matcher(line);
         if (matcher.matches()) {
             waiting_line_match_cnt++;
             if (verbose) {
                 System.out.println("waiting_line='" + line + "'");
             }

             matcher = HEADER_WAITING_PATTERN1.matcher(header_line);
             if (matcher.matches()) {
                 sum_waiting_hdr_waiting1_cnt++;
             } else {
                 System.err.println();
                 System.err.println("ERROR: header line does " +
                     "not match a waiting pattern.");
                 System.err.println("ERROR: header_line='" + header_line + "'");
                 System.err.println("ERROR: waiting_line='" + line + "'");
                 error_cnt++;
             }

             matcher = THREAD_STATE_BLOCKED_PATTERN.matcher(thread_state_line);
             if (matcher.matches()) {
                 sum_waiting_thr_state_blocked_cnt++;
             } else {
                 System.err.println();
                 System.err.println("ERROR: thread state line " +
                     "does not match a waiting pattern.");
                 System.err.println("ERROR: thread_state_line='" +
                     thread_state_line + "'");
                 System.err.println("ERROR: waiting_line='" + line + "'");
                 error_cnt++;
             }

             // Have everything we need from this thread stack
             // that matches the WAITING_PATTERN.
             have_header_line = false;
             have_thread_state_line = false;
             return true;
         }

         return false;
     }

     static void doSamples() throws Exception {
         for (int count = 0; count < n_samples; count++) {
             blank_line_match_cnt = 0;
             header_prefix_match_cnt = 0;
             locked_line_match_cnt = 0;
             waiting_line_match_cnt = 0;
             // verbose mode or an error has a lot of output so add more space
             if (verbose || error_cnt > 0) System.out.println();
             System.out.println("Sample #" + count);

             // We don't use the ProcessTools, OutputBuffer or
             // OutputAnalyzer classes from the testlibrary because
             // we have a complicated multi-line parse to perform
             // on a narrow subset of the JSTACK output.
             //
             // - we only care about stack traces that match
             //   HEADER_PREFIX_PATTERN; only two should match
             // - we care about at most three lines from each stack trace
             // - if both stack traces match LOCKED_PATTERN, then that's
             //   a failure and we report it
             // - for a stack trace that matches LOCKED_PATTERN, we verify:
             //   - the header line matches HEADER_RUNNABLE_PATTERN
             //     or HEADER_WAITING_PATTERN{1,2}
             //   - the thread state line matches THREAD_STATE_BLOCKED_PATTERN
             //     or THREAD_STATE_RUNNABLE_PATTERN
             //   - we report any mismatches as failures
             // - for a stack trace that matches WAITING_PATTERN, we verify:
             //   - the header line matches HEADER_WAITING_PATTERN1
             //   - the thread state line matches THREAD_STATE_BLOCKED_PATTERN
             //   - we report any mismatches as failures
             // - the stack traces that match HEADER_PREFIX_PATTERN may
             //   not match either LOCKED_PATTERN or WAITING_PATTERN
             //   because we might observe the thread outside of
             //   monitor operations; this is not considered a failure
             //
             // When we do observe LOCKED_PATTERN or WAITING_PATTERN,
             // then we are checking the header and thread state patterns
             // that occurred earlier in the current stack trace that
             // matched HEADER_PREFIX_PATTERN. We don't use data from
             // stack traces that don't match HEADER_PREFIX_PATTERN and
             // we don't mix data between the two stack traces that do
             // match HEADER_PREFIX_PATTERN.
             //
             Process process = new ProcessBuilder(JSTACK, PID)
                 .redirectErrorStream(true).start();

             BufferedReader reader = new BufferedReader(new InputStreamReader(
                                         process.getInputStream()));
             String line;
             while ((line = reader.readLine()) != null) {
                 Matcher matcher = null;

                 // process the header line here
                 if (!have_header_line) {
                     matcher = HEADER_PREFIX_PATTERN.matcher(line);
                     if (matcher.matches()) {
                         header_prefix_match_cnt++;
                         if (verbose) {
                             System.out.println();
                             System.out.println("header='" + line + "'");
                         }
                         header_line = new String(line);
                         have_header_line = true;
                         continue;
                     }
                     continue;  // skip until have a header line
                 }

                 // process the thread state line here
                 if (!have_thread_state_line) {
                     matcher = THREAD_STATE_PREFIX_PATTERN.matcher(line);
                     if (matcher.matches()) {
                         if (verbose) {
                             System.out.println("thread_state='" + line + "'");
                         }
                         thread_state_line = new String(line);
                         have_thread_state_line = true;
                         continue;
                     }
                     continue;  // skip until we have a thread state line
                 }

                 // process the locked line here if we find one
                 if (checkLockedLine(line)) {
                     continue;
                 }

                 // process the waiting line here if we find one
                 if (checkWaitingLine(line)) {
                     continue;
                 }

                 // process the blank line here if we find one
                 if (checkBlankLine(line)) {
                     continue;
                 }
             }
             process.waitFor();

             if (header_prefix_match_cnt != 2) {
                 System.err.println();
                 System.err.println("ERROR: should match exactly two headers.");
                 System.err.println("ERROR: header_prefix_match_cnt=" +
                     header_prefix_match_cnt);
                 error_cnt++;
             }

             if (locked_line_match_cnt == 2) {
                 if (locked_match_list[0].equals(locked_match_list[1])) {
                     System.err.println();
                     System.err.println("ERROR: matching lock lines:");
                     System.err.println("ERROR: line[0]'" +
                         locked_match_list[0] + "'");
                     System.err.println("ERROR: line[1]'" +
                         locked_match_list[1] + "'");
                     error_cnt++;
                 }
             }

             if (locked_line_match_cnt == 1) {
                 // one thread has the lock
                 if (waiting_line_match_cnt == 1) {
                     // and the other contended for it
                     sum_contended_cnt++;
                 } else {
                     // and the other is just running
                     sum_uncontended_cnt++;
                 }
             } else if (waiting_line_match_cnt == 1) {
                 // one thread is waiting
                 sum_one_waiting_cnt++;
             } else if (waiting_line_match_cnt == 2) {
                 // both threads are waiting
                 sum_both_waiting_cnt++;
             } else {
                 // both threads are running
                 sum_both_running_cnt++;
             }

             // slight delay between jstack launches
             Thread.sleep(500);
         }

         if (error_cnt != 0) {
             // skip summary info since there were errors
             return;
         }

         System.out.println("INFO: Summary for all samples:");
         System.out.println("INFO: both_running_cnt=" + sum_both_running_cnt);
         System.out.println("INFO: both_waiting_cnt=" + sum_both_waiting_cnt);
         System.out.println("INFO: contended_cnt=" + sum_contended_cnt);
         System.out.println("INFO: one_waiting_cnt=" + sum_one_waiting_cnt);
         System.out.println("INFO: uncontended_cnt=" + sum_uncontended_cnt);
         System.out.println("INFO: locked_hdr_runnable_cnt=" +
             sum_locked_hdr_runnable_cnt);
         System.out.println("INFO: locked_hdr_waiting1_cnt=" +
             sum_locked_hdr_waiting1_cnt);
         System.out.println("INFO: locked_hdr_waiting2_cnt=" +
             sum_locked_hdr_waiting2_cnt);
         System.out.println("INFO: locked_thr_state_blocked_cnt=" +
             sum_locked_thr_state_blocked_cnt);
         System.out.println("INFO: locked_thr_state_runnable_cnt=" +
             sum_locked_thr_state_runnable_cnt);
         System.out.println("INFO: waiting_hdr_waiting1_cnt=" +
             sum_waiting_hdr_waiting1_cnt);
         System.out.println("INFO: waiting_thr_state_blocked_cnt=" +
             sum_waiting_thr_state_blocked_cnt);

         if (sum_contended_cnt == 0) {
             System.err.println("WARNING: the primary scenario for 8036823" +
                 " has not been exercised by this test run.");
         }
     }

     // This helper relies on RuntimeMXBean.getName() returning a string
     // that looks like this: 5436@mt-haku
     //
     // The testlibrary has tryFindJvmPid(), but that uses a separate
     // process which is much more expensive for finding out your own PID.
     //
     static String getPid() {
         RuntimeMXBean runtimebean = ManagementFactory.getRuntimeMXBean();
         String vmname = runtimebean.getName();
         int i = vmname.indexOf('@');
         if (i != -1) {
             vmname = vmname.substring(0, i);
         }
         return vmname;
     }

     static void usage() {
         System.err.println("Usage: " +
             "java TestThreadDumpMonitorContention [-v] [n_samples]");
         System.exit(1);
     }
 }
	/*
	* Copyright (c) 2014, 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
	* @bug 8036823
	* @bug 8046287
	* @summary Creates two threads contending for the same lock and checks
	* whether jstack reports "locked" by more than one thread.
	*
	* @library /testlibrary
	* @run main/othervm TestThreadDumpMonitorContention
	*/

	import java.io.BufferedReader;
	import java.io.InputStreamReader;
	import java.lang.management.ManagementFactory;
	import java.lang.management.RuntimeMXBean;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;

	import com.oracle.java.testlibrary.*;

	public class TestThreadDumpMonitorContention {
	// jstack tends to be closely bound to the VM that we are running
	// so use getTestJDKTool() instead of getCompileJDKTool() or even
	// getJDKTool() which can fall back to "compile.jdk".
	final static String JSTACK = JDKToolFinder.getTestJDKTool("jstack");
	final static String PID = getPid();

	// looking for header lines with these patterns:
	// "ContendingThread-1" #19 prio=5 os_prio=64 tid=0x000000000079c000 nid=0x23 runnable [0xffff80ffb8b87000]
	// "ContendingThread-2" #21 prio=5 os_prio=64 tid=0x0000000000780000 nid=0x2f waiting for monitor entry [0xfffffd7fc1111000]
	// "ContendingThread-2" #24 prio=5 os_prio=64 tid=0x0000000000ec8800 nid=0x31 waiting on condition [0xfffffd7bbfffe000]
	final static Pattern HEADER_PREFIX_PATTERN = Pattern.compile(
	"^\"ContendingThread-.*");
	final static Pattern HEADER_WAITING_PATTERN1 = Pattern.compile(
	"^\"ContendingThread-.* waiting for monitor entry .*");
	final static Pattern HEADER_WAITING_PATTERN2 = Pattern.compile(
	"^\"ContendingThread-.* waiting on condition .*");
	final static Pattern HEADER_RUNNABLE_PATTERN = Pattern.compile(
	"^\"ContendingThread-.* runnable .*");

	// looking for thread state lines with these patterns:
	// java.lang.Thread.State: RUNNABLE
	// java.lang.Thread.State: BLOCKED (on object monitor)
	final static Pattern THREAD_STATE_PREFIX_PATTERN = Pattern.compile(
	" java\\.lang\\.Thread\\.State: .");
	final static Pattern THREAD_STATE_BLOCKED_PATTERN = Pattern.compile(
	" *java\\.lang\\.Thread\\.State: BLOCKED \\(on object monitor\\)");
	final static Pattern THREAD_STATE_RUNNABLE_PATTERN = Pattern.compile(
	" *java\\.lang\\.Thread\\.State: RUNNABLE");

	// looking for duplicates of this pattern:
	// - locked <0x000000076ac59e20> (a TestThreadDumpMonitorContention$1)
	final static Pattern LOCK_PATTERN = Pattern.compile(
	".* locked \\<.\\(a TestThreadDumpMonitorContention.");

	// sanity checking header and thread state lines associated
	// with this pattern:
	// - waiting to lock <0x000000076ac59e20> (a TestThreadDumpMonitorContention$1)
	final static Pattern WAITING_PATTERN = Pattern.compile(
	".* waiting to lock \\<.\\(a TestThreadDumpMonitorContention.");

	final static Object barrier = new Object();
	volatile static boolean done = false;

	static int barrier_cnt = 0;
	static int blank_line_match_cnt = 0;
	static int error_cnt = 0;
	static boolean have_header_line = false;
	static boolean have_thread_state_line = false;
	static String header_line = null;
	static int header_prefix_match_cnt = 0;
	static int locked_line_match_cnt = 0;
	static String[] locked_match_list = new String[2];
	static int n_samples = 15;
	static int sum_both_running_cnt = 0;
	static int sum_both_waiting_cnt = 0;
	static int sum_contended_cnt = 0;
	static int sum_locked_hdr_runnable_cnt = 0;
	static int sum_locked_hdr_waiting1_cnt = 0;
	static int sum_locked_hdr_waiting2_cnt = 0;
	static int sum_locked_thr_state_blocked_cnt = 0;
	static int sum_locked_thr_state_runnable_cnt = 0;
	static int sum_one_waiting_cnt = 0;
	static int sum_uncontended_cnt = 0;
	static int sum_waiting_hdr_waiting1_cnt = 0;
	static int sum_waiting_thr_state_blocked_cnt = 0;
	static String thread_state_line = null;
	static boolean verbose = false;
	static int waiting_line_match_cnt = 0;

	public static void main(String[] args) throws Exception {
	if (args.length != 0) {
	int arg_i = 0;
	if (args[arg_i].equals("-v")) {
	verbose = true;
	arg_i++;
	}

	try {
	n_samples = Integer.parseInt(args[arg_i]);
	} catch (NumberFormatException nfe) {
	System.err.println(nfe);
	usage();
	}
	}

	Runnable runnable = new Runnable() {
	public void run() {
	synchronized (barrier) {
	// let the main thread know we're running
	barrier_cnt++;
	barrier.notify();
	}
	while (!done) {
	synchronized (this) { }
	}
	}
	};
	Thread[] thread_list = new Thread[2];
	thread_list[0] = new Thread(runnable, "ContendingThread-1");
	thread_list[1] = new Thread(runnable, "ContendingThread-2");
	synchronized (barrier) {
	thread_list[0].start();
	thread_list[1].start();

	// Wait until the contending threads are running so that
	// we don't sample any thread init states.
	while (barrier_cnt < 2) {
	barrier.wait();
	}
	}

	doSamples();

	done = true;

	thread_list[0].join();
	thread_list[1].join();

	if (error_cnt == 0) {
	System.out.println("Test PASSED.");
	} else {
	System.out.println("Test FAILED.");
	throw new AssertionError("error_cnt=" + error_cnt);
	}
	}

	// Reached a blank line which is the end of the
	// stack trace without matching either LOCK_PATTERN
	// or WAITING_PATTERN. Rare, but it's not an error.
	//
	// Example:
	// "ContendingThread-1" #21 prio=5 os_prio=64 tid=0x00000000007b9000 nid=0x2f runnable [0xfffffd7fc1111000]
	// java.lang.Thread.State: RUNNABLE
	// at TestThreadDumpMonitorContention$1.run(TestThreadDumpMonitorContention.java:140)
	// at java.lang.Thread.run(Thread.java:745)
	//
	static boolean checkBlankLine(String line) {
	if (line.length() == 0) {
	blank_line_match_cnt++;
	have_header_line = false;
	have_thread_state_line = false;
	return true;
	}

	return false;
	}

	// Process the locked line here if we found one.
	//
	// Example 1:
	// "ContendingThread-1" #21 prio=5 os_prio=64 tid=0x00000000007b9000 nid=0x2f runnable [0xfffffd7fc1111000]
	// java.lang.Thread.State: RUNNABLE
	// at TestThreadDumpMonitorContention$1.run(TestThreadDumpMonitorContention.java:140)
	// - locked <0xfffffd7e6a2912f8> (a TestThreadDumpMonitorContention$1)
	// at java.lang.Thread.run(Thread.java:745)
	//
	// Example 2:
	// "ContendingThread-1" #21 prio=5 os_prio=64 tid=0x00000000007b9000 nid=0x2f waiting for monitor entry [0xfffffd7fc1111000]
	// java.lang.Thread.State: BLOCKED (on object monitor)
	// at TestThreadDumpMonitorContention$1.run(TestThreadDumpMonitorContention.java:140)
	// - locked <0xfffffd7e6a2912f8> (a TestThreadDumpMonitorContention$1)
	// at java.lang.Thread.run(Thread.java:745)
	//
	// Example 3:
	// "ContendingThread-2" #24 prio=5 os_prio=64 tid=0x0000000000ec8800 nid=0x31 waiting on condition [0xfffffd7bbfffe000]
	// java.lang.Thread.State: RUNNABLE
	// JavaThread state: _thread_blocked
	// Thread: 0x0000000000ec8800 [0x31] State: _at_safepoint _has_called_back 0 _at_poll_safepoint 0
	// JavaThread state: _thread_blocked
	// at TestThreadDumpMonitorContention$1.run(TestThreadDumpMonitorContention.java:140)
	// - locked <0xfffffd7e6d03eb28> (a TestThreadDumpMonitorContention$1)
	// at java.lang.Thread.run(Thread.java:745)
	//
	static boolean checkLockedLine(String line) {
	Matcher matcher = LOCK_PATTERN.matcher(line);
	if (matcher.matches()) {
	if (verbose) {
	System.out.println("locked_line='" + line + "'");
	}
	locked_match_list[locked_line_match_cnt] = new String(line);
	locked_line_match_cnt++;

	matcher = HEADER_RUNNABLE_PATTERN.matcher(header_line);
	if (matcher.matches()) {
	sum_locked_hdr_runnable_cnt++;
	} else {
	// It's strange, but a locked line can also
	// match the HEADER_WAITING_PATTERN{1,2}.
	matcher = HEADER_WAITING_PATTERN1.matcher(header_line);
	if (matcher.matches()) {
	sum_locked_hdr_waiting1_cnt++;
	} else {
	matcher = HEADER_WAITING_PATTERN2.matcher(header_line);
	if (matcher.matches()) {
	sum_locked_hdr_waiting2_cnt++;
	} else {
	System.err.println();
	System.err.println("ERROR: header line does " +
	"not match runnable or waiting patterns.");
	System.err.println("ERROR: header_line='" +
	header_line + "'");
	System.err.println("ERROR: locked_line='" + line +
	"'");
	error_cnt++;
	}
	}
	}

	matcher = THREAD_STATE_RUNNABLE_PATTERN.matcher(thread_state_line);
	if (matcher.matches()) {
	sum_locked_thr_state_runnable_cnt++;
	} else {
	// It's strange, but a locked line can also
	// match the THREAD_STATE_BLOCKED_PATTERN.
	matcher = THREAD_STATE_BLOCKED_PATTERN.matcher(
	thread_state_line);
	if (matcher.matches()) {
	sum_locked_thr_state_blocked_cnt++;
	} else {
	System.err.println();
	System.err.println("ERROR: thread state line does not " +
	"match runnable or waiting patterns.");
	System.err.println("ERROR: " + "thread_state_line='" +
	thread_state_line + "'");
	System.err.println("ERROR: locked_line='" + line + "'");
	error_cnt++;
	}
	}

	// Have everything we need from this thread stack
	// that matches the LOCK_PATTERN.
	have_header_line = false;
	have_thread_state_line = false;
	return true;
	}

	return false;
	}

	// Process the waiting line here if we found one.
	//
	// Example:
	// "ContendingThread-2" #22 prio=5 os_prio=64 tid=0x00000000007b9800 nid=0x30 waiting for monitor entry [0xfffffd7fc1010000]
	// java.lang.Thread.State: BLOCKED (on object monitor)
	// at TestThreadDumpMonitorContention$1.run(TestThreadDumpMonitorContention.java:140)
	// - waiting to lock <0xfffffd7e6a2912f8> (a TestThreadDumpMonitorContention$1)
	// at java.lang.Thread.run(Thread.java:745)
	//
	static boolean checkWaitingLine(String line) {
	Matcher matcher = WAITING_PATTERN.matcher(line);
	if (matcher.matches()) {
	waiting_line_match_cnt++;
	if (verbose) {
	System.out.println("waiting_line='" + line + "'");
	}

	matcher = HEADER_WAITING_PATTERN1.matcher(header_line);
	if (matcher.matches()) {
	sum_waiting_hdr_waiting1_cnt++;
	} else {
	System.err.println();
	System.err.println("ERROR: header line does " +
	"not match a waiting pattern.");
	System.err.println("ERROR: header_line='" + header_line + "'");
	System.err.println("ERROR: waiting_line='" + line + "'");
	error_cnt++;
	}

	matcher = THREAD_STATE_BLOCKED_PATTERN.matcher(thread_state_line);
	if (matcher.matches()) {
	sum_waiting_thr_state_blocked_cnt++;
	} else {
	System.err.println();
	System.err.println("ERROR: thread state line " +
	"does not match a waiting pattern.");
	System.err.println("ERROR: thread_state_line='" +
	thread_state_line + "'");
	System.err.println("ERROR: waiting_line='" + line + "'");
	error_cnt++;
	}

	// Have everything we need from this thread stack
	// that matches the WAITING_PATTERN.
	have_header_line = false;
	have_thread_state_line = false;
	return true;
	}

	return false;
	}

	static void doSamples() throws Exception {
	for (int count = 0; count < n_samples; count++) {
	blank_line_match_cnt = 0;
	header_prefix_match_cnt = 0;
	locked_line_match_cnt = 0;
	waiting_line_match_cnt = 0;
	// verbose mode or an error has a lot of output so add more space
	if (verbose \|\| error_cnt > 0) System.out.println();
	System.out.println("Sample #" + count);

	// We don't use the ProcessTools, OutputBuffer or
	// OutputAnalyzer classes from the testlibrary because
	// we have a complicated multi-line parse to perform
	// on a narrow subset of the JSTACK output.
	//
	// - we only care about stack traces that match
	// HEADER_PREFIX_PATTERN; only two should match
	// - we care about at most three lines from each stack trace
	// - if both stack traces match LOCKED_PATTERN, then that's
	// a failure and we report it
	// - for a stack trace that matches LOCKED_PATTERN, we verify:
	// - the header line matches HEADER_RUNNABLE_PATTERN
	// or HEADER_WAITING_PATTERN{1,2}
	// - the thread state line matches THREAD_STATE_BLOCKED_PATTERN
	// or THREAD_STATE_RUNNABLE_PATTERN
	// - we report any mismatches as failures
	// - for a stack trace that matches WAITING_PATTERN, we verify:
	// - the header line matches HEADER_WAITING_PATTERN1
	// - the thread state line matches THREAD_STATE_BLOCKED_PATTERN
	// - we report any mismatches as failures
	// - the stack traces that match HEADER_PREFIX_PATTERN may
	// not match either LOCKED_PATTERN or WAITING_PATTERN
	// because we might observe the thread outside of
	// monitor operations; this is not considered a failure
	//
	// When we do observe LOCKED_PATTERN or WAITING_PATTERN,
	// then we are checking the header and thread state patterns
	// that occurred earlier in the current stack trace that
	// matched HEADER_PREFIX_PATTERN. We don't use data from
	// stack traces that don't match HEADER_PREFIX_PATTERN and
	// we don't mix data between the two stack traces that do
	// match HEADER_PREFIX_PATTERN.
	//
	Process process = new ProcessBuilder(JSTACK, PID)
	.redirectErrorStream(true).start();

	BufferedReader reader = new BufferedReader(new InputStreamReader(
	process.getInputStream()));
	String line;
	while ((line = reader.readLine()) != null) {
	Matcher matcher = null;

	// process the header line here
	if (!have_header_line) {
	matcher = HEADER_PREFIX_PATTERN.matcher(line);
	if (matcher.matches()) {
	header_prefix_match_cnt++;
	if (verbose) {
	System.out.println();
	System.out.println("header='" + line + "'");
	}
	header_line = new String(line);
	have_header_line = true;
	continue;
	}
	continue; // skip until have a header line
	}

	// process the thread state line here
	if (!have_thread_state_line) {
	matcher = THREAD_STATE_PREFIX_PATTERN.matcher(line);
	if (matcher.matches()) {
	if (verbose) {
	System.out.println("thread_state='" + line + "'");
	}
	thread_state_line = new String(line);
	have_thread_state_line = true;
	continue;
	}
	continue; // skip until we have a thread state line
	}

	// process the locked line here if we find one
	if (checkLockedLine(line)) {
	continue;
	}

	// process the waiting line here if we find one
	if (checkWaitingLine(line)) {
	continue;
	}

	// process the blank line here if we find one
	if (checkBlankLine(line)) {
	continue;
	}
	}
	process.waitFor();

	if (header_prefix_match_cnt != 2) {
	System.err.println();
	System.err.println("ERROR: should match exactly two headers.");
	System.err.println("ERROR: header_prefix_match_cnt=" +
	header_prefix_match_cnt);
	error_cnt++;
	}

	if (locked_line_match_cnt == 2) {
	if (locked_match_list[0].equals(locked_match_list[1])) {
	System.err.println();
	System.err.println("ERROR: matching lock lines:");
	System.err.println("ERROR: line[0]'" +
	locked_match_list[0] + "'");
	System.err.println("ERROR: line[1]'" +
	locked_match_list[1] + "'");
	error_cnt++;
	}
	}

	if (locked_line_match_cnt == 1) {
	// one thread has the lock
	if (waiting_line_match_cnt == 1) {
	// and the other contended for it
	sum_contended_cnt++;
	} else {
	// and the other is just running
	sum_uncontended_cnt++;
	}
	} else if (waiting_line_match_cnt == 1) {
	// one thread is waiting
	sum_one_waiting_cnt++;
	} else if (waiting_line_match_cnt == 2) {
	// both threads are waiting
	sum_both_waiting_cnt++;
	} else {
	// both threads are running
	sum_both_running_cnt++;
	}

	// slight delay between jstack launches
	Thread.sleep(500);
	}

	if (error_cnt != 0) {
	// skip summary info since there were errors
	return;
	}

	System.out.println("INFO: Summary for all samples:");
	System.out.println("INFO: both_running_cnt=" + sum_both_running_cnt);
	System.out.println("INFO: both_waiting_cnt=" + sum_both_waiting_cnt);
	System.out.println("INFO: contended_cnt=" + sum_contended_cnt);
	System.out.println("INFO: one_waiting_cnt=" + sum_one_waiting_cnt);
	System.out.println("INFO: uncontended_cnt=" + sum_uncontended_cnt);
	System.out.println("INFO: locked_hdr_runnable_cnt=" +
	sum_locked_hdr_runnable_cnt);
	System.out.println("INFO: locked_hdr_waiting1_cnt=" +
	sum_locked_hdr_waiting1_cnt);
	System.out.println("INFO: locked_hdr_waiting2_cnt=" +
	sum_locked_hdr_waiting2_cnt);
	System.out.println("INFO: locked_thr_state_blocked_cnt=" +
	sum_locked_thr_state_blocked_cnt);
	System.out.println("INFO: locked_thr_state_runnable_cnt=" +
	sum_locked_thr_state_runnable_cnt);
	System.out.println("INFO: waiting_hdr_waiting1_cnt=" +
	sum_waiting_hdr_waiting1_cnt);
	System.out.println("INFO: waiting_thr_state_blocked_cnt=" +
	sum_waiting_thr_state_blocked_cnt);

	if (sum_contended_cnt == 0) {
	System.err.println("WARNING: the primary scenario for 8036823" +
	" has not been exercised by this test run.");
	}
	}

	// This helper relies on RuntimeMXBean.getName() returning a string
	// that looks like this: 5436@mt-haku
	//
	// The testlibrary has tryFindJvmPid(), but that uses a separate
	// process which is much more expensive for finding out your own PID.
	//
	static String getPid() {
	RuntimeMXBean runtimebean = ManagementFactory.getRuntimeMXBean();
	String vmname = runtimebean.getName();
	int i = vmname.indexOf('@');
	if (i != -1) {
	vmname = vmname.substring(0, i);
	}
	return vmname;
	}

	static void usage() {
	System.err.println("Usage: " +
	"java TestThreadDumpMonitorContention [-v] [n_samples]");
	System.exit(1);
	}
	}