<!--
* Copyright (c) 2017, 2019 IBM Corp. and others
*
* This program and the accompanying materials are made
* available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution and is available at
* https://www.eclipse.org/legal/epl-2.0/ or the Apache
* License, Version 2.0 which accompanies this distribution and
* is available at https://www.apache.org/licenses/LICENSE-2.0.
*
* This Source Code may also be made available under the
* following Secondary Licenses when the conditions for such
* availability set forth in the Eclipse Public License, v. 2.0
* are satisfied: GNU General Public License, version 2 with
* the GNU Classpath Exception [1] and GNU General Public
* License, version 2 with the OpenJDK Assembly Exception [2].
*
* [1] https://www.gnu.org/software/classpath/license.html
* [2] http://openjdk.java.net/legal/assembly-exception.html
*
* SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0 WITH
* Classpath-exception-2.0 OR LicenseRef-GPL-2.0 WITH Assembly-exception
-->




<!DOCTYPE html>
<html lang="en" class="no-js">
  <head>
    
      <meta charset="utf-8">
      <meta name="viewport" content="width=device-width,initial-scale=1">
      <meta http-equiv="x-ua-compatible" content="ie=edge">
      
        <meta name="description" content="Eclipse OpenJ9 documentation">
      
      
        <link rel="canonical" href="https://www.eclipse.org/openj9/docs/xdump/">
      
      
      
        <meta name="lang:clipboard.copy" content="">
      
        <meta name="lang:clipboard.copied" content="">
      
        <meta name="lang:search.language" content="">
      
        <meta name="lang:search.pipeline.stopwords" content="">
      
        <meta name="lang:search.pipeline.trimmer" content="">
      
        <meta name="lang:search.result.none" content="">
      
        <meta name="lang:search.result.one" content="">
      
        <meta name="lang:search.result.other" content="">
      
        <meta name="lang:search.tokenizer" content="">
      
      <link rel="shortcut icon" href="../cr/oj9logo_img9.ico">
      <meta name="generator" content="mkdocs-1.0.4, mkdocs-material-3.0.4">
    
    
      
        <title>-Xdump -  </title>
      
    
    
      <link rel="stylesheet" href="../assets/stylesheets/application.1b62728e.css">
      
        <link rel="stylesheet" href="../assets/stylesheets/application-palette.a8b3c06d.css">
      
      
        
        
        <meta name="theme-color" content="#00bcd4">
      
    
    
      <script src="../assets/javascripts/modernizr.268332fc.js"></script>
    
    
      
        <link href="https://fonts.gstatic.com" rel="preconnect" crossorigin>
        <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Roboto:300,400,400i,700|Roboto+Mono">
        <style>body,input{font-family:"Roboto","Helvetica Neue",Helvetica,Arial,sans-serif}code,kbd,pre{font-family:"Roboto Mono","Courier New",Courier,monospace}</style>
      
    
    <link rel="stylesheet" href="../assets/fonts/material-icons.css">
    
      <link rel="stylesheet" href="../stylesheets/oj9.css">
    
    
<!-- Google Tag Manager -->
<script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f (https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore%28j,f) );
})(window,document,'script','dataLayer','GTM-5WLCZXC');</script>
<!-- End Google Tag Manager -->
  </head>
  
    
    
    <body dir="" data-md-color-primary="cyan" data-md-color-accent="cyan">
  
    <svg class="md-svg">
      <defs>
        
        
          <svg xmlns="http://www.w3.org/2000/svg" width="416" height="448" viewBox="0 0 416 448" id="__github"><path fill="currentColor" d="M160 304q0 10-3.125 20.5t-10.75 19T128 352t-18.125-8.5-10.75-19T96 304t3.125-20.5 10.75-19T128 256t18.125 8.5 10.75 19T160 304zm160 0q0 10-3.125 20.5t-10.75 19T288 352t-18.125-8.5-10.75-19T256 304t3.125-20.5 10.75-19T288 256t18.125 8.5 10.75 19T320 304zm40 0q0-30-17.25-51T296 232q-10.25 0-48.75 5.25Q229.5 240 208 240t-39.25-2.75Q130.75 232 120 232q-29.5 0-46.75 21T56 304q0 22 8 38.375t20.25 25.75 30.5 15 35 7.375 37.25 1.75h42q20.5 0 37.25-1.75t35-7.375 30.5-15 20.25-25.75T360 304zm56-44q0 51.75-15.25 82.75-9.5 19.25-26.375 33.25t-35.25 21.5-42.5 11.875-42.875 5.5T212 416q-19.5 0-35.5-.75t-36.875-3.125-38.125-7.5-34.25-12.875T37 371.5t-21.5-28.75Q0 312 0 260q0-59.25 34-99-6.75-20.5-6.75-42.5 0-29 12.75-54.5 27 0 47.5 9.875t47.25 30.875Q171.5 96 212 96q37 0 70 8 26.25-20.5 46.75-30.25T376 64q12.75 25.5 12.75 54.5 0 21.75-6.75 42 34 40 34 99.5z"/></svg>
        
      </defs>
    </svg>
    <input class="md-toggle" data-md-toggle="drawer" type="checkbox" id="__drawer" autocomplete="off">
    <input class="md-toggle" data-md-toggle="search" type="checkbox" id="__search" autocomplete="off">
    <label class="md-overlay" data-md-component="overlay" for="__drawer"></label>
    
      <a href="../#-xdump" tabindex="1" class="md-skip">
        
      </a>
    
    
      <!--
* Copyright (c) 2017, 2019 IBM Corp. and others
*
* This program and the accompanying materials are made
* available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution and is available at
* https://www.eclipse.org/legal/epl-2.0/ or the Apache
* License, Version 2.0 which accompanies this distribution and
* is available at https://www.apache.org/licenses/LICENSE-2.0.
*
* This Source Code may also be made available under the
* following Secondary Licenses when the conditions for such
* availability set forth in the Eclipse Public License, v. 2.0
* are satisfied: GNU General Public License, version 2 with
* the GNU Classpath Exception [1] and GNU General Public
* License, version 2 with the OpenJDK Assembly Exception [2].
*
* [1] https://www.gnu.org/software/classpath/license.html
* [2] http://openjdk.java.net/legal/assembly-exception.html
*
* SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0 WITH
* Classpath-exception-2.0 OR LicenseRef-GPL-2.0 WITH Assembly-exception
-->
<header class="md-header" data-md-component="header">
    <nav class="md-header-nav md-grid">
      <div class="md-flex">
        <div class="md-flex__cell md-flex__cell--shrink">
          <a href="https://www.eclipse.org/openj9/docs" title=" " class="md-header-nav__button md-logo">
            
              <img src="../cr/openj9_6b.png">
            
          </a>
        </div>
        <div class="md-flex__cell md-flex__cell--shrink">
          <label class="md-icon md-icon--menu md-header-nav__button" for="__drawer"></label>
        </div>
        <div class="md-flex__cell md-flex__cell--stretch">
          <div class="md-flex__ellipsis md-header-nav__title" data-md-component="title">
          </div>
        </div>
        <div class="md-flex__cell md-flex__cell--shrink">
          
            
              <label class="md-icon md-icon--search md-header-nav__button" for="search"></label>
              
<div class="md-search" data-md-component="search" role="dialog">
  <label class="md-search__overlay" for="__search"></label>
  <div class="md-search__inner" role="search">
    <form class="md-search__form" name="search">
      <input type="text" class="md-search__input" name="query" placeholder="Search" autocapitalize="off" autocorrect="off" autocomplete="off" spellcheck="false" data-md-component="query" data-md-state="active">
      <label class="md-icon md-search__icon" for="__search"></label>
      <button type="reset" class="md-icon md-search__icon" data-md-component="reset" tabindex="-1">
        &#xE5CD;
      </button>
    </form>
    <div class="md-search__output">
      <div class="md-search__scrollwrap" data-md-scrollfix>
        <div class="md-search-result" data-md-component="result">
          <div class="md-search-result__meta">
            
          </div>
          <ol class="md-search-result__list"></ol>
        </div>
      </div>
    </div>
  </div>
</div>
            
          
        </div>
        
          <div class="md-flex__cell md-flex__cell--shrink">
            <div class="md-header-nav__source">
              


  

<a href="https://github.com/eclipse/openj9-docs/" title="Go to repository" class="md-source" data-md-source="github">
  
    <div class="md-source__icon">
      <svg viewBox="0 0 24 24" width="24" height="24">
        <use xlink:href="#__github" width="24" height="24"></use>
      </svg>
    </div>
  
  <div class="md-source__repository">
    GitHub
  </div>
</a>
            </div>
          </div>
        

        <!-- Eclipse Incubator link -->
        <div class="md-flex__cell md-flex__cell--shrink">
          <a href="http://wiki.eclipse.org/Development_Resources/Process_Guidelines/What_is_Incubation" target="_blank"><img class="egg" src="../cr/egg-incubation.png" alt="Eclipse Incubation"></a>
        </div>

      </div>
    </nav>
  </header>
    
    <div class="md-container">
      
        
      
      
      <main class="md-main">
        <div class="md-main__inner md-grid" data-md-component="container">
          
            
              <div class="md-sidebar md-sidebar--primary" data-md-component="navigation">
                <div class="md-sidebar__scrollwrap">
                  <div class="md-sidebar__inner">
                    <nav class="md-nav md-nav--primary" data-md-level="0">
  <label class="md-nav__title md-nav__title--site" for="__drawer">
    <a href="https://www.eclipse.org/openj9/docs" title=" " class="md-nav__button md-logo">
      
        <img src="../cr/openj9_6b.png" width="48" height="48">
      
    </a>
     
  </label>
  
    <div class="md-nav__source">
      


  

<a href="https://github.com/eclipse/openj9-docs/" title="Go to repository" class="md-source" data-md-source="github">
  
    <div class="md-source__icon">
      <svg viewBox="0 0 24 24" width="24" height="24">
        <use xlink:href="#__github" width="24" height="24"></use>
      </svg>
    </div>
  
  <div class="md-source__repository">
    GitHub
  </div>
