| /* |
| * Copyright (c) 2023 SAP SE. All rights reserved. |
| * Copyright (c) 2023, 2024, Red Hat, Inc. All rights reserved. |
| * Copyright (c) 2023, 2024, 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 id=trimNative |
| * @requires vm.flagless |
| * @requires (os.family=="linux") & !vm.musl |
| * @modules java.base/jdk.internal.misc |
| * @library /test/lib |
| * @build jdk.test.whitebox.WhiteBox |
| * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox |
| * @run driver TestTrimNative trimNative |
| */ |
| |
| /* |
| * @test id=trimNativeStrict |
| * @requires vm.flagless |
| * @requires (os.family=="linux") & !vm.musl |
| * @modules java.base/jdk.internal.misc |
| * @library /test/lib |
| * @build jdk.test.whitebox.WhiteBox |
| * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox |
| * @run main/manual TestTrimNative trimNativeStrict |
| */ |
| |
| /* |
| * @test id=trimNativeHighInterval |
| * @summary High interval trimming should not even kick in for short program runtimes |
| * @requires vm.flagless |
| * @requires (os.family=="linux") & !vm.musl |
| * @modules java.base/jdk.internal.misc |
| * @library /test/lib |
| * @build jdk.test.whitebox.WhiteBox |
| * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox |
| * @run driver TestTrimNative trimNativeHighInterval |
| */ |
| |
| /* |
| * @test id=trimNativeLowInterval |
| * @summary Very low (sub-second) interval, nothing should explode |
| * @requires vm.flagless |
| * @requires (os.family=="linux") & !vm.musl |
| * @modules java.base/jdk.internal.misc |
| * @library /test/lib |
| * @build jdk.test.whitebox.WhiteBox |
| * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox |
| * @run driver TestTrimNative trimNativeLowInterval |
| */ |
| |
| /* |
| * @test id=trimNativeLowIntervalStrict |
| * @summary Very low (sub-second) interval, nothing should explode (stricter test, manual mode) |
| * @requires vm.flagless |
| * @requires (os.family=="linux") & !vm.musl |
| * @modules java.base/jdk.internal.misc |
| * @library /test/lib |
| * @build jdk.test.whitebox.WhiteBox |
| * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox |
| * @run main/manual TestTrimNative trimNativeLowIntervalStrict |
| */ |
| |
| /* |
| * @test id=testOffByDefault |
| * @summary Test that trimming is disabled by default |
| * @requires vm.flagless |
| * @requires (os.family=="linux") & !vm.musl |
| * @modules java.base/jdk.internal.misc |
| * @library /test/lib |
| * @build jdk.test.whitebox.WhiteBox |
| * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox |
| * @run driver TestTrimNative testOffByDefault |
| */ |
| |
| /* |
| * @test id=testOffExplicit |
| * @summary Test that trimming can be disabled explicitly |
| * @requires vm.flagless |
| * @requires (os.family=="linux") & !vm.musl |
| * @modules java.base/jdk.internal.misc |
| * @library /test/lib |
| * @build jdk.test.whitebox.WhiteBox |
| * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox |
| * @run driver TestTrimNative testOffExplicit |
| */ |
| |
| /* |
| * @test id=testOffOnNonCompliantPlatforms |
| * @summary Test that trimming is correctly reported as unavailable if unavailable |
| * @requires vm.flagless |
| * @requires (os.family!="linux") | vm.musl |
| * @modules java.base/jdk.internal.misc |
| * @library /test/lib |
| * @build jdk.test.whitebox.WhiteBox |
| * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox |
| * @run driver TestTrimNative testOffOnNonCompliantPlatforms |
| */ |
| |
| import jdk.test.lib.Platform; |
| import jdk.test.lib.process.OutputAnalyzer; |
| import jdk.test.lib.process.ProcessTools; |
| |
| import java.io.IOException; |
| import java.util.*; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| import jdk.test.whitebox.WhiteBox; |
| |
| public class TestTrimNative { |
| |
| // Actual RSS increase is a lot larger than 4 MB. Depends on glibc overhead, and NMT malloc headers in debug VMs. |
| // We need small-grained allocations to make sure they actually increase RSS (all touched) and to see the |
| // glibc-retaining-memory effect. |
| static final int szAllocations = 128; |
| static final int totalAllocationsSize = 128 * 1024 * 1024; // 128 MB total |
| static final int numAllocations = totalAllocationsSize / szAllocations; |
| |
| static long[] ptrs = new long[numAllocations]; |
| |
| enum Unit { |
| B(1), K(1024), M(1024*1024), G(1024*1024*1024); |
| public final long size; |
| Unit(long size) { this.size = size; } |
| } |
| |
| private static String[] prepareOptions(String[] extraVMOptions, String[] programOptions) { |
| List<String> allOptions = new ArrayList<String>(); |
| if (extraVMOptions != null) { |
| allOptions.addAll(Arrays.asList(extraVMOptions)); |
| } |
| allOptions.add("-Xmx128m"); |
| allOptions.add("-Xms128m"); // Stabilize RSS |
| allOptions.add("-XX:+AlwaysPreTouch"); // Stabilize RSS |
| allOptions.add("-XX:+UnlockDiagnosticVMOptions"); // For whitebox |
| allOptions.add("-XX:+WhiteBoxAPI"); |
| allOptions.add("-Xbootclasspath/a:."); |
| allOptions.add("-XX:-ExplicitGCInvokesConcurrent"); // Invoke explicit GC on System.gc |
| allOptions.add("-Xlog:trimnative=debug"); |
| allOptions.add("--add-exports=java.base/jdk.internal.misc=ALL-UNNAMED"); |
| if (programOptions != null) { |
| allOptions.addAll(Arrays.asList(programOptions)); |
| } |
| return allOptions.toArray(new String[0]); |
| } |
| |
| private static OutputAnalyzer runTestWithOptions(String[] extraOptions, String[] programOptions) throws IOException { |
| ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(prepareOptions(extraOptions, programOptions)); |
| OutputAnalyzer output = new OutputAnalyzer(pb.start()); |
| output.shouldHaveExitValue(0); |
| return output; |
| } |
| |
| private static void checkExpectedLogMessages(OutputAnalyzer output, boolean expectEnabled, |
| int expectedInterval) { |
| if (expectEnabled) { |
| output.shouldContain("Periodic native trim enabled (interval: " + expectedInterval + " ms"); |
| output.shouldContain("Native heap trimmer start"); |
| } else { |
| output.shouldNotContain("Periodic native trim enabled"); |
| } |
| } |
| |
| /** |
| * Given JVM output, look for one or more log lines that describes a successful negative trim. The total amount |
| * of trims should be matching about what the test program allocated. |
| * @param output |
| * @param minTrimsExpected min number of periodic trim lines expected in UL log |
| * @param maxTrimsExpected min number of periodic trim lines expected in UL log |
| * @param strict: if true, expect RSS to go down; if false, just look for trims without looking at RSS. |
| */ |
| private static void parseOutputAndLookForNegativeTrim(OutputAnalyzer output, int minTrimsExpected, |
| int maxTrimsExpected, boolean strict) { |
| output.reportDiagnosticSummary(); |
| List<String> lines = output.asLines(); |
| Pattern pat = Pattern.compile(".*\\[trimnative\\] Periodic Trim \\(\\d+\\): (\\d+)([BKMG])->(\\d+)([BKMG]).*"); |
| int numTrimsFound = 0; |
| long rssReductionTotal = 0; |
| for (String line : lines) { |
| Matcher mat = pat.matcher(line); |
| if (mat.matches()) { |
| long rss1 = Long.parseLong(mat.group(1)) * Unit.valueOf(mat.group(2)).size; |
| long rss2 = Long.parseLong(mat.group(3)) * Unit.valueOf(mat.group(4)).size; |
| if (rss1 > rss2) { |
| rssReductionTotal += (rss1 - rss2); |
| } |
| numTrimsFound ++; |
| } |
| if (numTrimsFound > maxTrimsExpected) { |
| throw new RuntimeException("Abnormal high number of periodic trim attempts found (more than " + maxTrimsExpected + |
| "). Does the interval setting not work?"); |
| } |
| } |
| if (numTrimsFound < minTrimsExpected) { |
| throw new RuntimeException("We found fewer (periodic) trim lines in UL log than expected (expected at least " + minTrimsExpected + |
| ", found " + numTrimsFound + ")."); |
| } |
| System.out.println("Found " + numTrimsFound + " trims. Ok."); |
| if (strict && maxTrimsExpected > 0) { |
| // This is very fuzzy. Test program malloced X bytes, then freed them again and trimmed. But the log line prints change in RSS. |
| // Which, of course, is influenced by a lot of other factors. But we expect to see *some* reasonable reduction in RSS |
| // due to trimming. |
| float fudge = 0.5f; |
| // On ppc, we see a vastly diminished return (~3M reduction instead of ~200), I suspect because of the underlying |
| // 64k pages lead to a different geometry. Manual tests with larger reclaim sizes show that autotrim works. For |
| // this test, we just reduce the fudge factor. |
| if (Platform.isPPC()) { // le and be both |
| fudge = 0.01f; |
| } |
| long expectedMinimalReduction = (long) (totalAllocationsSize * fudge); |
| if (rssReductionTotal < expectedMinimalReduction) { |
| throw new RuntimeException("We did not see the expected RSS reduction in the UL log. Expected (with fudge)" + |
| " to see at least a combined reduction of " + expectedMinimalReduction + "."); |
| } else { |
| System.out.println("Found high enough RSS reduction from trims: " + rssReductionTotal); |
| } |
| } |
| } |
| |
| static class Tester { |
| public static void main(String[] args) throws Exception { |
| long sleeptime = Long.parseLong(args[0]); |
| |
| System.out.println("Will spike now..."); |
| WhiteBox wb = WhiteBox.getWhiteBox(); |
| for (int i = 0; i < numAllocations; i++) { |
| ptrs[i] = wb.NMTMalloc(szAllocations); |
| wb.preTouchMemory(ptrs[i], szAllocations); |
| } |
| for (int i = 0; i < numAllocations; i++) { |
| wb.NMTFree(ptrs[i]); |
| } |
| System.out.println("Done spiking."); |
| |
| System.out.println("GC..."); |
| System.gc(); |
| |
| // give GC time to react |
| System.out.println("Sleeping for " + sleeptime + " ms..."); |
| Thread.sleep(sleeptime); |
| System.out.println("Done."); |
| } |
| } |
| |
| public static void main(String[] args) throws Exception { |
| |
| if (args.length == 0) { |
| throw new RuntimeException("Argument error"); |
| } |
| |
| boolean strictTesting = args[0].endsWith("Strict"); |
| |
| switch (args[0]) { |
| case "trimNative": |
| case "trimNativeStrict": { |
| long trimInterval = 500; // twice per second |
| long ms1 = System.currentTimeMillis(); |
| OutputAnalyzer output = runTestWithOptions( |
| new String[] { "-XX:TrimNativeHeapInterval=" + trimInterval }, |
| new String[] { TestTrimNative.Tester.class.getName(), "5000" } |
| ); |
| long ms2 = System.currentTimeMillis(); |
| long runtime_ms = ms2 - ms1; |
| |
| checkExpectedLogMessages(output, true, 500); |
| |
| long maxTrimsExpected = runtime_ms / trimInterval; |
| long minTrimsExpected = maxTrimsExpected / 2; |
| parseOutputAndLookForNegativeTrim(output, (int) minTrimsExpected, (int) maxTrimsExpected, strictTesting); |
| } break; |
| |
| case "trimNativeHighInterval": { |
| OutputAnalyzer output = runTestWithOptions( |
| new String[] { "-XX:TrimNativeHeapInterval=" + Integer.MAX_VALUE }, |
| new String[] { TestTrimNative.Tester.class.getName(), "5000" } |
| ); |
| checkExpectedLogMessages(output, true, Integer.MAX_VALUE); |
| // We should not see any trims since the interval would prevent them |
| parseOutputAndLookForNegativeTrim(output, 0, 0, strictTesting); |
| } break; |
| |
| case "trimNativeLowInterval": |
| case "trimNativeLowIntervalStrict": { |
| long ms1 = System.currentTimeMillis(); |
| OutputAnalyzer output = runTestWithOptions( |
| new String[] { "-XX:TrimNativeHeapInterval=1" }, |
| new String[] { TestTrimNative.Tester.class.getName(), "0" } |
| ); |
| long ms2 = System.currentTimeMillis(); |
| int maxTrimsExpected = (int)(ms2 - ms1); // 1ms trim interval |
| checkExpectedLogMessages(output, true, 1); |
| parseOutputAndLookForNegativeTrim(output, 1, (int)maxTrimsExpected, strictTesting); |
| } break; |
| |
| case "testOffOnNonCompliantPlatforms": { |
| OutputAnalyzer output = runTestWithOptions( |
| new String[] { "-XX:TrimNativeHeapInterval=1" }, |
| new String[] { "-version" } |
| ); |
| checkExpectedLogMessages(output, false, 0); |
| parseOutputAndLookForNegativeTrim(output, 0, 0, strictTesting); |
| // The following output is expected to be printed with warning level, so it should not need -Xlog |
| output.shouldContain("[warning][trimnative] Native heap trim is not supported on this platform"); |
| } break; |
| |
| case "testOffExplicit": { |
| OutputAnalyzer output = runTestWithOptions( |
| new String[] { "-XX:TrimNativeHeapInterval=0" }, |
| new String[] { "-version" } |
| ); |
| checkExpectedLogMessages(output, false, 0); |
| parseOutputAndLookForNegativeTrim(output, 0, 0, strictTesting); |
| } break; |
| |
| case "testOffByDefault": { |
| OutputAnalyzer output = runTestWithOptions(null, new String[] { "-version" } ); |
| checkExpectedLogMessages(output, false, 0); |
| parseOutputAndLookForNegativeTrim(output, 0, 0, strictTesting); |
| } break; |
| |
| default: |
| throw new RuntimeException("Invalid test " + args[0]); |
| |
| } |
| } |
| } |
