| /* |
| * Copyright (c) 2020, 2023, 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 |
| * @requires vm.gc != "Epsilon" |
| * @summary Stress the string table and cleaning. |
| * Test argument is the approximate number of seconds to run. |
| * @library /test/lib |
| * @modules java.base/jdk.internal.misc |
| * @build jdk.test.whitebox.WhiteBox |
| * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox |
| * @run main/othervm |
| * -Xbootclasspath/a:. |
| * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI |
| * runtime.stringtable.StringTableCleaningTest 30 |
| */ |
| |
| package runtime.stringtable; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.concurrent.Executors; |
| import java.util.concurrent.ScheduledExecutorService; |
| import java.util.concurrent.ScheduledFuture; |
| import java.util.concurrent.TimeUnit; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| import jdk.test.lib.process.OutputAnalyzer; |
| import jdk.test.lib.process.ProcessTools; |
| import jdk.test.whitebox.gc.GC; |
| |
| public class StringTableCleaningTest { |
| public static void main(String[] args) throws Exception { |
| List<String> subargs = new ArrayList<String>(); |
| subargs.addAll(List.of("-Xlog:gc,gc+start,stringtable*=trace", "-Xmx1g")); |
| subargs.add(Tester.class.getName()); |
| subargs.addAll(Arrays.asList(args)); |
| OutputAnalyzer output = ProcessTools.executeTestJava(subargs); |
| output.shouldHaveExitValue(0); |
| checkOutput(output); |
| } |
| |
| private static int fail(String msg) throws Exception { |
| throw new RuntimeException(msg); |
| } |
| |
| // Recognizing GC start and end log lines. |
| |
| private static final String gcPrefix = "\\[info\\s*\\]\\[gc"; |
| private static final String gcMiddle = "\\s*\\] GC\\(\\p{Digit}+\\) "; |
| |
| private static final String gcStartPrefix = gcPrefix + ",start" + gcMiddle; |
| private static final String gcEndPrefix = gcPrefix + gcMiddle; |
| |
| // Suffix for SerialGC and ParallelGC. |
| private static final String spSuffix = "Pause"; |
| |
| // All G1 pauses except Cleanup do weak reference clearing. |
| private static final String g1Suffix = "Pause(?! Cleanup)"; |
| |
| // For ZGC only major collections clean the string table. ZGC prints the |
| // start message without using the start tag, hence the special prefix. |
| private static final String zStartPrefix = gcPrefix + gcMiddle; |
| private static final String zStartSuffix = "Major Collection \\(.*\\)$"; |
| private static final String zEndSuffix = "Major Collection \\(.*\\) .*->.*$"; |
| |
| // Suffix for ZGC (non generational). |
| private static final String xStartSuffix = "Garbage Collection (.*)$"; |
| private static final String xEndSuffix = "Garbage Collection (.*) .*->.*$"; |
| |
| // Suffix for Shenandoah. |
| private static final String shenSuffix = "Concurrent weak roots"; |
| |
| private static String getGcStartString() { |
| if (GC.Serial.isSelected() || GC.Parallel.isSelected()) { |
| return gcStartPrefix + spSuffix; |
| } else if (GC.G1.isSelected()) { |
| return gcStartPrefix + g1Suffix; |
| } else if (GC.Z.isSelected()) { |
| return "(" + zStartPrefix + zStartSuffix + ")|(" + gcStartPrefix + xStartSuffix + ")"; |
| } else if (GC.Shenandoah.isSelected()) { |
| return gcStartPrefix + shenSuffix; |
| } else { |
| return "unsupported GC"; |
| } |
| } |
| |
| private static String getGcEndString() { |
| if (GC.Serial.isSelected() || GC.Parallel.isSelected()) { |
| return gcEndPrefix + spSuffix; |
| } else if (GC.G1.isSelected()) { |
| return gcEndPrefix + g1Suffix; |
| } else if (GC.Z.isSelected()) { |
| return gcEndPrefix + "(" + zEndSuffix + ")|(" + xEndSuffix + ")"; |
| } else if (GC.Shenandoah.isSelected()) { |
| return gcEndPrefix + shenSuffix; |
| } else { |
| return "unsupported GC"; |
| } |
| } |
| |
| private static Pattern getGcStartPattern() { |
| return Pattern.compile(getGcStartString()); |
| } |
| |
| private static Pattern getGcEndPattern() { |
| return Pattern.compile(getGcEndString()); |
| } |
| |
| private static final Pattern pGcStart = getGcStartPattern(); |
| private static final Pattern pGcEnd = getGcEndPattern(); |
| |
| // Recognizing StringTable GC callback log lines. |
| |
| private static final Pattern pCallback = |
| Pattern.compile("\\[trace\\s*\\]\\[stringtable\\s*\\] Uncleaned items:"); |
| |
| private static boolean matchesPattern(String line, Pattern regex) { |
| return regex.matcher(line).find(); |
| } |
| |
| private static boolean matchesStart(String line) { |
| return matchesPattern(line, pGcStart); |
| } |
| |
| private static boolean matchesEnd(String line) { |
| return matchesPattern(line, pGcEnd); |
| } |
| |
| private static boolean matchesCallback(String line) { |
| return matchesPattern(line, pCallback); |
| } |
| |
| // Search the lines for the first GC start log line in lines, starting |
| // from fromIndex. Returns the index of that line, or -1 if no GC start |
| // line found. Throws if a callback or GC end line is found first. |
| private static int findStart(List<String> lines, int fromIndex) |
| throws Exception |
| { |
| for (int i = fromIndex; i < lines.size(); ++i) { |
| String line = lines.get(i); |
| if (matchesStart(line)) { |
| return i; |
| } else if (matchesEnd(line)) { |
| fail("End without Start: " + i); |
| } else if (matchesCallback(line)) { |
| fail("Callback without Start: " + i); |
| } |
| } |
| return -1; |
| } |
| |
| // Search the lines for the first callback log line in lines, starting |
| // after gcStart. Returns the index of that line, or -1 if no callback |
| // line is found (concurrent GC could start but not complete). Throws |
| // if a GC start or GC end log line is found first. |
| private static int findCallback(List<String> lines, int gcStart) |
| throws Exception |
| { |
| for (int i = gcStart + 1; i < lines.size(); ++i) { |
| String line = lines.get(i); |
| if (matchesCallback(line)) { |
| return i; |
| } else if (matchesEnd(line)) { |
| fail("Missing Callback in [" + gcStart + ", " + i + "]"); |
| } else if (matchesStart(line)) { |
| fail("Two Starts: " + gcStart + ", " + i); |
| } |
| } |
| return -1; |
| } |
| |
| // Search the lines for the first GC end log line in lines, starting |
| // after callback. Returns the index of that line, or -1 if no GC end |
| // line is found (concurrent GC could start but not complete). Throws |
| // if a GC start or a callback log line is found first. |
| private static int findEnd(List<String> lines, int gcStart, int callback) |
| throws Exception |
| { |
| for (int i = callback + 1; i < lines.size(); ++i) { |
| String line = lines.get(i); |
| if (matchesEnd(line)) { |
| return i; |
| } else if (matchesStart(line)) { |
| fail("Missing End for Start: " + gcStart + " at " + i); |
| } else if (matchesCallback(line)) { |
| fail("Multiple Callbacks for Start: " + gcStart + " at " + i); |
| } |
| } |
| return -1; |
| } |
| |
| private static int check(List<String> lines, int fromIndex) throws Exception { |
| int gcStart = findStart(lines, fromIndex); |
| if (gcStart < 0) return -1; |
| int callback = findCallback(lines, gcStart); |
| if (callback < 0) return -1; |
| int gcEnd = findEnd(lines, gcStart, callback); |
| if (gcEnd < 0) return -1; |
| return gcEnd + 1; |
| } |
| |
| private static void checkOutput(OutputAnalyzer output) throws Exception { |
| List<String> lines = output.asLines(); |
| int count = -1; |
| int i = 0; |
| try { |
| for ( ; i >= 0; i = check(lines, i)) { ++count; } |
| } finally { |
| if (i < 0) { |
| System.out.println("Output check passed with " + count + " GCs"); |
| } else { |
| System.out.println("--- Output check failed: " + count + " -----"); |
| System.out.println(output.getOutput()); |
| } |
| } |
| } |
| |
| static class Tester { |
| private static volatile boolean stopRequested = false; |
| |
| private static final TimeUnit durationUnits = TimeUnit.SECONDS; |
| |
| public static void main(String[] args) throws Exception { |
| long duration = Long.parseLong(args[0]); |
| runTest(duration); |
| } |
| |
| public static void runTest(long duration) throws Exception { |
| ScheduledExecutorService scheduler = |
| Executors.newScheduledThreadPool(1); |
| try { |
| ScheduledFuture<?> stopper = |
| scheduler.schedule(() -> stopRequested = true, |
| duration, |
| durationUnits); |
| try { |
| stringMaker(10000000, 100000, 50000); |
| } finally { |
| stopper.cancel(false); |
| } |
| } finally { |
| scheduler.shutdownNow(); |
| } |
| } |
| |
| private static void stringMaker(int maxSize, int growStep, int shrinkStep) |
| throws Exception |
| { |
| long stringNum = 0; |
| while (true) { |
| LinkedList<String> list = new LinkedList<String>(); |
| for (int i = 0; i < maxSize; ++i, ++stringNum) { |
| if (stopRequested) { |
| return; |
| } |
| if ((i != 0) && ((i % growStep) == 0)) { |
| list.subList(0, shrinkStep).clear(); |
| } |
| list.push(Long.toString(stringNum).intern()); |
| } |
| // For generational collectors, try to move current list |
| // contents to old-gen before dropping the list. |
| System.gc(); |
| } |
| } |
| } |
| } |