</a>
    </div>
  
  <ul class="md-nav__list" data-md-scrollfix>
    
      
      
      


  <li class="md-nav__item">
    <a href=".." title="About" class="md-nav__link">
      About
    </a>
  </li>

    
      
      
      


  <li class="md-nav__item">
    <a href="../adoptopenjdk/" title="AdoptOpenJDK builds" class="md-nav__link">
      AdoptOpenJDK builds
    </a>
  </li>

    
      
      
      


  <li class="md-nav__item">
    <a href="../introduction/" title="Getting started" class="md-nav__link">
      Getting started
    </a>
  </li>

    
      
      
      


  <li class="md-nav__item">
    <a href="../openj9_newuser/" title="New to OpenJ9?" class="md-nav__link">
      New to OpenJ9?
    </a>
  </li>

    
      
      
      


  <li class="md-nav__item md-nav__item--nested">
    
      <input class="md-toggle md-nav__toggle" data-md-toggle="nav-5" type="checkbox" id="nav-5">
    
    <label class="md-nav__link" for="nav-5">
      Release notes
    </label>
    <nav class="md-nav" data-md-component="collapsible" data-md-level="1">
      <label class="md-nav__title" for="nav-5">
        Release notes
      </label>
      <ul class="md-nav__list" data-md-scrollfix>
        
        
          
          
          


  <li class="md-nav__item">
    <a href="../version0.17/" title="Version 0.17.0" class="md-nav__link">
      Version 0.17.0
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../version0.16/" title="Version 0.16.0" class="md-nav__link">
      Version 0.16.0
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../version0.15/" title="Version 0.15.1" class="md-nav__link">
      Version 0.15.1
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../version0.14/" title="Version 0.14.0" class="md-nav__link">
      Version 0.14.0
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item md-nav__item--nested">
    
      <input class="md-toggle md-nav__toggle" data-md-toggle="nav-5-5" type="checkbox" id="nav-5-5">
    
    <label class="md-nav__link" for="nav-5-5">
      Earlier releases
    </label>
    <nav class="md-nav" data-md-component="collapsible" data-md-level="2">
      <label class="md-nav__title" for="nav-5-5">
        Earlier releases
      </label>
      <ul class="md-nav__list" data-md-scrollfix>
        
        
          
          
          


  <li class="md-nav__item">
    <a href="../version0.13/" title="Version 0.13.0" class="md-nav__link">
      Version 0.13.0
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../version0.12/" title="Version 0.12.0" class="md-nav__link">
      Version 0.12.0
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../version0.11/" title="Version 0.11.0" class="md-nav__link">
      Version 0.11.0
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../version0.10/" title="Version 0.10.0" class="md-nav__link">
      Version 0.10.0
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../version0.9/" title="Version 0.9.0" class="md-nav__link">
      Version 0.9.0
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../version0.8/" title="Version 0.8.0" class="md-nav__link">
      Version 0.8.0
    </a>
  </li>

        
      </ul>
    </nav>
  </li>

        
      </ul>
    </nav>
  </li>

    
      
      
      


  <li class="md-nav__item">
    <a href="../gc/" title="Garbage Collection" class="md-nav__link">
      Garbage Collection
    </a>
  </li>

    
      
      
      


  <li class="md-nav__item">
    <a href="../jit/" title="JIT Compiler" class="md-nav__link">
      JIT Compiler
    </a>
  </li>

    
      
      
      


  <li class="md-nav__item">
    <a href="../aot/" title="AOT Compiler" class="md-nav__link">
      AOT Compiler
    </a>
  </li>

    
      
      
      


  <li class="md-nav__item md-nav__item--nested">
    
      <input class="md-toggle md-nav__toggle" data-md-toggle="nav-9" type="checkbox" id="nav-9">
    
    <label class="md-nav__link" for="nav-9">
      Class data sharing
    </label>
    <nav class="md-nav" data-md-component="collapsible" data-md-level="1">
      <label class="md-nav__title" for="nav-9">
        Class data sharing
      </label>
      <ul class="md-nav__list" data-md-scrollfix>
        
        
          
          
          


  <li class="md-nav__item">
    <a href="../shrc/" title="Overview" class="md-nav__link">
      Overview
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../shrc_diag_util/" title="Diagnostic cache utilities" class="md-nav__link">
      Diagnostic cache utilities
    </a>
  </li>

        
      </ul>
    </nav>
  </li>

    
      
      
      


  <li class="md-nav__item md-nav__item--nested">
    
      <input class="md-toggle md-nav__toggle" data-md-toggle="nav-10" type="checkbox" id="nav-10">
    
    <label class="md-nav__link" for="nav-10">
      Diagnostics
    </label>
    <nav class="md-nav" data-md-component="collapsible" data-md-level="1">
      <label class="md-nav__title" for="nav-10">
        Diagnostics
      </label>
      <ul class="md-nav__list" data-md-scrollfix>
        
        
          
          
          


  <li class="md-nav__item">
    <a href="../diag_overview/" title="Overview" class="md-nav__link">
      Overview
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item md-nav__item--nested">
    
      <input class="md-toggle md-nav__toggle" data-md-toggle="nav-10-2" type="checkbox" id="nav-10-2">
    
    <label class="md-nav__link" for="nav-10-2">
      Dumps
    </label>
    <nav class="md-nav" data-md-component="collapsible" data-md-level="2">
      <label class="md-nav__title" for="nav-10-2">
        Dumps
      </label>
      <ul class="md-nav__list" data-md-scrollfix>
        
        
          
          
          


  <li class="md-nav__item">
    <a href="../dump_javadump/" title="Java dump" class="md-nav__link">
      Java dump
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../dump_heapdump/" title="Heap dump" class="md-nav__link">
      Heap dump
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../dump_systemdump/" title="System dump" class="md-nav__link">
      System dump
    </a>
  </li>

        
      </ul>
    </nav>
  </li>

        
          
          
          


  <li class="md-nav__item md-nav__item--nested">
    
      <input class="md-toggle md-nav__toggle" data-md-toggle="nav-10-3" type="checkbox" id="nav-10-3">
    
    <label class="md-nav__link" for="nav-10-3">
      Tools
    </label>
    <nav class="md-nav" data-md-component="collapsible" data-md-level="2">
      <label class="md-nav__title" for="nav-10-3">
        Tools
      </label>
      <ul class="md-nav__list" data-md-scrollfix>
        
        
          
          
          


  <li class="md-nav__item">
    <a href="../tool_jextract/" title="Dump extractor" class="md-nav__link">
      Dump extractor
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../tool_jdmpview/" title="Dump viewer" class="md-nav__link">
      Dump viewer
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../tool_traceformat/" title="Trace formatter" class="md-nav__link">
      Trace formatter
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../tool_builder/" title="Option builder" class="md-nav__link">
      Option builder
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../tool_jcmd/" title="Java command (jcmd) tool" class="md-nav__link">
      Java command (jcmd) tool
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../tool_jmap/" title="Java memory map (jmap) tool" class="md-nav__link">
      Java memory map (jmap) tool
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../tool_jps/" title="Java process status (jps)" class="md-nav__link">
      Java process status (jps)
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../tool_jstack/" title="Java stack (jstack) tool" class="md-nav__link">
      Java stack (jstack) tool
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../tool_migration/" title="Switching to OpenJ9" class="md-nav__link">
      Switching to OpenJ9
    </a>
  </li>

        
      </ul>
    </nav>
  </li>

        
          
          
          


  <li class="md-nav__item md-nav__item--nested">
    
      <input class="md-toggle md-nav__toggle" data-md-toggle="nav-10-4" type="checkbox" id="nav-10-4">
    
    <label class="md-nav__link" for="nav-10-4">
      Interfaces
    </label>
    <nav class="md-nav" data-md-component="collapsible" data-md-level="2">
      <label class="md-nav__title" for="nav-10-4">
        Interfaces
      </label>
      <ul class="md-nav__list" data-md-scrollfix>
        
        
          
          
          


  <li class="md-nav__item">
    <a href="../interface_jvmti/" title="JVMTI" class="md-nav__link">
      JVMTI
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../interface_dtfj/" title="DTFJ" class="md-nav__link">
      DTFJ
    </a>
  </li>

        
      </ul>
    </nav>
  </li>

        
      </ul>
    </nav>
  </li>

    
      
      
      

  


  <li class="md-nav__item md-nav__item--active md-nav__item--nested">
    
      <input class="md-toggle md-nav__toggle" data-md-toggle="nav-11" type="checkbox" id="nav-11" checked>
    
    <label class="md-nav__link" for="nav-11">
      Command-line options
    </label>
    <nav class="md-nav" data-md-component="collapsible" data-md-level="1">
      <label class="md-nav__title" for="nav-11">
        Command-line options
      </label>
      <ul class="md-nav__list" data-md-scrollfix>
        
        
          
          
          


  <li class="md-nav__item">
    <a href="../cmdline_specifying/" title="Specifying options" class="md-nav__link">
      Specifying options
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../cmdline_general/" title="Standard options" class="md-nav__link">
      Standard options
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../cmdline_migration/" title="Switching to OpenJ9" class="md-nav__link">
      Switching to OpenJ9
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item md-nav__item--nested">
    
      <input class="md-toggle md-nav__toggle" data-md-toggle="nav-11-4" type="checkbox" id="nav-11-4">
    
    <label class="md-nav__link" for="nav-11-4">
      System property options
    </label>
    <nav class="md-nav" data-md-component="collapsible" data-md-level="2">
      <label class="md-nav__title" for="nav-11-4">
        System property options
      </label>
      <ul class="md-nav__list" data-md-scrollfix>
        
        
          
          
          


  <li class="md-nav__item">
    <a href="../d_jvm_commands/" title="Using System properties" class="md-nav__link">
      Using System properties
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../dcomibmenableclasscaching/" title="-Dcom.ibm.enableClassCaching" class="md-nav__link">
      -Dcom.ibm.enableClassCaching
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../dcomibmenablelegacydumpsecurity/" title="-Dcom.ibm.enableLegacyDumpSecurity" class="md-nav__link">
      -Dcom.ibm.enableLegacyDumpSecurity
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../dcomibmenablelegacylogsecurity/" title="-Dcom.ibm.enableLegacyLogSecurity" class="md-nav__link">
      -Dcom.ibm.enableLegacyLogSecurity
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../dcomibmenablelegacytracesecurity/" title="-Dcom.ibm.enableLegacyTraceSecurity" class="md-nav__link">
      -Dcom.ibm.enableLegacyTraceSecurity
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../dcomibmgpudisable/" title="-Dcom.ibm.gpu.disable" class="md-nav__link">
      -Dcom.ibm.gpu.disable
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../dcomibmgpuenable/" title="-Dcom.ibm.gpu.enable" class="md-nav__link">
      -Dcom.ibm.gpu.enable
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../dcomibmgpuverbose/" title="-Dcom.ibm.gpu.verbose" class="md-nav__link">
      -Dcom.ibm.gpu.verbose
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../dcomibmlangmanagementosmxbeaniscputime100ns/" title="-Dcom.ibm.lang.management.OperatingSystemMXBean.isCpuTime100ns" class="md-nav__link">
      -Dcom.ibm.lang.management.OperatingSystemMXBean.isCpuTime100ns
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../dcomibmlangmanagementverbose/" title="-Dcom.ibm.lang.management.verbose" class="md-nav__link">
      -Dcom.ibm.lang.management.verbose
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../dcomibmtoolsattachdirectory/" title="-Dcom.ibm.tools.attach.directory" class="md-nav__link">
      -Dcom.ibm.tools.attach.directory
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../dcomibmtoolsattachdisplayname/" title="-Dcom.ibm.tools.attach.displayName" class="md-nav__link">
      -Dcom.ibm.tools.attach.displayName
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../dcomibmtoolsattachenable/" title="-Dcom.ibm.tools.attach.enable" class="md-nav__link">
      -Dcom.ibm.tools.attach.enable
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../dcomibmtoolsattachid/" title="-Dcom.ibm.tools.attach.id" class="md-nav__link">
      -Dcom.ibm.tools.attach.id
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../dcomibmtoolsattachtimeout/" title="-Dcom.ibm.tools.attach.timeout" class="md-nav__link">
      -Dcom.ibm.tools.attach.timeout
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../dfileencoding/" title="-Dfile.encoding" class="md-nav__link">
      -Dfile.encoding
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../djavacompiler/" title="-Djava.compiler" class="md-nav__link">
      -Djava.compiler
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../djdknativecbc/" title="-Djdk.nativeCBC" class="md-nav__link">
      -Djdk.nativeCBC
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../djdknativechacha20/" title="-Djdk.nativeChaCha20" class="md-nav__link">
      -Djdk.nativeChaCha20
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../djdknativecrypto/" title="-Djdk.nativeCrypto" class="md-nav__link">
      -Djdk.nativeCrypto
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../djdknativedigest/" title="-Djdk.nativeDigest" class="md-nav__link">
      -Djdk.nativeDigest
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../djdknativegcm/" title="-Djdk.nativeGCM" class="md-nav__link">
      -Djdk.nativeGCM
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../djdknativersa/" title="-Djdk.nativeRSA" class="md-nav__link">
      -Djdk.nativeRSA
    </a>
  </li>

        
      </ul>
    </nav>
  </li>

        
          
          
          

  


  <li class="md-nav__item md-nav__item--active md-nav__item--nested">
    
      <input class="md-toggle md-nav__toggle" data-md-toggle="nav-11-5" type="checkbox" id="nav-11-5" checked>
    
    <label class="md-nav__link" for="nav-11-5">
      JVM -X options
    </label>
    <nav class="md-nav" data-md-component="collapsible" data-md-level="2">
      <label class="md-nav__title" for="nav-11-5">
        JVM -X options
      </label>
      <ul class="md-nav__list" data-md-scrollfix>
        
        
          
          
          


  <li class="md-nav__item">
    <a href="../x_jvm_commands/" title="Using -X options" class="md-nav__link">
      Using -X options
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../x/" title="-X" class="md-nav__link">
      -X
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xaggressive/" title="-Xaggressive" class="md-nav__link">
      -Xaggressive
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xalwaysclassgc/" title="-Xalwaysclassgc" class="md-nav__link">
      -Xalwaysclassgc
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xaot/" title="-Xaot" class="md-nav__link">
      -Xaot
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xargencoding/" title="-Xargencoding" class="md-nav__link">
      -Xargencoding
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xbootclasspath/" title="-Xbootclasspath" class="md-nav__link">
      -Xbootclasspath
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xceehdlr/" title="-XCEEHDLR" class="md-nav__link">
      -XCEEHDLR
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xcheck/" title="-Xcheck" class="md-nav__link">
      -Xcheck
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xclassgc/" title="-Xclassgc" class="md-nav__link">
      -Xclassgc
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xcodecache/" title="-Xcodecache" class="md-nav__link">
      -Xcodecache
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xcodecachetotal/" title="-Xcodecachetotal" class="md-nav__link">
      -Xcodecachetotal
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xcomp/" title="-Xcomp" class="md-nav__link">
      -Xcomp
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xcompactexplicitgc/" title="-Xcompactexplicitgc" class="md-nav__link">
      -Xcompactexplicitgc
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xcompactgc/" title="-Xcompactgc" class="md-nav__link">
      -Xcompactgc
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xcompilationthreads/" title="-XcompilationThreads" class="md-nav__link">
      -XcompilationThreads
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xcompressedrefs/" title="-Xcompressedrefs" class="md-nav__link">
      -Xcompressedrefs
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xconcurrentbackground/" title="-Xconcurrentbackground" class="md-nav__link">
      -Xconcurrentbackground
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xconcurrentlevel/" title="-Xconcurrentlevel" class="md-nav__link">
      -Xconcurrentlevel
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xconcurrentslack/" title="-Xconcurrentslack" class="md-nav__link">
      -Xconcurrentslack
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xconmeter/" title="-Xconmeter" class="md-nav__link">
      -Xconmeter
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xenableexcessivegc/" title="-Xdisableexcessivegc" class="md-nav__link">
      -Xdisableexcessivegc
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xenableexplicitgc/" title="-Xdisableexplicitgc" class="md-nav__link">
      -Xdisableexplicitgc
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xdisablejavadump/" title="-Xdisablejavadump" class="md-nav__link">
      -Xdisablejavadump
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xenablestringconstantgc/" title="-Xdisablestringconstantgc" class="md-nav__link">
      -Xdisablestringconstantgc
    </a>
  </li>

        
          
          
          

  


  <li class="md-nav__item md-nav__item--active">
    
    <input class="md-toggle md-nav__toggle" data-md-toggle="toc" type="checkbox" id="__toc">
    
      
    
    
      <label class="md-nav__link md-nav__link--active" for="__toc">
        -Xdump
      </label>
    
    <a href="./" title="-Xdump" class="md-nav__link md-nav__link--active">
      -Xdump
    </a>
    
      
