jdk8-mips64-public/hotspot: test/runtime/Thread/TestThreadDumpMonitorContention.java@dbb05f6d93c4 (annotated)

test/runtime/Thread/TestThreadDumpMonitorContention.java@dbb05f6d93c4 (annotated)

test/runtime/Thread/TestThreadDumpMonitorContention.java

Mon, 28 Jul 2014 15:06:38 -0700

author: fzhinkin
date: Mon, 28 Jul 2014 15:06:38 -0700
changeset 6997: dbb05f6d93c4
parent 6727: 22146594cd5a
child 6876: 710a3c8b516e
permissions: -rw-r--r--

8051344: JVM crashed in Compile::start() during method parsing w/ UseRTMDeopt turned on
Summary: call rtm_deopt() only if there were no compilation bailouts before.
Reviewed-by: kvn

 /*
  * 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);
     }
 }

Mercurial > jdk8-mips64-public > hotspot / annotate

test/runtime/Thread/TestThreadDumpMonitorContention.java@dbb05f6d93c4 (annotated)

test/runtime/Thread/TestThreadDumpMonitorContention.java