test/hotspot/jtreg/gc/concurrent_phase_control/CheckControl.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2017, 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.
  */

 package gc.concurrent_phase_control;

 /*
  * Utility class that uses the WhiteBox concurrent GC phase control to
  * step through a provided sequence of phases, and verify that the
  * phases were actually reached as expected.
  *
  * To use:
  *
  * (1) The main test class has a main function which calls this helper
  * class's check() function with appropriate arguments for the
  * collector being tested.
  *
  * (2) The test program must provide access to WhiteBox, as it is used
  * by this support class.
  *
  * (4) The main test class should be invoked as a driver.  This
  * helper class's check() function will run its Executor class in a
  * subprocess, in order to capture its output for analysis.
  */

 import sun.hotspot.WhiteBox;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;

 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 import jdk.test.lib.Platform;
 import jdk.test.lib.process.OutputAnalyzer;
 import jdk.test.lib.process.ProcessTools;

 public final class CheckControl {
     // gcName: The name of the GC, logged as "Using <name>" near the
     // beginning of the log output.
     //
     // gcOptions: Command line options for invoking the desired
     // collector and logging options to produce output that can be
     // matched against the regex patterns in the gcPhaseInfo pairs.
     //
     // gcPhaseInfo: An array of pairs of strings.  Each pair is a
     // phase name and a regex pattern for recognizing the associated
     // log message.  The regex pattern can be null if no log message
     // is associated with the named phase.  The test will iterate
     // through the array, requesting each phase in turn.
     public static void check(String gcName,
                              String[] gcOptions,
                              String[][] gcPhaseInfo) throws Exception {
         String[] stepPhases = new String[gcPhaseInfo.length];
         for (int i = 0; i < gcPhaseInfo.length; ++i) {
             stepPhases[i] = gcPhaseInfo[i][0];
         }
         String messages = executeTest(gcName, gcOptions, stepPhases);
         checkPhaseControl(messages, gcPhaseInfo);
     }

     private static void fail(String message) throws Exception {
         throw new RuntimeException(message);
     }

     private static final String requestPrefix = "Requesting concurrent phase: ";
     private static final String reachedPrefix = "Reached concurrent phase: ";

     private static String executeTest(String gcName,
                                       String[] gcOptions,
                                       String[] gcStepPhases) throws Exception {
         System.out.println("\n---------- Testing ---------");

         final String[] wb_arguments = {
             "-Xbootclasspath/a:.",
             "-XX:+UnlockDiagnosticVMOptions",
             "-XX:+WhiteBoxAPI"
         };

         List<String> arglist = new ArrayList<String>();
         Collections.addAll(arglist, wb_arguments);
         Collections.addAll(arglist, gcOptions);
         arglist.add(Executor.class.getName());
         Collections.addAll(arglist, gcStepPhases);
         String[] arguments = arglist.toArray(new String[arglist.size()]);

         ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(arguments);
         OutputAnalyzer output = new OutputAnalyzer(pb.start());

         String messages = output.getStdout();
         System.out.println(messages);

         output.shouldHaveExitValue(0);
         output.shouldContain("Using " + gcName);

         return messages;
     }

     private static void checkPhaseControl(String messages,
                                           String[][] gcPhaseInfo)
         throws Exception
     {
         // Iterate through the phase sequence for the test, verifying
         // output contains appropriate sequences of request message,
         // log message for phase, and request reached message.  Note
         // that a log message for a phase may occur later than the
         // associated request reached message, or even the following
         // request message.

         Pattern nextReqP = Pattern.compile(requestPrefix);
         Matcher nextReqM = nextReqP.matcher(messages);

         Pattern nextReachP = Pattern.compile(reachedPrefix);
         Matcher nextReachM = nextReachP.matcher(messages);

         String pendingPhaseMessage = null;
         int pendingPhaseMessagePosition = -1;

         int position = 0;
         for (String[] phase: gcPhaseInfo) {
             String phaseName = phase[0];
             String phaseMsg = phase[1];

             System.out.println("Checking phase " + phaseName);

             // Update the "next" matchers to refer to the next
             // corresponding pair of request and reached messages.
             if (!nextReqM.find()) {
                 fail("Didn't find next phase request");
             } else if ((position != 0) && (nextReqM.start() < nextReachM.end())) {
                 fail("Next request before previous reached");
             } else if (!nextReachM.find()) {
                 fail("Didn't find next phase reached");
             } else if (nextReachM.start() <= nextReqM.end()) {
                 fail("Next request/reached misordered");
             }

             // Find the expected request message, and ensure it is the next.
             Pattern reqP = Pattern.compile(requestPrefix + phaseName);
             Matcher reqM = reqP.matcher(messages);
             if (!reqM.find(position)) {
                 fail("Didn't find request for " + phaseName);
             } else if (reqM.start() != nextReqM.start()) {
                 fail("Request mis-positioned for " + phaseName);
             }

             // Find the expected reached message, and ensure it is the next.
             Pattern reachP = Pattern.compile(reachedPrefix + phaseName);
             Matcher reachM = reachP.matcher(messages);
             if (!reachM.find(position)) {
                 fail("Didn't find reached for " + phaseName);
             } else if (reachM.start() != nextReachM.start()) {
                 fail("Reached mis-positioned for " + phaseName);
             }

             // If there is a pending log message (see below), ensure
             // it was before the current reached message.
             if (pendingPhaseMessage != null) {
                 if (pendingPhaseMessagePosition >= reachM.start()) {
                     fail("Log message after next reached message: " +
                          pendingPhaseMessage);
                 }
             }

             // If the phase has an associated logging message, verify
             // such a logging message is present following the
             // request, and otherwise positioned appropriately.  The
             // complication here is that the logging message
             // associated with a request might follow the reached
             // message, and even the next request message, if there is
             // a later request.  But it must preceed the next
             // logging message and the next reached message.
             boolean clearPendingPhaseMessage = true;
             if (phaseMsg != null) {
                 Pattern logP = Pattern.compile("GC\\(\\d+\\)\\s+" + phaseMsg);
                 Matcher logM = logP.matcher(messages);
                 if (!logM.find(reqM.end())) {
                     fail("Didn't find message " + phaseMsg);
                 }

                 if (pendingPhaseMessage != null) {
                     if (pendingPhaseMessagePosition >= logM.start()) {
                         fail("Log messages out of order: " +
                              pendingPhaseMessage + " should preceed " +
                              phaseMsg);
                     }
                 }

                 if (reachM.end() <= logM.start()) {
                     clearPendingPhaseMessage = false;
                     pendingPhaseMessage = phaseMsg;
                     pendingPhaseMessagePosition = logM.end();
                 }
             }
             if (clearPendingPhaseMessage) {
                 pendingPhaseMessage = null;
                 pendingPhaseMessagePosition = -1;
             }

             // Update position for start of next phase search.
             position = reachM.end();
         }
         // It's okay for there to be a leftover pending phase message.
         // We know it was found before the end of the log.
     }

     private static final class Executor {
         private static final WhiteBox WB = WhiteBox.getWhiteBox();

         private static void step(String phase) {
             System.out.println(requestPrefix + phase);
             WB.requestConcurrentGCPhase(phase);
             System.out.println(reachedPrefix + phase);
         }

         public static void main(String[] phases) throws Exception {
             // Iterate through set sequence of phases, reporting each.
             for (String phase: phases) {
                 step(phase);
             }
             // Wait a little to allow a delayed logging message for
             // the final request/reached to be printed before exiting
             // the program.
             Thread.sleep(250);
         }
     }
 }
	/*
	* Copyright (c) 2017, 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.
	*/

	package gc.concurrent_phase_control;

	/*
	* Utility class that uses the WhiteBox concurrent GC phase control to
	* step through a provided sequence of phases, and verify that the
	* phases were actually reached as expected.
	*
	* To use:
	*
	* (1) The main test class has a main function which calls this helper
	* class's check() function with appropriate arguments for the
	* collector being tested.
	*
	* (2) The test program must provide access to WhiteBox, as it is used
	* by this support class.
	*
	* (4) The main test class should be invoked as a driver. This
	* helper class's check() function will run its Executor class in a
	* subprocess, in order to capture its output for analysis.
	*/

	import sun.hotspot.WhiteBox;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.List;

	import java.util.regex.Matcher;
	import java.util.regex.Pattern;

	import jdk.test.lib.Platform;
	import jdk.test.lib.process.OutputAnalyzer;
	import jdk.test.lib.process.ProcessTools;

	public final class CheckControl {
	// gcName: The name of the GC, logged as "Using <name>" near the
	// beginning of the log output.
	//
	// gcOptions: Command line options for invoking the desired
	// collector and logging options to produce output that can be
	// matched against the regex patterns in the gcPhaseInfo pairs.
	//
	// gcPhaseInfo: An array of pairs of strings. Each pair is a
	// phase name and a regex pattern for recognizing the associated
	// log message. The regex pattern can be null if no log message
	// is associated with the named phase. The test will iterate
	// through the array, requesting each phase in turn.
	public static void check(String gcName,
	String[] gcOptions,
	String[][] gcPhaseInfo) throws Exception {
	String[] stepPhases = new String[gcPhaseInfo.length];
	for (int i = 0; i < gcPhaseInfo.length; ++i) {
	stepPhases[i] = gcPhaseInfo[i][0];
	}
	String messages = executeTest(gcName, gcOptions, stepPhases);
	checkPhaseControl(messages, gcPhaseInfo);
	}

	private static void fail(String message) throws Exception {
	throw new RuntimeException(message);
	}

	private static final String requestPrefix = "Requesting concurrent phase: ";
	private static final String reachedPrefix = "Reached concurrent phase: ";

	private static String executeTest(String gcName,
	String[] gcOptions,
	String[] gcStepPhases) throws Exception {
	System.out.println("\n---------- Testing ---------");

	final String[] wb_arguments = {
	"-Xbootclasspath/a:.",
	"-XX:+UnlockDiagnosticVMOptions",
	"-XX:+WhiteBoxAPI"
	};

	List<String> arglist = new ArrayList<String>();
	Collections.addAll(arglist, wb_arguments);
	Collections.addAll(arglist, gcOptions);
	arglist.add(Executor.class.getName());
	Collections.addAll(arglist, gcStepPhases);
	String[] arguments = arglist.toArray(new String[arglist.size()]);

	ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(arguments);
	OutputAnalyzer output = new OutputAnalyzer(pb.start());

	String messages = output.getStdout();
	System.out.println(messages);

	output.shouldHaveExitValue(0);
	output.shouldContain("Using " + gcName);

	return messages;
	}

	private static void checkPhaseControl(String messages,
	String[][] gcPhaseInfo)
	throws Exception
	{
	// Iterate through the phase sequence for the test, verifying
	// output contains appropriate sequences of request message,
	// log message for phase, and request reached message. Note
	// that a log message for a phase may occur later than the
	// associated request reached message, or even the following
	// request message.

	Pattern nextReqP = Pattern.compile(requestPrefix);
	Matcher nextReqM = nextReqP.matcher(messages);

	Pattern nextReachP = Pattern.compile(reachedPrefix);
	Matcher nextReachM = nextReachP.matcher(messages);

	String pendingPhaseMessage = null;
	int pendingPhaseMessagePosition = -1;

	int position = 0;
	for (String[] phase: gcPhaseInfo) {
	String phaseName = phase[0];
	String phaseMsg = phase[1];

	System.out.println("Checking phase " + phaseName);

	// Update the "next" matchers to refer to the next
	// corresponding pair of request and reached messages.
	if (!nextReqM.find()) {
	fail("Didn't find next phase request");
	} else if ((position != 0) && (nextReqM.start() < nextReachM.end())) {
	fail("Next request before previous reached");
	} else if (!nextReachM.find()) {
	fail("Didn't find next phase reached");
	} else if (nextReachM.start() <= nextReqM.end()) {
	fail("Next request/reached misordered");
	}

	// Find the expected request message, and ensure it is the next.
	Pattern reqP = Pattern.compile(requestPrefix + phaseName);
	Matcher reqM = reqP.matcher(messages);
	if (!reqM.find(position)) {
	fail("Didn't find request for " + phaseName);
	} else if (reqM.start() != nextReqM.start()) {
	fail("Request mis-positioned for " + phaseName);
	}

	// Find the expected reached message, and ensure it is the next.
	Pattern reachP = Pattern.compile(reachedPrefix + phaseName);
	Matcher reachM = reachP.matcher(messages);
	if (!reachM.find(position)) {
	fail("Didn't find reached for " + phaseName);
	} else if (reachM.start() != nextReachM.start()) {
	fail("Reached mis-positioned for " + phaseName);
	}

	// If there is a pending log message (see below), ensure
	// it was before the current reached message.
	if (pendingPhaseMessage != null) {
	if (pendingPhaseMessagePosition >= reachM.start()) {
	fail("Log message after next reached message: " +
	pendingPhaseMessage);
	}
	}

	// If the phase has an associated logging message, verify
	// such a logging message is present following the
	// request, and otherwise positioned appropriately. The
	// complication here is that the logging message
	// associated with a request might follow the reached
	// message, and even the next request message, if there is
	// a later request. But it must preceed the next
	// logging message and the next reached message.
	boolean clearPendingPhaseMessage = true;
	if (phaseMsg != null) {
	Pattern logP = Pattern.compile("GC\\(\\d+\\)\\s+" + phaseMsg);
	Matcher logM = logP.matcher(messages);
	if (!logM.find(reqM.end())) {
	fail("Didn't find message " + phaseMsg);
	}

	if (pendingPhaseMessage != null) {
	if (pendingPhaseMessagePosition >= logM.start()) {
	fail("Log messages out of order: " +
	pendingPhaseMessage + " should preceed " +
	phaseMsg);
	}
	}

	if (reachM.end() <= logM.start()) {
	clearPendingPhaseMessage = false;
	pendingPhaseMessage = phaseMsg;
	pendingPhaseMessagePosition = logM.end();
	}
	}
	if (clearPendingPhaseMessage) {
	pendingPhaseMessage = null;
	pendingPhaseMessagePosition = -1;
	}

	// Update position for start of next phase search.
	position = reachM.end();
	}
	// It's okay for there to be a leftover pending phase message.
	// We know it was found before the end of the log.
	}

	private static final class Executor {
	private static final WhiteBox WB = WhiteBox.getWhiteBox();

	private static void step(String phase) {
	System.out.println(requestPrefix + phase);
	WB.requestConcurrentGCPhase(phase);
	System.out.println(reachedPrefix + phase);
	}

	public static void main(String[] phases) throws Exception {
	// Iterate through set sequence of phases, reporting each.
	for (String phase: phases) {
	step(phase);
	}
	// Wait a little to allow a delayed logging message for
	// the final request/reached to be printed before exiting
	// the program.
	Thread.sleep(250);
	}
	}
	}