<nav class="md-nav md-nav--secondary">
  
  
    
  
  
    <label class="md-nav__title" for="__toc">On this page ...</label>
    <ul class="md-nav__list" data-md-scrollfix>
      
        <li class="md-nav__item">
  <a href="#xdump-option-builder" class="md-nav__link">
    Xdump Option Builder
  </a>
  
</li>
      
        <li class="md-nav__item">
  <a href="#syntax" class="md-nav__link">
    Syntax
  </a>
  
</li>
      
        <li class="md-nav__item">
  <a href="#dump-agents" class="md-nav__link">
    Dump agents
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#default-dump-agents" class="md-nav__link">
    Default dump agents
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#dump-agent-tokens" class="md-nav__link">
    Dump agent tokens
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#merging-xdump-agents" class="md-nav__link">
    Merging -Xdump agents
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
      
        <li class="md-nav__item">
  <a href="#dump-events" class="md-nav__link">
    Dump events
  </a>
  
</li>
      
        <li class="md-nav__item">
  <a href="#parameters" class="md-nav__link">
    Parameters
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#help" class="md-nav__link">
    help
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#noneltoptionsgt" class="md-nav__link">
    none:&lt;options&gt;
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#defaults" class="md-nav__link">
    defaults
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#eventslteventgt" class="md-nav__link">
    events=&lt;event&gt;
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#execltcommandgt" class="md-nav__link">
    exec=&lt;command&gt;
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#fileltfilenamegt" class="md-nav__link">
    file=&lt;filename&gt;
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#writing-to-stdoutstderr" class="md-nav__link">
    Writing to STDOUT/STDERR
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#tokens" class="md-nav__link">
    Tokens
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#file-location" class="md-nav__link">
    File location
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
        
          <li class="md-nav__item">
  <a href="#filterltfiltergt" class="md-nav__link">
    filter=&lt;filter&gt;
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#wildcards" class="md-nav__link">
    Wildcards
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#class-loading-and-exception-events" class="md-nav__link">
    Class loading and exception events
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#vmstop-event" class="md-nav__link">
    vmstop event
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#slow-event" class="md-nav__link">
    slow event
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#allocation-event" class="md-nav__link">
    allocation event
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#other-events" class="md-nav__link">
    Other events
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
        
          <li class="md-nav__item">
  <a href="#msg_filterltfiltergt" class="md-nav__link">
    msg_filter=&lt;filter&gt;
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#optsltoptionsgt" class="md-nav__link">
    opts=&lt;options&gt;
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#heap-dumps" class="md-nav__link">
    Heap dumps
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#zos-system-dumps" class="md-nav__link">
    z/OS system dumps
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#tool-dumps" class="md-nav__link">
    Tool dumps
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
        
          <li class="md-nav__item">
  <a href="#prioritylt0-999gt" class="md-nav__link">
    priority=&lt;0-999&gt;
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#rangeltrangesgt" class="md-nav__link">
    range=&lt;ranges&gt;
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#requestltrequestsgt" class="md-nav__link">
    request=&lt;requests&gt;
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
      
        <li class="md-nav__item">
  <a href="#dump-output" class="md-nav__link">
    Dump output
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#system-dumps-on-linux" class="md-nav__link">
    System dumps on Linux
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
      
        <li class="md-nav__item">
  <a href="#see-also" class="md-nav__link">
    See also
  </a>
  
</li>
      
      
      
      
      
    </ul>
  
</nav>
    
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xenableexcessivegc/" title="-Xenableexcessivegc" class="md-nav__link">
      -Xenableexcessivegc
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xenableexplicitgc/" title="-Xenableexplicitgc" class="md-nav__link">
      -Xenableexplicitgc
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xenablestringconstantgc/" title="-Xenablestringconstantgc" class="md-nav__link">
      -Xenablestringconstantgc
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xfastresolve/" title="-Xfastresolve" class="md-nav__link">
      -Xfastresolve
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xfuture/" title="-Xfuture" class="md-nav__link">
      -Xfuture
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xgc/" title="-Xgc" class="md-nav__link">
      -Xgc
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xgcsplitheap/" title="-Xgc:splitheap" class="md-nav__link">
      -Xgc:splitheap
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xgcpolicy/" title="-Xgcpolicy" class="md-nav__link">
      -Xgcpolicy
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xgcthreads/" title="-Xgcthreads" class="md-nav__link">
      -Xgcthreads
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xgcworkpackets/" title="-Xgcworkpackets" class="md-nav__link">
      -Xgcworkpackets
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xifa/" title="-Xifa" class="md-nav__link">
      -Xifa
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xint/" title="-Xint" class="md-nav__link">
      -Xint
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xss/" title="-Xiss" class="md-nav__link">
      -Xiss
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xjit/" title="-Xjit" class="md-nav__link">
      -Xjit
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xjni/" title="-Xjni" class="md-nav__link">
      -Xjni
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xlinenumbers/" title="-Xlinenumbers" class="md-nav__link">
      -Xlinenumbers
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xloa/" title="-Xloa" class="md-nav__link">
      -Xloa
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xloaminimum/" title="-Xloainitial" class="md-nav__link">
      -Xloainitial
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xloaminimum/" title="-Xloamaximum" class="md-nav__link">
      -Xloamaximum
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xloaminimum/" title="-Xloaminimum" class="md-nav__link">
      -Xloaminimum
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xlockreservation/" title="-XlockReservation" class="md-nav__link">
      -XlockReservation
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xlockword/" title="-Xlockword" class="md-nav__link">
      -Xlockword
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xlog/" title="-Xlog" class="md-nav__link">
      -Xlog
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xlp/" title="-Xlp" class="md-nav__link">
      -Xlp
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xlpcodecache/" title="-Xlp:codecache" class="md-nav__link">
      -Xlp:codecache
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xlpobjectheap/" title="-Xlp:objectheap" class="md-nav__link">
      -Xlp:objectheap
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xmine/" title="-Xmaxe" class="md-nav__link">
      -Xmaxe
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xminf/" title="-Xmaxf" class="md-nav__link">
      -Xmaxf
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xmint/" title="-Xmaxt" class="md-nav__link">
      -Xmaxt
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xmca/" title="-Xmca" class="md-nav__link">
      -Xmca
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xmca/" title="-Xmco" class="md-nav__link">
      -Xmco
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xmcrs/" title="-Xmcrs" class="md-nav__link">
      -Xmcrs
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xmine/" title="-Xmine" class="md-nav__link">
      -Xmine
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xminf/" title="-Xminf" class="md-nav__link">
      -Xminf
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xmint/" title="-Xmint" class="md-nav__link">
      -Xmint
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xmn/" title="-Xmn" class="md-nav__link">
      -Xmn
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xmn/" title="-Xmns" class="md-nav__link">
      -Xmns
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xmn/" title="-Xmnx" class="md-nav__link">
      -Xmnx
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xmo/" title="-Xmo" class="md-nav__link">
      -Xmo
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xmo/" title="-Xmoi" class="md-nav__link">
      -Xmoi
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xmo/" title="-Xmos" class="md-nav__link">
      -Xmos
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xmo/" title="-Xmox" class="md-nav__link">
      -Xmox
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xmr/" title="-Xmr" class="md-nav__link">
      -Xmr
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xmr/" title="-Xmrx" class="md-nav__link">
      -Xmrx
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xms/" title="-Xms" class="md-nav__link">
      -Xms
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xmso/" title="-Xmso" class="md-nav__link">
      -Xmso
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xms/" title="-Xmx" class="md-nav__link">
      -Xmx
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xaot/" title="-Xnoaot" class="md-nav__link">
      -Xnoaot
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xclassgc/" title="-Xnoclassgc" class="md-nav__link">
      -Xnoclassgc
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xcompactexplicitgc/" title="-Xnocompactexplicitgc" class="md-nav__link">
      -Xnocompactexplicitgc
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xcompactgc/" title="-Xnocompactgc" class="md-nav__link">
      -Xnocompactgc
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xcompressedrefs/" title="-Xnocompressedrefs" class="md-nav__link">
      -Xnocompressedrefs
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xjit/" title="-Xnojit" class="md-nav__link">
      -Xnojit
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xlinenumbers/" title="-Xnolinenumbers" class="md-nav__link">
      -Xnolinenumbers
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xloa/" title="-Xnoloa" class="md-nav__link">
      -Xnoloa
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xsigcatch/" title="-Xnosigcatch" class="md-nav__link">
      -Xnosigcatch
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xsigchain/" title="-Xnosigchain" class="md-nav__link">
      -Xnosigchain
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xnumanone/" title="-Xnuma:none" class="md-nav__link">
      -Xnuma:none
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xoptionsfile/" title="-Xoptionsfile" class="md-nav__link">
      -Xoptionsfile
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xquickstart/" title="-Xquickstart" class="md-nav__link">
      -Xquickstart
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xrs/" title="-Xrs" class="md-nav__link">
      -Xrs
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xsamplingexpirationtime/" title="-XsamplingExpirationTime" class="md-nav__link">
      -XsamplingExpirationTime
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xscdmx/" title="-Xscdmx" class="md-nav__link">
      -Xscdmx
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xscminaot/" title="-Xscmaxaot" class="md-nav__link">
      -Xscmaxaot
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xscminjitdata/" title="-Xscmaxjitdata" class="md-nav__link">
      -Xscmaxjitdata
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xscminaot/" title="-Xscminaot" class="md-nav__link">
      -Xscminaot
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xscminjitdata/" title="-Xscminjitdata" class="md-nav__link">
      -Xscminjitdata
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xscmx/" title="-Xscmx" class="md-nav__link">
      -Xscmx
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xshareclasses/" title="-Xshareclasses" class="md-nav__link">
      -Xshareclasses
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xsigcatch/" title="-Xsigcatch" class="md-nav__link">
      -Xsigcatch
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xsigchain/" title="-Xsigchain" class="md-nav__link">
      -Xsigchain
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xsignal/" title="-Xsignal" class="md-nav__link">
      -Xsignal
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xsoftmx/" title="-Xsoftmx" class="md-nav__link">
      -Xsoftmx
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xsoftrefthreshold/" title="-Xsoftrefthreshold" class="md-nav__link">
      -Xsoftrefthreshold
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xss/" title="-Xss" class="md-nav__link">
      -Xss
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xss/" title="-Xssi" class="md-nav__link">
      -Xssi
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xtgc/" title="-Xtgc" class="md-nav__link">
      -Xtgc
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xthr/" title="-Xthr" class="md-nav__link">
      -Xthr
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xtlhprefetch/" title="-XtlhPrefetch" class="md-nav__link">
      -XtlhPrefetch
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xtrace/" title="-Xtrace" class="md-nav__link">
      -Xtrace
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xtunevirtualized/" title="-Xtune:virtualized" class="md-nav__link">
      -Xtune:virtualized
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xverbosegclog/" title="-Xverbosegclog" class="md-nav__link">
      -Xverbosegclog
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xverify/" title="-Xverify" class="md-nav__link">
      -Xverify
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xzero/" title="-Xzero" class="md-nav__link">
      -Xzero
    </a>
  </li>

        
      </ul>
    </nav>
  </li>

        
          
          
          


  <li class="md-nav__item md-nav__item--nested">
    
      <input class="md-toggle md-nav__toggle" data-md-toggle="nav-11-6" type="checkbox" id="nav-11-6">
    
    <label class="md-nav__link" for="nav-11-6">
      JVM -XX options
    </label>
    <nav class="md-nav" data-md-component="collapsible" data-md-level="2">
      <label class="md-nav__title" for="nav-11-6">
        JVM -XX options
      </label>
      <ul class="md-nav__list" data-md-scrollfix>
        
        
          
          
          


  <li class="md-nav__item">
    <a href="../xx_jvm_commands/" title="Using -XX options" class="md-nav__link">
      Using -XX options
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxactiveprocessorcount/" title="-XXActiveProcessorCount" class="md-nav__link">
      -XXActiveProcessorCount
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxallowvmshutdown/" title="-XXallowvmshutdown" class="md-nav__link">
      -XXallowvmshutdown
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxclassrelationshipverifier/" title="-XX:[+|-]ClassRelationshipVerifier" class="md-nav__link">
      -XX:[+|-]ClassRelationshipVerifier
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxcodecachetotal/" title="-XX:codecachetotal" class="md-nav__link">
      -XX:codecachetotal
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxcompactstrings/" title="-XX:[+|-]CompactStrings" class="md-nav__link">
      -XX:[+|-]CompactStrings
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxdisableexplicitgc/" title="-XX:[+|-]DisableExplicitGC" class="md-nav__link">
      -XX:[+|-]DisableExplicitGC
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxdisclaimjitscratch/" title="-XX:[+|-]DisclaimJitScratch" class="md-nav__link">
      -XX:[+|-]DisclaimJitScratch
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxenablecpumonitor/" title="-XX:[+|-]EnableCPUMonitor" class="md-nav__link">
      -XX:[+|-]EnableCPUMonitor
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxhandlesigxfsz/" title="-XX:[+|-]handleSIGXFSZ" class="md-nav__link">
      -XX:[+|-]handleSIGXFSZ
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxheapdumponoutofmemory/" title="-XX:[+|-]HeapDumpOnOutOfMemory" class="md-nav__link">
      -XX:[+|-]HeapDumpOnOutOfMemory
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxheapdumppath/" title="-XX:HeapDumpPath" class="md-nav__link">
      -XX:HeapDumpPath
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxheapmanagementmxbeancompatibility/" title="-XX:[+|-]HeapManagementMXBeanCompatibility" class="md-nav__link">
      -XX:[+|-]HeapManagementMXBeanCompatibility
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxidletuningcompactonidle/" title="-XX:[+|-]IdleTuningCompactOnIdle" class="md-nav__link">
      -XX:[+|-]IdleTuningCompactOnIdle
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxidletuninggconidle/" title="-XX:[+|-]IdleTuningGcOnIdle" class="md-nav__link">
      -XX:[+|-]IdleTuningGcOnIdle
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxidletuningminfreeheaponidle/" title="-XX:IdleTuningMinFreeHeapOnIdle" class="md-nav__link">
      -XX:IdleTuningMinFreeHeapOnIdle
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxidletuningminidlewaittime/" title="-XX:IdleTuningMinIdleWaitTime" class="md-nav__link">
      -XX:IdleTuningMinIdleWaitTime
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxignoreunrecognizedvmoptions/" title="-XX:[+|-]IgnoreUnrecognizedVMOptions" class="md-nav__link">
      -XX:[+|-]IgnoreUnrecognizedVMOptions
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxignoreunrecognizedxxcolonoptions/" title="-XX:[+|-]IgnoreUnrecognizedXXColonOptions" class="md-nav__link">
      -XX:[+|-]IgnoreUnrecognizedXXColonOptions
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxinitialrampercentage/" title="-XX:InitialRAMPercentage" class="md-nav__link">
      -XX:InitialRAMPercentage
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxinitialheapsize/" title="-XX:InitialHeapSize" class="md-nav__link">
      -XX:InitialHeapSize
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxinterleavememory/" title="-XX:[+|-]InterleaveMemory" class="md-nav__link">
      -XX:[+|-]InterleaveMemory
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxjitinlinewatches/" title="-XX:[+|-]JITInlineWatches" class="md-nav__link">
      -XX:[+|-]JITInlineWatches
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxlazysymbolresolution/" title="-XX:[+|-]LazySymbolResolution" class="md-nav__link">
      -XX:[+|-]LazySymbolResolution
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxmaxdirectmemorysize/" title="-XX:MaxDirectMemorySize" class="md-nav__link">
      -XX:MaxDirectMemorySize
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxinitialheapsize/" title="-XX:MaxHeapSize" class="md-nav__link">
      -XX:MaxHeapSize
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxinitialrampercentage/" title="-XX:MaxRAMPercentage" class="md-nav__link">
      -XX:MaxRAMPercentage
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxonoutofmemoryerror/" title="-XX:OnOutOfMemoryError" class="md-nav__link">
      -XX:OnOutOfMemoryError
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxnosuballoc32bitmem/" title="-XXnosuballoc32bitmem" class="md-nav__link">
      -XXnosuballoc32bitmem
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxpagealigndirectmemory/" title="-XX:[+|-]PageAlignDirectMemory" class="md-nav__link">
      -XX:[+|-]PageAlignDirectMemory
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxpositiveidentityhash/" title="-XX:[+|-]PositiveIdentityHash" class="md-nav__link">
      -XX:[+|-]PositiveIdentityHash
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxreadipinfoforras/" title="-XX:[+|-]ReadIPInfoForRAS" class="md-nav__link">
      -XX:[+|-]ReadIPInfoForRAS
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxreducecpumonitoroverhead/" title="-XX:[+|-]ReduceCPUMonitorOverhead" class="md-nav__link">
      -XX:[+|-]ReduceCPUMonitorOverhead
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxruntimeinstrumentation/" title="-XX:[+|-]RuntimeInstrumentation" class="md-nav__link">
      -XX:[+|-]RuntimeInstrumentation
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxsethwprefetch/" title="-XXsetHWPrefetch" class="md-nav__link">
      -XXsetHWPrefetch
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxshareanonymousclasses/" title="-XX:[+|-]ShareAnonymousClasses" class="md-nav__link">
      -XX:[+|-]ShareAnonymousClasses
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxshareclassesenablebci/" title="-XX:ShareClassesDisableBCI" class="md-nav__link">
      -XX:ShareClassesDisableBCI
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxshareclassesenablebci/" title="-XX:ShareClassesEnableBCI" class="md-nav__link">
      -XX:ShareClassesEnableBCI
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxsharedcachehardlimit/" title="-XX:SharedCacheHardLimit" class="md-nav__link">
      -XX:SharedCacheHardLimit
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxshareunsafeclasses/" title="-XX:[+|-]ShareUnsafeClasses" class="md-nav__link">
      -XX:[+|-]ShareUnsafeClasses
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxstacktraceinthrowable/" title="-XX:-StackTraceInThrowable" class="md-nav__link">
      -XX:-StackTraceInThrowable
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxtransparenthugepage/" title="-XX:[+|-]TransparentHugePage" class="md-nav__link">
      -XX:[+|-]TransparentHugePage
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxusecompressedoops/" title="-XX:[+|-]UseCompressedOops" class="md-nav__link">
      -XX:[+|-]UseCompressedOops
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxusecontainersupport/" title="-XX:[+|-]UseContainerSupport" class="md-nav__link">
      -XX:[+|-]UseContainerSupport
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxusegcstartuphints/" title="-XX:[+|-]UseGCStartupHints" class="md-nav__link">
      -XX:[+|-]UseGCStartupHints
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxusenogc/" title="-XX:[+|-]UseNoGC" class="md-nav__link">
      -XX:[+|-]UseNoGC
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxverboseverification/" title="-XX:[+|-]VerboseVerification" class="md-nav__link">
      -XX:[+|-]VerboseVerification
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../xxvmlockclassloader/" title="-XX:[+|-]VMLockClassLoader" class="md-nav__link">
      -XX:[+|-]VMLockClassLoader
    </a>
  </li>

        
      </ul>
    </nav>
  </li>

        
      </ul>
    </nav>
  </li>

    
      
      
      


  <li class="md-nav__item md-nav__item--nested">
    
      <input class="md-toggle md-nav__toggle" data-md-toggle="nav-12" type="checkbox" id="nav-12">
    
    <label class="md-nav__link" for="nav-12">
       Reference
    </label>
    <nav class="md-nav" data-md-component="collapsible" data-md-level="1">
      <label class="md-nav__title" for="nav-12">
         Reference
      </label>
      <ul class="md-nav__list" data-md-scrollfix>
        
        
          
          
          


  <li class="md-nav__item">
    <a href="../openj9_support/" title="Supported environments" class="md-nav__link">
      Supported environments
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../openj9_defaults/" title="Default settings" class="md-nav__link">
      Default settings
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../openj9_directories/" title="Directory conventions" class="md-nav__link">
      Directory conventions
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../messages_intro/" title="OpenJ9 messages" class="md-nav__link">
      OpenJ9 messages
    </a>
  </li>

        
          
          
          


  <li class="md-nav__item">
    <a href="../env_var/" title="Environment variables" class="md-nav__link">
      Environment variables
    </a>
  </li>

        
      </ul>
    </nav>
  </li>

    
      
      
      


  <li class="md-nav__item">
    <a href="../legal/" title="Legal" class="md-nav__link">
      Legal
    </a>
  </li>

    
  </ul>
