示例#1
1
  public static void main(String args[]) throws Exception {
    is_64_bit_system = (Platform.is64bit());

    OutputAnalyzer output;
    whiteBox = WhiteBox.getWhiteBox();

    // Grab my own PID
    String pid = Integer.toString(ProcessTools.getProcessId());
    ProcessBuilder pb = new ProcessBuilder();

    AllocThread[] alloc_threads = new AllocThread[256];
    ReleaseThread[] release_threads = new ReleaseThread[64];

    int index;
    // Create many allocation threads
    for (index = 0; index < alloc_threads.length; index++) {
      alloc_threads[index] = new AllocThread();
    }

    // Fewer release threads
    for (index = 0; index < release_threads.length; index++) {
      release_threads[index] = new ReleaseThread();
    }

    if (is_64_bit_system()) {
      sleep_wait(2 * 60 * 1000);
    } else {
      sleep_wait(60 * 1000);
    }
    // pause the stress test
    phase = TestPhase.pause;
    while (pause_count.intValue() < alloc_threads.length + release_threads.length) {
      sleep_wait(10);
    }

    long mallocd_total_in_KB = (mallocd_total + K / 2) / K;

    // Now check if the result from NMT matches the total memory allocated.
    String expected_test_summary =
        "Test (reserved=" + mallocd_total_in_KB + "KB, committed=" + mallocd_total_in_KB + "KB)";
    // Run 'jcmd <pid> VM.native_memory summary'
    pb.command(new String[] {JDKToolFinder.getJDKTool("jcmd"), pid, "VM.native_memory", "summary"});
    output = new OutputAnalyzer(pb.start());
    output.shouldContain(expected_test_summary);

    // Release all allocated memory
    phase = TestPhase.release;
    synchronized (mallocd_memory) {
      mallocd_memory.notifyAll();
    }

    // Join all threads
    for (index = 0; index < alloc_threads.length; index++) {
      try {
        alloc_threads[index].join();
      } catch (InterruptedException e) {
      }
    }

    for (index = 0; index < release_threads.length; index++) {
      try {
        release_threads[index].join();
      } catch (InterruptedException e) {
      }
    }

    // All test memory allocated should be released
    output = new OutputAnalyzer(pb.start());
    output.shouldNotContain("Test (reserved=");

    // Verify that tracking level has not been downgraded
    pb.command(
        new String[] {JDKToolFinder.getJDKTool("jcmd"), pid, "VM.native_memory", "statistics"});
    output = new OutputAnalyzer(pb.start());
    output.shouldNotContain("Tracking level has been downgraded due to lack of resources");
  }