</nav>
                  </div>
                </div>
              </div>
            
            
              <div class="md-sidebar md-sidebar--secondary" data-md-component="toc">
                <div class="md-sidebar__scrollwrap">
                  <div class="md-sidebar__inner">
                    
<nav class="md-nav md-nav--secondary">
  
  
    
  
  
    <label class="md-nav__title" for="__toc">On this page ...</label>
    <ul class="md-nav__list" data-md-scrollfix>
      
        <li class="md-nav__item">
  <a href="#xdump-option-builder" class="md-nav__link">
    Xdump Option Builder
  </a>
  
</li>
      
        <li class="md-nav__item">
  <a href="#syntax" class="md-nav__link">
    Syntax
  </a>
  
</li>
      
        <li class="md-nav__item">
  <a href="#dump-agents" class="md-nav__link">
    Dump agents
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#default-dump-agents" class="md-nav__link">
    Default dump agents
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#dump-agent-tokens" class="md-nav__link">
    Dump agent tokens
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#merging-xdump-agents" class="md-nav__link">
    Merging -Xdump agents
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
      
        <li class="md-nav__item">
  <a href="#dump-events" class="md-nav__link">
    Dump events
  </a>
  
</li>
      
        <li class="md-nav__item">
  <a href="#parameters" class="md-nav__link">
    Parameters
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#help" class="md-nav__link">
    help
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#noneltoptionsgt" class="md-nav__link">
    none:&lt;options&gt;
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#defaults" class="md-nav__link">
    defaults
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#eventslteventgt" class="md-nav__link">
    events=&lt;event&gt;
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#execltcommandgt" class="md-nav__link">
    exec=&lt;command&gt;
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#fileltfilenamegt" class="md-nav__link">
    file=&lt;filename&gt;
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#writing-to-stdoutstderr" class="md-nav__link">
    Writing to STDOUT/STDERR
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#tokens" class="md-nav__link">
    Tokens
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#file-location" class="md-nav__link">
    File location
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
        
          <li class="md-nav__item">
  <a href="#filterltfiltergt" class="md-nav__link">
    filter=&lt;filter&gt;
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#wildcards" class="md-nav__link">
    Wildcards
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#class-loading-and-exception-events" class="md-nav__link">
    Class loading and exception events
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#vmstop-event" class="md-nav__link">
    vmstop event
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#slow-event" class="md-nav__link">
    slow event
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#allocation-event" class="md-nav__link">
    allocation event
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#other-events" class="md-nav__link">
    Other events
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
        
          <li class="md-nav__item">
  <a href="#msg_filterltfiltergt" class="md-nav__link">
    msg_filter=&lt;filter&gt;
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#optsltoptionsgt" class="md-nav__link">
    opts=&lt;options&gt;
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#heap-dumps" class="md-nav__link">
    Heap dumps
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#zos-system-dumps" class="md-nav__link">
    z/OS system dumps
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#tool-dumps" class="md-nav__link">
    Tool dumps
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
        
          <li class="md-nav__item">
  <a href="#prioritylt0-999gt" class="md-nav__link">
    priority=&lt;0-999&gt;
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#rangeltrangesgt" class="md-nav__link">
    range=&lt;ranges&gt;
  </a>
  
</li>
        
          <li class="md-nav__item">
  <a href="#requestltrequestsgt" class="md-nav__link">
    request=&lt;requests&gt;
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
      
        <li class="md-nav__item">
  <a href="#dump-output" class="md-nav__link">
    Dump output
  </a>
  
    <nav class="md-nav">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#system-dumps-on-linux" class="md-nav__link">
    System dumps on Linux
  </a>
  
</li>
        
      </ul>
    </nav>
  
</li>
      
        <li class="md-nav__item">
  <a href="#see-also" class="md-nav__link">
    See also
  </a>
  
</li>
      
      
      
      
      
    </ul>
  
</nav>
                  </div>
                </div>
              </div>
            
          
          <div class="md-content">
            <article class="md-content__inner md-typeset">
              
<!-- this adds 'pencil' icon to H1 so that you can edit the page directly in GitHub
                
                  <a href="https://github.com/eclipse/openj9-docs/edit/master/docs/xdump.md" title="Edit this page" class="md-icon md-content__icon">&#xE3C9;</a>
                
-->
                
                <!--
* Copyright (c) 2017, 2019 IBM Corp. and others
*
* This program and the accompanying materials are made
* available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution and is available at
* https://www.eclipse.org/legal/epl-2.0/ or the Apache
* License, Version 2.0 which accompanies this distribution and
* is available at https://www.apache.org/licenses/LICENSE-2.0.
*
* This Source Code may also be made available under the
* following Secondary Licenses when the conditions for such
* availability set forth in the Eclipse Public License, v. 2.0
* are satisfied: GNU General Public License, version 2 with
* the GNU Classpath Exception [1] and GNU General Public
* License, version 2 with the OpenJDK Assembly Exception [2].
*
* [1] https://www.gnu.org/software/classpath/license.html
* [2] http://openjdk.java.net/legal/assembly-exception.html
*
* SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0 WITH
* Classpath-exception-2.0 OR LicenseRef-GPL-2.0 WITH Assembly-exception
-->

<h1 id="-xdump">-Xdump</h1>
<p>OpenJ9 produces various types of diagnostic information for analysis when different events occur, such as a general protection fault. The dumps produced are controlled by dump agents, which are initialized when the OpenJ9 virtual machine (VM) starts. The default settings for the dump agents are sufficient for most cases. However, you can use the <code>-Xdump</code> option on the command line to fine tune the dump agent settings. For example, you can use the <code>-Xdump</code> option to add and remove dump agents for various VM events, update default dump settings, and limit the number of dumps that are produced.</p>
<p>A large set of options and suboptions are available for controlling dumps, which provides a lot of flexibility.</p>
<h2 id="xdump-option-builder">Xdump Option Builder</h2>
<p>Use the <a href="https://www.eclipse.org/openj9/tools/xdump_option_builder.html" target="_blank">Xdump Option Builder tool</a> to help you specify the correct options and avoid incompatibilities.</p>
<h2 id="syntax">Syntax</h2>
<pre><code>    -Xdump:&lt;parameter&gt;
</code></pre>
<p>The following table lists the help options for <code>-Xdump</code>, which provide usage and configuration information:</p>
<table>
<thead>
<tr>
<th>Command</th>
<th>Result</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>-Xdump:help</code></td>
<td>Displays general dump help.</td>
</tr>
<tr>
<td><code>-Xdump:events</code></td>
<td>Lists available trigger events.</td>
</tr>
<tr>
<td><code>-Xdump:request</code></td>
<td>Lists additional VM requests.</td>
</tr>
<tr>
<td><code>-Xdump:tokens</code></td>
<td>Lists recognized label tokens.</td>
</tr>
<tr>
<td><code>-Xdump:what</code></td>
<td>Shows registered agents on startup.</td>
</tr>
<tr>
<td><code>-Xdump:&lt;agent&gt;:help</code></td>
<td>Displays dump agent usage information.</td>
</tr>
</tbody>
</table>
<p>The following options can be used to control the production of diagnostic data:  </p>
<table>
<thead>
<tr>
<th>Parameter</th>
<th>Result</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>-Xdump:none</code></td>
<td>Removes all default dump agents and any preceding dump options.</td>
</tr>
<tr>
<td><code>-Xdump:dynamic</code></td>
<td>Enable support for pluggable agents</td>
</tr>
<tr>
<td><code>-Xdump:nofailover</code></td>
<td>Discards dumps when the default or specified dump location is full.</td>
</tr>
<tr>
<td><code>-Xdump:directory=&lt;path&gt;</code></td>
<td>Specifies a directory for all dump types to be written to. This directory path is prefixed to the path of all non-absolute dump file names, including the file names for the default dump agents.</td>
</tr>
<tr>
<td><code>-Xdump:suspendwith=&lt;offset&gt;</code></td>
<td>Modifies the signal that is used to suspend VM threads while a dump file is being written. Use <code>&lt;offset&gt;</code> to change the default signal number. (Linux&reg; only)</td>
</tr>
<tr>
<td><code>-Xdump:&lt;agent&gt;:&lt;suboptions&gt;</code></td>
<td>Provides detailed suboptions per dump agent that provide more granular control.</td>
</tr>
</tbody>
</table>
<p>Dump agents can be configured at a very granular level by specifying suboptions. The <code>&lt;events&gt;</code> suboption is the prime trigger mechanism. The full set of suboptions are listed in the following table:</p>
<table>
<thead>
<tr>
<th>Dump agent suboptions</th>
<th>Result</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>-Xdump:&lt;agent&gt;:none</code></td>
<td>Removes the dump agent.</td>
</tr>
<tr>
<td><code>-Xdump:&lt;agent&gt;:defaults</code></td>
<td>Prints the default options for the dump agent.</td>
</tr>
<tr>
<td><code>-Xdump:&lt;agent&gt;:events=&lt;events&gt;</code></td>
<td>Triggers a dump agent when a specific event occurs.</td>
</tr>
<tr>
<td><code>-Xdump:&lt;agent&gt;:exec=&lt;command&gt;</code></td>
<td>Starts an external application for the dump agent.</td>
</tr>
<tr>
<td><code>-Xdump:&lt;agent&gt;:file=&lt;filename&gt;</code></td>
<td>Specifies where to write the dump for the dump agent.</td>
</tr>
<tr>
<td><code>-Xdump:&lt;agent&gt;:filter=&lt;filter&gt;</code></td>
<td>Filters dumps by wildcards or events.</td>
</tr>
<tr>
<td><code>-Xdump:&lt;agent&gt;:msg_filter=&lt;filter&gt;</code></td>
<td>Filters on text strings within an exception message.</td>
</tr>
<tr>
<td><code>-Xdump:&lt;agent&gt;:opts=&lt;options&gt;</code></td>
<td>Used by specific dump agents to select the type of dump file to produce.</td>
</tr>
<tr>
<td><code>-Xdump:&lt;agent&gt;:priority=&lt;0-999&gt;</code></td>
<td>Specifies the priority that the dump agents run in.</td>
</tr>
<tr>
<td><code>-Xdump:&lt;agent&gt;:range=&lt;ranges&gt;</code></td>
<td>Starts and stops a dump agent on a particular occurrence of a VM.</td>
</tr>
<tr>
<td><code>-Xdump:&lt;agent&gt;:request=&lt;requests&gt;</code></td>
<td>Asks the VM to prepare the state before starting the dump agent.</td>
</tr>
</tbody>
</table>
<p>You can have multiple <code>-Xdump</code> options on the command line. You can also have multiple dump types triggered by multiple events. For example, the following command turns off the creation of heap dump files, and creates a dump agent that produces a heap dump file and a Java&trade; dump file when either a <strong>vmstart</strong> or <strong>vmstop</strong> event occurs:</p>
<pre><code>java -Xdump:heap:none -Xdump:heap+java:events=vmstart+vmstop -mp . -m &lt;class&gt; [args...]
</code></pre>

<p><i class="fa fa-pencil-square-o" aria-hidden="true"></i> <strong>Note:</strong> Multiple suboptions that follow an <code>Xdump</code> suboption must be split with a comma (,), for example:</p>
<pre><code>java -Xdump:java:events=vmstart,file=/STDERR/ -version
</code></pre>

<p>For more detailed information on the these parameters and suboptions, including examples, see <a href="#parameters">Parameters</a>.</p>
<h2 id="dump-agents">Dump agents</h2>
<p>A dump agent performs diagnostic tasks when triggered. Most dump agents save information on the state of the VM in some form of dump or trace file for later analysis.
An exception is the "tool" agent, which can be used to trigger external processes when specific events occur.</p>
<table>
<thead>
<tr>
<th>Dump agent</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>stack</td>
<td>Stack dumps are very basic dumps in which the status and Java stack of the thread is written to stderr.</td>
</tr>
<tr>
<td>console</td>
<td>Console dumps are very basic dumps, in which the status of every Java thread is written to stderr.</td>
</tr>
<tr>
<td>system</td>
<td>System dumps capture the raw process image or address space of an application.</td>
</tr>
<tr>
<td>tool</td>
<td>The tool option allows external processes to be started when an event occurs.</td>
</tr>
<tr>
<td>java</td>
<td>Java dumps are an internally generated and formatted analysis of the VM, giving information that includes the Java threads present, the classes loaded, and heap statistics.</td>
</tr>
<tr>
<td>heap</td>
<td>Heap dumps capture all object instances in the heap, including each object address, type or class name, size, and references to other objects.</td>
</tr>
<tr>
<td>snap</td>
<td>Take a snap of the trace buffers, which contain tracepoint data.</td>
</tr>
<tr>
<td>ceedump</td>
<td>LE CEEDUMP dumps are z/OS&reg; formatted summary system dumps that show stack traces for each thread that is in the VM process, together with register information and a short dump of storage for each register.</td>
</tr>
<tr>
<td>jit</td>
<td>JIT compiler dumps contain diagnostic data in a binary format.</td>
</tr>
</tbody>
</table>
<h3 id="default-dump-agents">Default dump agents</h3>
<p>During VM initialization a set of dump agents are added by default. You can override this set of dump agents using <code>-Xdump</code> on the command line. To show the registered dump agents, user the <code>Xdump:what</code> option on the command line. The following sample output shows the default dump agents that are in place on a Linux system:</p>
<pre><code>java -Xdump:what

Registered dump agents
----------------------
-Xdump:system:
    events=gpf+abort+traceassert+corruptcache,
    label=/home/user/core.%Y%m%d.%H%M%S.%pid.%seq.dmp,
    range=1..0,
    priority=999,
    request=serial
----------------------
-Xdump:system:
    events=systhrow,
    filter=java/lang/OutOfMemoryError,
    label=/home/user/core.%Y%m%d.%H%M%S.%pid.%seq.dmp,
    range=1..1,
    priority=999,
    request=exclusive+compact+prepwalk
----------------------
-Xdump:heap:
    events=systhrow,
    filter=java/lang/OutOfMemoryError,
    label=/home/user/heapdump.%Y%m%d.%H%M%S.%pid.%seq.phd,
    range=1..4,
    priority=500,
    request=exclusive+compact+prepwalk,
    opts=PHD
----------------------
-Xdump:java:
    events=gpf+user+abort+traceassert+corruptcache,
    label=/home/user/javacore.%Y%m%d.%H%M%S.%pid.%seq.txt,
    range=1..0,
    priority=400,
    request=exclusive+preempt
----------------------
-Xdump:java:
    events=systhrow,
    filter=java/lang/OutOfMemoryError,
    label=/home/user/javacore.%Y%m%d.%H%M%S.%pid.%seq.txt,
    range=1..4,
    priority=400,
    request=exclusive+preempt
----------------------
-Xdump:snap:
    events=gpf+abort+traceassert+corruptcache,
    label=/home/user/Snap.%Y%m%d.%H%M%S.%pid.%seq.trc,
    range=1..0,
    priority=300,
    request=serial
----------------------
-Xdump:snap:
    events=systhrow,
    filter=java/lang/OutOfMemoryError,
    label=/home/user/Snap.%Y%m%d.%H%M%S.%pid.%seq.trc,
    range=1..4,
    priority=300,
    request=serial
----------------------
-Xdump:jit:
    events=gpf+abort,
    label=/home/user/jitdump.%Y%m%d.%H%M%S.%pid.%seq.dmp,
    range=1..0,
    priority=200,
    request=serial
----------------------
</code></pre>

<h3 id="dump-agent-tokens">Dump agent tokens</h3>
<p>You can use tokens to add context to dump file names and directories, and to pass command-line arguments to the tool agent. The tokens available are listed in the following table:</p>
<table>
<thead>
<tr>
<th>Token</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>%Y</td>
<td>Year (4 digits)</td>
</tr>
<tr>
<td>%y</td>
<td>Year (2 digits)</td>
</tr>
<tr>
<td>%m</td>
<td>Month (2 digits)</td>
</tr>
<tr>
<td>%d</td>
<td>Day of the month (2 digits)</td>
</tr>
<tr>
<td>%H</td>
<td>Hour ( 2 digits)</td>
</tr>
<tr>
<td>%M</td>
<td>Minute (2 digits)</td>
</tr>
<tr>
<td>%S</td>
<td>Second (2 digits)</td>
</tr>
<tr>
<td>%pid</td>
<td>Process ID</td>
</tr>
<tr>
<td>%uid</td>
<td>User name</td>
</tr>
<tr>
<td>%seq</td>
<td>Dump counter</td>
</tr>
<tr>
<td>%tick</td>
<td>msec counter</td>
</tr>
<tr>
<td>%home</td>
<td>Java home directory</td>
</tr>
<tr>
<td>%last</td>
<td>Last dump</td>
</tr>
<tr>
<td>%job</td>
<td>Job name (z/OS only)</td>
</tr>
<tr>
<td>%jobid</td>
<td>Job ID (z/OS only)</td>
</tr>
<tr>
<td>%asid</td>
<td>Address space ID (z/OS only)</td>
</tr>
<tr>
<td>&amp;DS</td>
<td>Dump Section. An incrementing sequence number used for splitting TDUMP files to be less than 2 GB in size. (z/OS 64-bit only)</td>
</tr>
</tbody>
</table>
<h3 id="merging-xdump-agents">Merging -Xdump agents</h3>
<p>If you configure more than one dump agent, each responds to events according to its configuration. However, the internal structures representing the dump agent configuration might not match the command line, because dump agents are merged for efficiency. Two sets of options can be merged as long as none of the agent settings conflict. This means that the list of installed dump agents and their parameters produced by <code>-Xdump:what</code> might not be grouped in the same way as the original <code>-Xdump</code> options that configured them.</p>
<p>For example, you can use the following command to specify that a dump agent creates a Java dump file on class unload:</p>
<pre><code>java -Xdump:java:events=unload -Xdump:what
</code></pre>

<p>This command does not create a new agent, as can be seen in the results from the <code>-Xdump:what</code> option.</p>
<pre><code>...
----------------------
-Xdump:java:
    events=gpf+user+abort+unload+traceassert+corruptcache,
    label=/home/user/javacore.%Y%m%d.%H%M%S.%pid.%seq.txt,
    range=1..0,
    priority=400,
    request=exclusive+preempt
----------------------
</code></pre>

<p>The configuration is merged with the existing Java dump agent for events <strong>gpf</strong>, <strong>user</strong>, <strong>abort</strong>, <strong>traceassert</strong>, and <strong>corruptcache</strong>, because none of the specified options for the new unload agent conflict with those for the existing agent.</p>
<p>In the previous example, if one of the parameters for the unload agent is changed so that it conflicts with the existing agent, then it cannot be merged. For example, the following command specifies a different priority, forcing a separate agent to be created:</p>
<pre><code>java -Xdump:java:events=unload,priority=100 -Xdump:what
</code></pre>

<p>The results of the <code>-Xdump:what</code> option in the command are as follows.</p>
<pre><code>...
----------------------
-Xdump:java:
    events=unload,
    label=/home/user/javacore.%Y%m%d.%H%M%S.%pid.%seq.txt,
    range=1..0,
    priority=100,
    request=exclusive+preempt
----------------------
-Xdump:java:
    events=gpf+user+abort+traceassert+corruptcache,
    label=/home/user/javacore.%Y%m%d.%H%M%S.%pid.%seq.txt,
    range=1..0,
    priority=400,
    request=exclusive+preempt
----------------------
</code></pre>