示例#2
0
  public static void main(String args[]) throws Exception {
    if (!Platform.is64bit()) {
      System.out.println(
          "ReadFromNoaccessArea tests is useful only on 64bit architecture. Passing silently.");
      return;
    }

    ProcessBuilder pb =
        ProcessTools.createJavaProcessBuilder(
            "-Xbootclasspath/a:.",
            "-XX:+UnlockDiagnosticVMOptions",
            "-XX:+WhiteBoxAPI",
            "-XX:+UseCompressedOops",
            "-XX:HeapBaseMinAddress=33G",
            "-XX:-CreateCoredumpOnCrash",
            "-Xmx32m",
            DummyClassWithMainTryingToReadFromNoaccessArea.class.getName());

    OutputAnalyzer output = new OutputAnalyzer(pb.start());
    System.out.println("******* Printing stdout for analysis in case of failure *******");
    System.out.println(output.getStdout());
    System.out.println("******* Printing stderr for analysis in case of failure *******");
    System.out.println(output.getStderr());
    System.out.println("***************************************************************");
    if (output.getStdout() != null
        && output.getStdout().contains("WB_ReadFromNoaccessArea method is useless")) {
      // Test conditions broken. There is no protected page in ReservedHeapSpace in these
      // circumstances. Silently passing test.
      return;
    }
    if (Platform.isWindows()) {
      output.shouldContain("EXCEPTION_ACCESS_VIOLATION");
    } else if (Platform.isOSX()) {
      output.shouldContain("SIGBUS");
    } else {
      output.shouldContain("SIGSEGV");
    }
  }
  public static void main(String[] args) throws Exception {
    ProcessBuilder pb;
    String filename = "./CDSCompressedKPtrsError.jsa";

    if (Platform.is64bit()) {
      pb =
          ProcessTools.createJavaProcessBuilder(
              "-XX:+UseCompressedOops",
              "-XX:+UseCompressedClassPointers",
              "-XX:+UnlockDiagnosticVMOptions",
              "-XX:SharedArchiveFile=" + filename,
              "-Xshare:dump");
      OutputAnalyzer output = new OutputAnalyzer(pb.start());
      try {
        output.shouldContain("Loading classes to share");
        output.shouldHaveExitValue(0);

        pb =
            ProcessTools.createJavaProcessBuilder(
                "-XX:-UseCompressedClassPointers",
                "-XX:-UseCompressedOops",
                "-XX:+UnlockDiagnosticVMOptions",
                "-XX:SharedArchiveFile=" + filename,
                "-Xshare:on",
                "-version");
        output = new OutputAnalyzer(pb.start());
        output.shouldContain("Unable to use shared archive");
        output.shouldHaveExitValue(0);

        pb =
            ProcessTools.createJavaProcessBuilder(
                "-XX:-UseCompressedClassPointers",
                "-XX:+UseCompressedOops",
                "-XX:+UnlockDiagnosticVMOptions",
                "-XX:SharedArchiveFile=" + filename,
                "-Xshare:on",
                "-version");
        output = new OutputAnalyzer(pb.start());
        output.shouldContain("Unable to use shared archive");
        output.shouldHaveExitValue(0);

        pb =
            ProcessTools.createJavaProcessBuilder(
                "-XX:+UseCompressedClassPointers",
                "-XX:-UseCompressedOops",
                "-XX:+UnlockDiagnosticVMOptions",
                "-XX:SharedArchiveFile=" + filename,
                "-Xshare:on",
                "-version");
        output = new OutputAnalyzer(pb.start());
        output.shouldContain("Unable to use shared archive");
        output.shouldHaveExitValue(0);

      } catch (RuntimeException e) {
        output.shouldContain("Unable to use shared archive");
        output.shouldHaveExitValue(1);
      }

      // Test bad options with -Xshare:dump.
      pb =
          ProcessTools.createJavaProcessBuilder(
              "-XX:-UseCompressedOops",
              "-XX:+UseCompressedClassPointers",
              "-XX:+UnlockDiagnosticVMOptions",
              "-XX:SharedArchiveFile=./CDSCompressedKPtrsErrorBad1.jsa",
              "-Xshare:dump");
      output = new OutputAnalyzer(pb.start());
      output.shouldContain("Cannot dump shared archive");

      pb =
          ProcessTools.createJavaProcessBuilder(
              "-XX:+UseCompressedOops",
              "-XX:-UseCompressedClassPointers",
              "-XX:+UnlockDiagnosticVMOptions",
              "-XX:SharedArchiveFile=./CDSCompressedKPtrsErrorBad2.jsa",
              "-Xshare:dump");
      output = new OutputAnalyzer(pb.start());
      output.shouldContain("Cannot dump shared archive");

      pb =
          ProcessTools.createJavaProcessBuilder(
              "-XX:-UseCompressedOops",
              "-XX:-UseCompressedClassPointers",
              "-XX:+UnlockDiagnosticVMOptions",
              "-XX:SharedArchiveFile=./CDSCompressedKPtrsErrorBad3.jsa",
              "-Xshare:dump");
      output = new OutputAnalyzer(pb.start());
      output.shouldContain("Cannot dump shared archive");
    }
  }