<p>To merge dump agents, the <em>request</em>, <em>filter</em>, <em>opts</em>, <em>label</em>, and <em>range</em> parameters must match exactly. If you specify multiple agents that filter on the same string, but keep all other parameters the same, the agents are merged. For example:</p>
<pre><code>java -Xdump:none -Xdump:java:events=uncaught,filter=java/lang/NullPointerException -Xdump:java:events=unload,filter=java/lang/NullPointerException -Xdump:what
</code></pre>

<p>The results of this command are as follows:</p>
<pre><code>Registered dump agents
----------------------
-Xdump:java:
    events=unload+uncaught,
    filter=java/lang/NullPointerException,
    label=/home/user/javacore.%Y%m%d.%H%M%S.%pid.%seq.txt,
    range=1..0,
    priority=400,
    request=exclusive+preempt
----------------------
</code></pre>

<h2 id="dump-events">Dump events</h2>
<p>Dump agents are triggered by events occurring during operation of the OpenJ9 VM. Some events can be filtered to improve the relevance of the output.</p>
<p>The following table shows the events that are available as dump agent triggers:</p>
<table>
<thead>
<tr>
<th>Event</th>
<th>Triggered when....</th>
<th>Filters on ....</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>gpf</strong></td>
<td>A General Protection Fault (GPF) occurs.</td>
<td>Not applicable</td>
</tr>
<tr>
<td><strong>user</strong></td>
<td>The VM receives the SIGQUIT (Linux, macOS&reg;, AIX&reg;, z/OS) or SIGBREAK (Windows&trade;) signal from the operating system.</td>
<td>Not applicable</td>
</tr>
<tr>
<td><strong>abort</strong></td>
<td>The VM receives the SIGABRT signal from the operating system.</td>
<td>Not applicable</td>
</tr>
<tr>
<td><strong>vmstart</strong></td>
<td>The virtual machine is started.</td>
<td>Not applicable</td>
</tr>
<tr>
<td><strong>vmstop</strong></td>
<td>The virtual machine stops.</td>
<td>Exit code; for example, <code>filter=#129..#192#-42#255</code></td>
</tr>
<tr>
<td><strong>load</strong></td>
<td>A class is loaded.</td>
<td>Class name; for example, <code>filter=java/lang/String</code></td>
</tr>
<tr>
<td><strong>unload</strong></td>
<td>A class us unloaded.</td>
<td>Not applicable</td>
</tr>
<tr>
<td><strong>throw</strong></td>
<td>An exception is thrown.</td>
<td>Exception class name; for example, <code>filter=java/lang/OutOfMem*</code></td>
</tr>
<tr>
<td><strong>catch</strong></td>
<td>An exception is caught.</td>
<td>Exception class name; for example, <code>filter=*Memory*</code></td>
</tr>
<tr>
<td><strong>uncaught</strong></td>
<td>A Java exception is not caught by the application.</td>
<td>Exception class name; for example, <code>filter=*MemoryError</code></td>
</tr>
<tr>
<td><strong>systhrow</strong></td>
<td>A Java exception is about to be thrown by the VM. This is different from the 'throw' event because it is only triggered for error conditions detected internally in the VM.</td>
<td>Exception class name; for example, <code>filter=java/lang/OutOfMem*</code>.</td>
</tr>
<tr>
<td><strong>thrstart</strong></td>
<td>A new thread is started.</td>
<td>Not applicable</td>
</tr>
<tr>
<td><strong>blocked</strong></td>
<td>A thread becomes blocked.</td>
<td>Not applicable</td>
</tr>
<tr>
<td><strong>thrstop</strong></td>
<td>A thread stops.</td>
<td>Not applicable</td>
</tr>
<tr>
<td><strong>fullgc</strong></td>
<td>A garbage collection cycle is started.</td>
<td>Not applicable</td>
</tr>
<tr>
<td><strong>slow</strong></td>
<td>A thread takes longer than 50ms to respond to an internal VM request.</td>
<td>Time taken; for example, filter=#300ms will trigger when a thread takes longer than 300ms to respond to an internal VM request.</td>
</tr>
<tr>
<td><strong>allocation</strong></td>
<td>A Java object is allocated with a size matching the given filter specification.</td>
<td>Object size; a filter must be supplied. For example, filter=#5m will trigger on objects larger than 5 Mb. Ranges are also supported; for example, filter=#256k..512k will trigger on objects between 256 Kb and 512 Kb in size.</td>
</tr>
<tr>
<td><strong>traceassert</strong></td>
<td>An internal error occurs in the VM.</td>
<td>Not applicable</td>
</tr>
<tr>
<td><strong>corruptcache</strong></td>
<td>The VM finds that the shared class cache is corrupt.</td>
<td>Not applicable</td>
</tr>
<tr>
<td><strong>excessivegc</strong></td>
<td>An excessive amount of time is being spent in the garbage collector.</td>
<td>Not applicable</td>
</tr>
</tbody>
</table>
<p><i class="fa fa-pencil-square-o" aria-hidden="true"></i> <strong>Note:</strong> The <strong>gpf</strong>, <strong>traceassert</strong>, and <strong>abort</strong> events cannot trigger a heap dump, prepare the heap (request=prepwalk), or compact the heap (request=compact).</p>
<h2 id="parameters">Parameters</h2>
<p><code>-Xdump:&lt;agent&gt;:&lt;suboptions&gt;</code> descriptions and examples.</p>
<h3 id="help"><code>help</code></h3>
<p>To print usage information for a specific dump agent, use <code>-Xdump:&lt;agent&gt;:help</code></p>
<h3 id="noneltoptionsgt"><code>none:&lt;options&gt;</code></h3>
<p>Use the <code>-Xdump:none</code> option to add and remove dump agents for various VM events, update default dump settings (such as the dump name), and limit the number of dumps that are produced.</p>
<p>The option can be used to affect all agents by specifying <code>-Xdump:none:&lt;options&gt;</code> or specific agents by specifying <code>-Xdump:&lt;agent&gt;:none:&lt;suboptions&gt;</code></p>
<p>where <code>&lt;suboptions&gt;</code> is one of the following control types:</p>
<ul>
<li><code>events=&lt;event&gt;</code></li>
<li><code>exec=&lt;command&gt;</code></li>
<li><code>file=&lt;filename&gt;</code></li>
<li><code>filter=&lt;filter&gt;</code></li>
<li><code>opts=&lt;options&gt;</code></li>
<li><code>priority=&lt;0-999&gt;</code></li>
<li><code>range=&lt;ranges&gt;</code></li>
<li><code>request=&lt;requests&gt;</code></li>
</ul>
<p>Explanations for these suboptions are provided elsewhere in this topic.</p>
<p>To remove all default dump agents and any preceding dump options, use <code>-Xdump:none</code>. Use this option so that you can subsequently specify a completely new dump configuration.</p>
<p>You can also remove dump agents of a particular type. Here are some examples:</p>
<p>To turn off all heap dumps (including default agents) but leave Java dumps enabled, use the following option:</p>
<pre><code>-Xdump:java+heap:events=vmstop -Xdump:heap:none
</code></pre>

<p>To turn off all dump agents for corruptcache events:</p>
<pre><code>-Xdump:none:events=corruptcache
</code></pre>

<p>To turn off just system dumps for corruptcache events:</p>
<pre><code>-Xdump:system:none:events=corruptcache
</code></pre>

<p>To turn off all dumps when a <code>java/lang/OutOfMemory</code> error is thrown:</p>
<pre><code>-Xdump:none:events=systhrow,filter=java/lang/OutOfMemoryError
</code></pre>

<p>To turn off just system dumps when a <code>java/lang/OutOfMemory</code> error is thrown:</p>
<pre><code>-Xdump:system:none:events=systhrow,filter=java/lang/OutOfMemoryError
</code></pre>

<p>If you remove all dump agents by using <code>-Xdump:none</code> with no further <code>-Xdump</code> options, the VM still provides these basic diagnostic outputs:</p>
<ul>
<li>If a user signal (kill -QUIT) is sent to the VM, a brief listing of the Java threads including their stacks, status, and monitor information is written to stderr.</li>
<li>If a crash occurs, information about the location of the crash, VM options, and native and Java stack traces are written to stderr. A system dump file is also written to the user's home directory.</li>
</ul>
<p><i class="fa fa-pencil-square-o" aria-hidden="true"></i> <strong>Note:</strong> Removing dump agents and specifying a new dump configuration can require a long set of command-line options. To reuse command-line options, save the new dump configuration in a file and use the <code>-Xoptionsfile</code> option. For more information, see <a href="../xoptionsfile/">-Xoptionsfile</a>.</p>
<h3 id="defaults"><code>defaults</code></h3>
<p>Each dump type has default options. To view the default options for a particular dump type, use <code>-Xdump:&lt;agent&gt;:defaults</code>.</p>
<p>You can change the default options at run time. For example, you can direct Java dump files into a separate directory for each process, and guarantee unique files by adding a sequence number to the file name using:</p>
<pre><code>-Xdump:java:defaults:file=dumps/%pid/javacore-%seq.txt`
</code></pre>

<p>Or, for example, on z/OS, you can add the jobname to the Java dump file name using:</p>
<pre><code>-Xdump:java:defaults:file=javacore.%job.%H%M%S.txt
</code></pre>

<p>This option does not add a Java dump agent; it updates the default settings for Java dump agents. Further Java dump agents will then create dump files using this specification for filenames, unless overridden.</p>
<p><i class="fa fa-pencil-square-o" aria-hidden="true"></i> <strong>Note:</strong> Changing the defaults for a dump type will also affect the default agents for that dump type added by the VM during initialization. For example if you change the default file name for Java dump files, that will change the file name used by the default Java dump agents. However, changing the default range option will not change the range used by the default Java dump agents, because those agents override the range option with specific values.</p>
<h3 id="eventslteventgt"><code>events=&lt;event&gt;</code></h3>
<p>To trigger a dump as a result of an event, use the <code>-Xdump:&lt;agent&gt;:events=&lt;event&gt;</code> suboption. For a list of possible events, see <a href="#dump-events">Dump events</a>.</p>
<p>For example, the following command instructs the VM to create a dump agent at startup that produces a Heap dump whenever the <em>vmstop</em> event happens:</p>
<pre><code>-Xdump:heap:events=vmstop
</code></pre>

<h3 id="execltcommandgt"><code>exec=&lt;command&gt;</code></h3>
<p>The exec suboption is used by the tool dump agent to specify an external application to start. You can set a specific command to run for a particular dump agent with the following command:</p>
<pre><code>-Xdump:&lt;agent&gt;:exec=&lt;command&gt;
</code></pre>

<h3 id="fileltfilenamegt"><code>file=&lt;filename&gt;</code></h3>
<p>The file suboption specifies where the diagnostics information is written for the specified dump type. The syntax is <code>-Xdump:&lt;agent&gt;:file=&lt;filename&gt;</code>.</p>
<p>For example, to create a Heap dump called <code>my.dmp</code> when a <strong>vmstop</strong> event is received, use:</p>
<pre><code>java -Xdump:heap:events=vmstop,file=my.dmp
</code></pre>

<p>When producing system dump files on z/OS platforms, use the <code>dsn</code> option instead of the <code>file</code> option. For example:</p>
<pre><code>java -Xdump:system:events=vmstop,dsn=%uid.MYDUMP
</code></pre>

<h4 id="writing-to-stdoutstderr">Writing to <code>STDOUT</code>/<code>STDERR</code></h4>
<p>Add one of the following options to write a Java dump file to STDOUT or STDERR respectively:</p>
<pre><code>-Xdump:java:file=/STDOUT/
-Xdump:java:file=/STDERR/
</code></pre>

<ul>
<li>The keywords <code>/STDOUT/</code> and <code>/STDERR/</code> are <em>not</em> case sensitive; <code>/stdout/</code> and <code>/stderr/</code> are equivalent.</li>
<li>By common convention, you can use a dash (<code>-</code>) to refer to STDOUT:<pre><code>-Xdump:java:file=-
</code></pre>
</li>
</ul>
<h4 id="tokens">Tokens</h4>
<p>You can use tokens to add context to dump file names. For a list of tokens, see <a href="#dump-agent-tokens">Dump agent tokens</a>.</p>
<h4 id="file-location">File location</h4>
<p>The location for the dump file is selected from the following options, in this order:</p>
<ol>
<li>The location specified by the <code>-Xdump:&lt;agent&gt;:file</code> suboption on the command line (if that location includes a path). This location applies to the specified dump agent type only.</li>
<li>The location specified by the <code>-Xdump:directory</code> option on the command line. This location applies to all dump agent types.</li>
<li>
<p>The location specified by the relevant environment variable:</p>
<table>
<thead>
<tr>
<th>Dump agent type</th>
<th>z/OS operating systems</th>
<th>Other operating systems</th>
</tr>
</thead>
<tbody>
<tr>
<td>Java dumps</td>
<td><code>_CEE_DMPTARG</code></td>
<td><code>IBM_JAVACOREDIR</code></td>
</tr>
<tr>
<td>Heap dumps</td>
<td><code>_CEE_DMPTARG</code></td>
<td><code>IBM_HEAPDUMPDIR</code></td>
</tr>
<tr>
<td>System dumps</td>
<td><code>JAVA_DUMP_TDUMP_PATTERN</code></td>
<td><code>IBM_COREDIR</code></td>
</tr>
<tr>
<td>JIT dumps</td>
<td><code>_CEE_DMPTARG</code></td>
<td><code>IBM_COREDIR</code></td>
</tr>
<tr>
<td>Snap traces</td>
<td><code>_CEE_DMPTARG</code></td>
<td><code>IBM_COREDIR</code></td>
</tr>
</tbody>
</table>
</li>
<li>
<p>The current working directory of the OpenJ9 VM process.</p>
</li>
</ol>
<p>If the directory does not exist, it is created.</p>
<p>If the dump file cannot be written to the selected location, the VM reverts to using the following locations, in this order:</p>
<ol>
<li>On Windows platforms only, the system default location is <code>C:\WINDOWS</code>.</li>
<li>The location specified by the <code>TMPDIR</code> environment variable.</li>
<li>The <code>C:\Temp</code> on Windows operating systems, or the <code>/tmp</code> directory on other operating systems.</li>
</ol>
<p>This VM action does not apply to system dumps on z/OS operating systems that use the <code>dsn</code> option.
You can prevent the VM reverting to different dump locations by using the <code>-Xdump:nofailover</code> option.</p>
<h3 id="filterltfiltergt"><code>filter=&lt;filter&gt;</code></h3>
<p>Some VM events occur thousands of times during the lifetime of an application. Dump agents can use filters and ranges to avoid producing an excessive number of dump files. The following syntax must be used:</p>
<pre><code>-Xdump:&lt;agent&gt;:filter=&lt;filter&gt;
</code></pre>

<h4 id="wildcards">Wildcards</h4>
<p>You can use a wildcard in your exception event filter by placing an asterisk only at the beginning or end of the filter. The following command does not work because the second asterisk is not at the end:</p>
<pre><code>-Xdump:java:events=throw,filter=*InvalidArgumentException#*.myVirtualMethod
</code></pre>

<p>To fix the problem, change this filter to the following string:</p>
<pre><code>-Xdump:java:events=throw,filter=*InvalidArgumentException#MyApplication.*
</code></pre>

<h4 id="class-loading-and-exception-events">Class loading and exception events</h4>
<p>You can filter class loading (<strong>load</strong>) and exception (<strong>throw</strong>, <strong>catch</strong>, <strong>uncaught</strong>, <strong>systhrow</strong>) events by the name of the class that is being loaded, thrown or caught. For example:</p>
<pre><code>-Xdump:java:events=load,filter=java/lang/String
-Xdump:java:events=throw,filter=java/lang/ArrayStoreException
-Xdump:java:events=catch,filter=java/lang/NullPointerException
</code></pre>

<p>In addition, you can filter <strong>throw</strong>, <strong>uncaught</strong>, and <strong>systhrow</strong> exception events by the name of the method that throws the exception. The name of the parent class must include the full package name, using the forward slash (/) as a separator. Use a dot (.) to separate the method name from the class name. You can use an asterisk (*) as a wildcard character, to include all methods (optional portions are shown in brackets). For example:</p>
<pre><code>-Xdump:java:events=throw,filter=ExceptionClassName[#com/ibm/ThrowingClassName.throwingMethodName[#stackFrameOffset]]
</code></pre>

<p>For example, to trigger a Java dump when method <code>MyApplication.myMethod()</code> throws a <code>NullPointerException</code> exception, use the following syntax:</p>
<pre><code>-Xdump:java:events=throw,filter=java/lang/NullPointerException#com/ibm/MyApplication.myMethod
</code></pre>

<p>The stack frame offset allows you to filter on the name of a method that calls the throwing method. This option is useful if the exception is being thrown from a general purpose or utility class. For example, to trigger a Java dump when a method called by <code>MyApplication.main()</code> throws a <code>NullPointerException</code>, use the following syntax:</p>
<pre><code>-Xdump:java:events=throw,filter=java/lang/NullPointerException#com/ibm/MyApplication.main#1
</code></pre>

<p>The default value of the stack frame offset is zero.</p>
<p>You can filter the <strong>catch</strong> exception events by Java method name (optional portions are shown in brackets). For example:</p>
<pre><code>-Xdump:java:events=catch,filter=ExceptionClassName[#com/ibm/CatchingClassName.catchingMethodName]
</code></pre>

<p>You can filter <strong>throw</strong>, <strong>uncaught</strong>, and <strong>systhrowexception</strong> events by Java method name (optional portions are shown in brackets):</p>
<pre><code>-Xdump:java:events=throw,filter=ExceptionClassName[#com/ibm/ThrowingClassName.throwingMethodName[#stackFrameOffset]]
</code></pre>

<p>You can filter the <strong>catch</strong> exception events by Java method name (optional portions are shown in brackets):</p>
<pre><code>-Xdump:java:events=catch,filter=ExceptionClassName[#com/ibm/CatchingClassName.catchingMethodName]
</code></pre>

<p><i class="fa fa-pencil-square-o" aria-hidden="true"></i> <strong>Note:</strong> The filters apply to the stacktrace and fire every time the same exception is rethrown, which might result in multiple Java core files.</p>
<h4 id="vmstop-event">vmstop event</h4>
<p>You can filter the VM shut down event (<strong>vmstop</strong>) by using one or more exit codes:</p>
<pre><code>-Xdump:java:events=vmstop,filter=#129..192#-42#255
</code></pre>

<h4 id="slow-event">slow event</h4>
<p>You can filter the <strong>slow</strong> event to change the time threshold from the default of 50 ms:</p>
<pre><code>-Xdump:java:events=slow,filter=#300ms
</code></pre>

<h4 id="allocation-event">allocation event</h4>
<p>You must filter the <strong>allocation</strong> event to specify the size of objects that cause a trigger. You can set the filter size from zero up to the maximum value of a 32-bit pointer on 32-bit platforms, or the maximum value of a 64-bit pointer on 64-bit platforms. Setting the lower filter value to zero triggers a dump on all allocations.</p>
<p>For example, to trigger dumps on allocations greater than 5 Mb in size, use:</p>
<pre><code>-Xdump:stack:events=allocation,filter=#5m
</code></pre>

<p>To trigger dumps on allocations between 256Kb and 512Kb in size, use:</p>
<pre><code>-Xdump:stack:events=allocation,filter=#256k..512k
</code></pre>

<h4 id="other-events">Other events</h4>
<p>If you apply a filter to an event that does not support filtering, the filter is ignored.</p>
<h3 id="msg_filterltfiltergt"><code>msg_filter=&lt;filter&gt;</code></h3>
<p>You can use the msg_filter suboption to filter on text strings within an exception message, allowing you to reduce the number of dump files produced. This option is supported only for the following events: <strong>throw</strong>, <strong>catch</strong>, <strong>systhrow</strong>, and <strong>uncaught</strong>.</p>
<p>Use the following syntax to include message filtering in your dump output:</p>
<pre><code>-Xdump:&lt;agent&gt;:events=&lt;event&gt;,msg_filter=&lt;filter&gt;`
</code></pre>

<p>where <code>&lt;filter&gt;</code> is a text string from the exceptions that you want to include in the dump file. This suboption supports asterisks as wild cards.</p>
<p>The following example filters <code>java/lang/VerifyError</code> exceptions that contains the text string <em>class format</em>:</p>
<pre><code>-Xdump:java:events=throw,filter=java/lang/VerifyError,msg_filter=*class format*
</code></pre>

<h3 id="optsltoptionsgt"><code>opts=&lt;options&gt;</code></h3>
<p>The full syntax is <code>-Xdump:&lt;agent&gt;:opts=&lt;options&gt;</code>.</p>
<p>The heap dump agent uses this suboption to specify the type of file to produce. On z/OS, the system dump agent uses this suboption to specify the type of dump to produce.</p>
<h4 id="heap-dumps">Heap dumps</h4>
<p>You can specify a PHD heap dump file (PHD), a classic text heap dump file (CLASSIC), or both. The default is a PHD file. For example:</p>
<pre><code>-Xdump:heap:opts=PHD  
-Xdump:heap:opts=CLASSIC
-Xdump:heap:opts=PHD+CLASSIC
</code></pre>

<h4 id="zos-system-dumps">z/OS system dumps</h4>
<p>You can specify a system transaction dump (IEATDUMP), an LE dump (CEEDUMP), or both. The default is an IEADUMP file. For example:</p>
<pre><code>-Xdump:system:opts=IEATDUMP
-Xdump:system:opts=CEEDUMP
-Xdump:system:opts=IEATDUMP+CEEDUMP
</code></pre>

<p>The ceedump agent is the preferred way to specify LE dumps, for example:</p>
<pre><code>-Xdump:ceedump:events=gpf
</code></pre>

<h4 id="tool-dumps">Tool dumps</h4>
<p>The tool dump agent supports two suboptions that can be specified using the <code>opts</code> subption. You can run the external process asynchronously with opts=ASYNC. You can also specify a delay in milliseconds that produces a pause after starting the command. These two options can be used independently or together. The following examples show different options for starting a new process that runs <code>myProgram</code>:</p>
<pre><code>-Xdump:tool:events=vmstop,exec=myProgram
</code></pre>

<p>Without the <code>opts</code> suboption, the tool dump agent starts the process, and waits for the process to end before continuing.</p>
<pre><code>-Xdump:tool:events=vmstop,exec=myProgram,opts=ASYNC
</code></pre>

<p>When <code>opts=ASYNC</code> is specified, the tool dump agent starts the process, and continues without waiting for the new process to end.</p>
<pre><code>-Xdump:tool:events=vmstop,exec=myProgram,opts=WAIT1000
</code></pre>

<p>This option starts the process, waits for the process to end, and then waits a further 1 second (1000 milliseconds) before continuing.</p>
<pre><code>-Xdump:tool:events=vmstop,exec=myProgram,opts=ASYNC+WAIT10000
</code></pre>

<p>Finally the last example starts the process and waits for 10 seconds before continuing, whether the process is still running or not. This last form is useful if you are starting a process that does not end, but requires time to initialize properly.</p>
<h3 id="prioritylt0-999gt"><code>priority=&lt;0-999&gt;</code></h3>
<p>One event can generate multiple dump files. The agents that produce each dump file run sequentially and their order is determined by the priority keyword set for each agent. The full syntax for this command is <code>-Xdump:&lt;agent&gt;:priority=&lt;0-999&gt;</code>.</p>
<p>Examination of the output from <code>-Xdump:what</code> shows that a <strong>gpf</strong> event produces a snap trace, a Java dump file, and a system dump file. In this example, the system dump runs first, with priority 999. The snap dump runs second, with priority 500. The Java dump runs last, with priority 10:</p>
<pre><code>-Xdump:heap:events=vmstop,priority=123
</code></pre>

<p>The maximum value allowed for priority is 999. Higher priority dump agents are started first.</p>
<p>If you do not specifically set a priority, default values are taken based on the dump type. The default priority and the other default values for a particular type of dump, can be displayed by using <code>-Xdump:&lt;type&gt;:defaults</code>. For example:</p>
<pre><code>java -Xdump:heap:defaults -version
</code></pre>

<p>Default <code>-Xdump:heap</code> settings:</p>
<pre><code>  events=gpf+user
  filter=
  file=/home/user/heapdump.%Y%m%d.%H%M%S.%pid.phd
  range=1..0
  priority=500
  request=exclusive+compact+prepwalk
  opts=PHD
</code></pre>

<h3 id="rangeltrangesgt"><code>range=&lt;ranges&gt;</code></h3>
<p>You can start and stop dump agents on a particular occurrence of a VM event by using the <code>range</code> suboption: <code>-Xdump:&lt;agent&gt;:range=&lt;ranges&gt;</code></p>
<p>For example:</p>
<pre><code>-Xdump:java:events=fullgc,range=100..200
</code></pre>

<p><i class="fa fa-pencil-square-o" aria-hidden="true"></i> <strong>Note:</strong> range=1..0 against an event means "on every occurrence".</p>
<p>The VM default dump agents have the range suboption set to 1..0 for all events except systhrow. Most systhrow events with <code>filter=java/lang/OutOfMemoryError</code> have the range suboption set to 1..4, which limits the number of dump files produced on <code>OutOfMemory</code> conditions to a maximum of 4. For more information, see <a href="#default-dump-agents">Default dump agents</a>.</p>
<p>If you add a new dump agent and do not specify the range, a default of 1..0 is used.</p>
<h3 id="requestltrequestsgt"><code>request=&lt;requests&gt;</code></h3>
<p>Use the request suboption to ask the VM to prepare the state before starting the dump agent: <code>-Xdump:&lt;agent&gt;:request=&lt;requests&gt;</code></p>
<p>The available suboptions are listed in the following table:</p>
<table>
<thead>
<tr>
<th>suboption value</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>exclusive</td>
<td>Request exclusive access to the VM.</td>
</tr>
<tr>
<td>compact</td>
<td>Run garbage collection. This option removes all unreachable objects from the heap before the dump file is generated.</td>
</tr>
<tr>
<td>prepwalk</td>
<td>Prepare the heap for walking. You must also specify exclusive when you use this option.</td>
</tr>
<tr>
<td>serial</td>
<td>Suspend other dumps until this dump is finished.</td>
</tr>
<tr>
<td>preempt</td>
<td>Applies to the Java dump agent and controls whether native threads in the process are forcibly pre-empted in order to collect stack traces. If this option is not specified, only Java stack traces are collected in the Java dump.</td>
</tr>
</tbody>
</table>
<p>You can specify more than one request option by using <strong>+</strong>. For example:</p>
<pre><code>-Xdump:heap:request=exclusive+compact+prepwalk
</code></pre>

<p>The VM exclusive access mechanism allows a VM thread to halt the activity of other VM threads in a controlled way by using internal VM locks. When the <code>request=exclusive</code> option is specified for a dump agent, the VM thread that is producing the dump waits for threads that are running Java code to halt, and for garbage collection operations to complete, before the dump file is written. This process helps ensure that the dump has consistent data. When the dump is complete, the mechanism allows the other threads to resume.</p>
<p>By default, only system dumps for <code>OutOfMemoryError</code> exceptions request exclusive access. Other system dump events typically result from a crash. In these cases, exclusive access is not requested because acquiring locks during a crash can be problematic.</p>
<p>If system dumps are requested by using the <code>com.ibm.jvm.Dump.SystemDump()</code> API, the default system dump agent settings are used, and exclusive access is not requested. However, if you intend to use the system dump file for Java heap memory analysis, use the following option to request exclusive access when the dump is taken:</p>
<pre><code>-Xdump:system:defaults:request=exclusive+compact+prepwalk
</code></pre>

<p>These settings avoid capturing a dump file with in-flight data during garbage collection.
As an alternative, you can use the <code>com.ibm.jvm.Dump.triggerDump()</code> API and specify <code>request=exclusive+compact+prepwalk</code> on the API call.</p>
<p>For more information about the <code>com.ibm.jvm.Dump API</code>, see the API reference information.</p>
<p>The default setting of the <code>request</code> suboption for Java dump files is <code>request=exclusive+preempt</code>. To change the settings so that Java dump files are produced without pre-empting threads to collect native stack traces, use the following option:</p>
<pre><code>-Xdump:java:request=exclusive
</code></pre>

<p>In general, the default request options are sufficient.</p>
<h2 id="dump-output">Dump output</h2>
<p>Dump output is written to different files, depending on the type of dump and the platform. File names include a time stamp.</p>
<table>
<thead>
<tr>
<th>Dump type</th>
<th>File name  (AIX, Linux, macOS, Windows)</th>
<th>File name (z/OS)</th>
</tr>
</thead>
<tbody>
<tr>
<td>System dump</td>
<td>core.%Y%m%d.%H%M%S.%pid.dmp</td>
<td>%uid.JVM.TDUMP.%job.D%Y%m%d.T%H%M%S (31-bit),  %uid.JVM.%job.D%y%m%d.T%H%M%S.X&amp;DS (64-bit) See <strong>Note</strong></td>
</tr>
<tr>
<td>Java dump</td>
<td>javacore.%Y%m%d.%H%M%S.%pid.%seq.txt</td>
<td>javacore.%Y%m%d.%H%M%S.%pid.%seq.txt</td>
</tr>
<tr>
<td>Heap dump</td>
<td>heapdump.%Y%m%d.%H%M%S.%pid.phd</td>
<td>heapdump.%Y%m%d.T%H%M%S.phd</td>
</tr>
<tr>
<td>JIT dump</td>
<td>jitdump%Y%m%d.%H%M%S.%pid.%seq.dmp</td>
<td>jitdump%Y%m%d.%H%M%S.%pid.%seq.dmp</td>
</tr>
<tr>
<td>LE CEEDUMP</td>
<td>-</td>
<td>CEEDUMP.%Y%m%d.%H%M%S.%pid See <strong>Note</strong></td>
</tr>
</tbody>
</table>
<p>The tokens used in this table, for example <code>%Y</code>, are described in <a href="#dump-agent-tokens">Dump agent tokens</a>.</p>
<p><i class="fa fa-pencil-square-o" aria-hidden="true"></i> <strong>Note:</strong> On z/OS, the system dump file name can be set with the <code>JAVA_DUMP_TDUMP_PATTERN</code> environment variable. The CEEDUMP, which is not produced by default, is stored in the directory specified by
<code>_CEE_DMPTARG</code> or the current directory if <code>_CEE_DMPTARG</code> is not specified.</p>
<h3 id="system-dumps-on-linux">System dumps on Linux</h3>
<p>Linux does not provide an operating system API for generating a system dump from a running process. The VM produces system dumps on Linux by using the fork() API to start an identical process to the parent VM process. The VM then generates a SIGSEGV signal in the child process. The SIGSEGV signal causes Linux to create a system dump for the child process. The parent VM processes and renames the system dump, as required, by the <code>-Xdump</code> options, and might add additional data into the dump file.</p>
<p>The system dump file for the child process contains an exact copy of the memory areas used in the parent. The <a href="../tool_jdmpview/">dump viewer</a> can obtain information about the Java threads, classes, and heap from the system dump. However, the dump viewer, and other system dump debuggers show only the single native thread that was running in the child process.</p>
<p>You can use the Linux <code>kernel.core_pattern</code> setting to specify the name and path for system dumps. The VM dump agents override the Linux system dump name and path by renaming the dump as specified in the <code>-Xdump</code> options. If the <code>kernel.core_pattern</code> setting specifies a different file system to the <code>-Xdump</code> options, the VM dump agents might be unable to change the file path. In this case the VM renames the dump file, but leaves the file path unchanged. You can find the dump file name and location in the JVMDUMP010I message.</p>
<p><i class="fa fa-pencil-square-o" aria-hidden="true"></i> <strong>Note:</strong> If you use the <code>%t</code> specifier in the <code>kernel.core_pattern</code> setting, the VM does not rename the dump. The VM cannot determine the exact time that Linux generated the core file, and therefore cannot be certain which Linux dump file is the correct one to rename.</p>
<h2 id="see-also">See also</h2>
<ul>
<li><a href="../xtrace/"><code>-Xtrace</code></a></li>
<li><a href="../xdisablejavadump/"><code>-Xdisablejavadump</code></a></li>
</ul>
<!-- ==== END OF TOPIC ==== xdump.md ==== -->
                
                  
                
              
<!--
              
                


              
-->
              <!-- This block was originally in the theme's 'footer.html' partial file. It has been moved here in part to resolve issues with the footer being too large. -->
              
                <!--
* Copyright (c) 2017, 2018 IBM Corp. and others
*
* This program and the accompanying materials are made
* available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution and is available at
* https://www.eclipse.org/legal/epl-2.0/ or the Apache
* License, Version 2.0 which accompanies this distribution and
* is available at https://www.apache.org/licenses/LICENSE-2.0.
*
* This Source Code may also be made available under the
* following Secondary Licenses when the conditions for such
* availability set forth in the Eclipse Public License, v. 2.0
* are satisfied: GNU General Public License, version 2 with
* the GNU Classpath Exception [1] and GNU General Public
* License, version 2 with the OpenJDK Assembly Exception [2].
*
* [1] https://www.gnu.org/software/classpath/license.html
* [2] http://openjdk.java.net/legal/assembly-exception.html
*
* SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0 WITH
* Classpath-exception-2.0 OR LicenseRef-GPL-2.0 WITH Assembly-exception
-->
              
                <div class="md-footer-nav">
                  <nav class="md-footer-nav__inner md-grid">
<!-- Ignore all this to remove previous/next links in footer, but leave nav block else lose highlighting in LH navigation
                    <img alt="" src="../cr/rule.png"> [!-- Separator --]
                    
                      <a href="xenablestringconstantgc/" title="-Xdisablestringconstantgc" class="md-flex md-footer-nav__link md-footer-nav__link--prev" rel="prev">
                        <div class="md-flex__cell md-flex__cell--shrink">
                          <i class="md-icon md-icon--arrow-back md-footer-nav__button"></i>
                        </div>
                        <div class="md-flex__cell md-flex__cell--stretch md-footer-nav__title">
                          <span class="md-flex__ellipsis">
                            <span class="md-footer-nav__direction">
                              Previous
                            </span>
                            -Xdisablestringconstantgc
                          </span>
                        </div>
                      </a>
                    
                    
                      <a href="xenableexcessivegc/" title="-Xenableexcessivegc" class="md-flex md-footer-nav__link md-footer-nav__link--next" rel="next">
                        <div class="md-flex__cell md-flex__cell--stretch md-footer-nav__title">
                          <span class="md-flex__ellipsis">
                            <span class="md-footer-nav__direction">
                              Next
                            </span>
                            -Xenableexcessivegc
                          </span>
                        </div>
                        <div class="md-flex__cell md-flex__cell--shrink">
                          <i class="md-icon md-icon--arrow-forward md-footer-nav__button"></i>
                        </div>
                      </a>
                    
-->
                  </nav>
                </div>
              
              
            </article>
          </div>
        </div>
      </main>
      
        <!--
* Copyright (c) 2017, 2019 IBM Corp. and others
*
* This program and the accompanying materials are made
* available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution and is available at
* https://www.eclipse.org/legal/epl-2.0/ or the Apache
* License, Version 2.0 which accompanies this distribution and
* is available at https://www.apache.org/licenses/LICENSE-2.0.
*
* This Source Code may also be made available under the
* following Secondary Licenses when the conditions for such
* availability set forth in the Eclipse Public License, v. 2.0
* are satisfied: GNU General Public License, version 2 with
* the GNU Classpath Exception [1] and GNU General Public
* License, version 2 with the OpenJDK Assembly Exception [2].
*
* [1] https://www.gnu.org/software/classpath/license.html
* [2] http://openjdk.java.net/legal/assembly-exception.html
*
* SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0 WITH
* Classpath-exception-2.0 OR LicenseRef-GPL-2.0 WITH Assembly-exception
-->
<cite></cite>
<footer class="md-footer">

  <div class="md-footer-meta md-typeset">
    

    
      <!--
* Copyright (c) 2017, 2019 IBM Corp. and others
*
* This program and the accompanying materials are made
* available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution and is available at
* https://www.eclipse.org/legal/epl-2.0/ or the Apache
* License, Version 2.0 which accompanies this distribution and
* is available at https://www.apache.org/licenses/LICENSE-2.0.
*
* This Source Code may also be made available under the
* following Secondary Licenses when the conditions for such
* availability set forth in the Eclipse Public License, v. 2.0
* are satisfied: GNU General Public License, version 2 with
* the GNU Classpath Exception [1] and GNU General Public
* License, version 2 with the OpenJDK Assembly Exception [2].
*
* [1] https://www.gnu.org/software/classpath/license.html
* [2] http://openjdk.java.net/legal/assembly-exception.html
*
* SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0 WITH
* Classpath-exception-2.0 OR LicenseRef-GPL-2.0 WITH Assembly-exception
-->

  <div class="md-footer-social1">
    
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css">
    
      <a href="https://github.com/eclipse/openj9" class="md-footer-social__link fa fa-github"></a>
    
      <a href="https://openj9.slack.com" class="md-footer-social__link fa fa-slack"></a>
    
      <a href="https://twitter.com/openj9" class="md-footer-social__link fa fa-twitter"></a>
    
      <a href="https://stackoverflow.com/search?q=OpenJ9" class="md-footer-social__link fa fa-stack-overflow"></a>
    
  </div>

    

    <div class="md-footer-eclipse1">OpenJ9 is an Eclipse Incubator project.</div>

    <div class="md-footer-links1">
      <span class="no-wrap"><i class="fa fa-chevron-circle-right f_mini" aria-hidden="true"></i><a class="dark-link" href="http://www.eclipse.org">Eclipse Foundation website</a></span>
      &nbsp; <span class="no-wrap"><i class="fa fa-chevron-circle-right f_mini" aria-hidden="true"></i><a class="dark-link" href="http://www.eclipse.org/legal/privacy.php">Privacy policy</a></span>
      &nbsp; <span class="no-wrap"><i class="fa fa-chevron-circle-right f_mini" aria-hidden="true"></i><a class="dark-link" href="http://www.eclipse.org/legal/termsofuse.php">Website terms of use</a></span>
      &nbsp; <span class="no-wrap"><i class="fa fa-chevron-circle-right f_mini" aria-hidden="true"></i><a class="dark-link" href="http://www.eclipse.org/legal/copyright.php">Copyright agent</a></span>
      &nbsp; <span class="no-wrap"><i class="fa fa-chevron-circle-right f_mini" aria-hidden="true"></i><a class="dark-link" href="http://www.eclipse.org/legal">Legal</a></span>
    </div>

    <div class="md-footer-power1">
      powered by
      <a href="http://www.mkdocs.org" title="MkDocs">MkDocs</a>
      and
      <a href="http://squidfunk.github.io/mkdocs-material/" title="Material for MkDocs">
      Material for MkDocs</a><br/><br/>
    </div>

  </div>

</footer>
      
    </div>
    
      <script src="../assets/javascripts/application.a8b5e56f.js"></script>
      
        
        
      
      <script>app.initialize({version:"1.0.4",url:{base:".."}})</script>
      
    
    
      
        
<script>
  window.ga = window.ga || function() {
    (ga.q = ga.q || []).push(arguments)
  }
  ga.l = +new Date
  /* Setup integration and send page view */
  ga("create", "UA-105616558-3", "mkdocs.org")
  ga("set", "anonymizeIp", true)
  ga("send", "pageview")
  /* Register handler to log search on blur */
  document.addEventListener("DOMContentLoaded", () => {
    if (document.forms.search) {
      var query = document.forms.search.query
      query.addEventListener("blur", function() {
        if (this.value) {
          var path = document.location.pathname;
          ga("send", "pageview", path + "?q=" + this.value)
        }
      })
    }
  })
</script>
<script async src="https://www.google-analytics.com/analytics.js"></script>
      
    
  </body>
</html>