I&#39;m using IDEA 12 Leda on Mountain Lion. I wanted to increase the maximum memory that IDE can use. I set the VMOptions in Info.plist file to be
`-Xmx2048m -ea -XX:+HeapDumpOnOutOfMemoryError -Xverify:none -Xbootclasspath/a:../lib/boot.jar`

When I open up IDEA, I still see the maximum memory to be 711m.

`jps -v` shows my VMOptions has been loaded but it&#39;s replaced by the following options.

    29388  **-Xmx2048m** -ea -XX:+HeapDumpOnOutOfMemoryError -Xverify:none -Xbootclasspath/a:../lib/boot.jar -Xms128m **-Xmx800m** -XX:MaxPermSize=350m -XX:ReservedCodeCacheSize=64m -XX:+UseCodeCacheFlushing -XX:+UseCompressedOops -Didea.paths.selector=IdeaIC12 -Dsun.java2d.noddraw=true -Didea.max.intellisense.filesize=2500 -Didea.dynamic.classpath=false -Didea.jars.nocopy=false -Dsun.java2d.d3d=false -Dapple.awt.fullscreencapturealldisplays=false -Dapple.laf.useScreenMenuBar=true -Djava.endorsed.dirs= -Dswing.bufferPerWindow=false -Didea.fatal.error.notification=enabled -Didea.cycle.buffer.size=1024 -Didea.popup.weight=heavy -Didea.xdebug.key=-Xdebug -Dapple.awt.graphics.UseQuartz=true -Dsun.java2d.pmoffscreen=false -Didea.no.launcher=false -DCVS_PASSFILE=~/.cvspass -Didea.use.default.antialiasing.in.editor=false -Dcom.apple.mrj.application.live-resize=false -Didea.smooth.progress=false
    29392 Jps -Dapplication.home=/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home -Xms8m

Where does `-Xmx800` come from? I need to remove it.

How to increase IDE memory limit in IntelliJ IDEA on Mac?

Specifically, why would it help to fix a PermGen OutOfMemoryError issue?

Also, bonus points for an answer that points me to the documentation on JVM arguments...

What does -XX:MaxPermSize do?

I thought it would be great to have a comparison between `_JAVA_OPTIONS` and `JAVA_TOOL_OPTIONS`.
I have been searching a bit for one, but I cannot find anything, so I hope we can find the knowledge here on Stackoverflow.

`JAVA_OPTS` is included for completeness. It is not part of the JVM, but there is a lot of questions about it out in the wild.

What I know:
------

So far I have found out that:

 - **`JAVA_OPTS`** is not used by the JDK, but by a bunch of other apps (see [this post][1]).
 - **`JAVA_TOOL_OPTIONS`** and **`_JAVA_OPTIONS`** are ways to specify JVM arguments as an environment variable instead of command line parameters. 
   - The are picked up by at least `java` and `javac`
   - They have this precedence:
     1. `_JAVA_OPTIONS` (overwrites the others)
     2. Command line parameters
     3. `JAVA_TOOL_OPTIONS` (is overwritten by the others)

What I would like to know
------

 - Are there any official documentation comparing `JAVA_TOOL_OPTIONS` and `_JAVA_OPTIONS`
 - Are there any other differences between `JAVA_TOOL_OPTIONS` and `_JAVA_OPTIONS` (except from precedence).
 - Which executables pick up `JAVA_TOOL_OPTIONS` and `_JAVA_OPTIONS` (in addition to `java` and `javac`)
 - Any limitation on what can be included on `JAVA_TOOL_OPTIONS` and `_JAVA_OPTIONS`

Official Documentation
------

I have not been able to find any documentation about `_JAVA_OPTIONS`. [The documentation for `JAVA_TOOL_OPTIONS`][2] does not shed much light on the difference:

&gt; Since the command-line cannot always be accessed or modified, for example in embedded VMs or simply VMs launched deep within scripts, a JAVA_TOOL_OPTIONS variable is provided so that agents may be launched in these cases. &lt;br&gt;...


Example script
====
This is the code I used to figure this out. Console output is included as comments:

	export JAVA_OPTS=foobar
	export JAVA_TOOL_OPTIONS= 
	export _JAVA_OPTIONS=&quot;-Xmx512m -Xms64m&quot;

	java -version                          
	# Picked up JAVA_TOOL_OPTIONS: 
	# Picked up _JAVA_OPTIONS: -Xmx512m -Xms64m
	# java version &quot;1.7.0_40&quot;
	OpenJDK Runtime Environment (IcedTea 2.4.1) (suse-3.41.1-x86_64)
	OpenJDK 64-Bit Server VM (build 24.0-b50, mixed mode)

	javac -version
	# Picked up JAVA_TOOL_OPTIONS: 
	# Picked up _JAVA_OPTIONS: -Xmx512m -Xms64m
	# javac 1.7.0_40

	export JAVA_TOOL_OPTIONS=&quot;-Xmx1 -Xms1&quot;
	export _JAVA_OPTIONS=&quot;-Xmx512m -Xms64m&quot;
	javac -version
	# Picked up JAVA_TOOL_OPTIONS: -Xmx1 -Xms1
	# Picked up _JAVA_OPTIONS: -Xmx512m -Xms64m
	# javac 1.7.0_40

	export JAVA_TOOL_OPTIONS=&quot;-Xmx512m -Xms64m&quot;
	export _JAVA_OPTIONS=&quot;-Xmx1 -Xms1&quot;
	javac -version
	# Picked up JAVA_TOOL_OPTIONS: -Xmx512m -Xms64m
	# Picked up _JAVA_OPTIONS: -Xmx1 -Xms1
	# Error occurred during initialization of VM
	# Too small initial heap

	export JAVA_TOOL_OPTIONS=&quot;-Xmx1 -Xms1&quot;
	export _JAVA_OPTIONS=
	java -Xmx512m -Xms64m -version
	# Picked up JAVA_TOOL_OPTIONS: -Xmx1 -Xms1
	# Picked up _JAVA_OPTIONS: 
	# java version &quot;1.7.0_40&quot;
	# OpenJDK Runtime Environment (IcedTea 2.4.1) (suse-3.41.1-x86_64)
	# OpenJDK 64-Bit Server VM (build 24.0-b50, mixed mode)

	export JAVA_TOOL_OPTIONS=
	export _JAVA_OPTIONS=&quot;-Xmx1 -Xms1&quot;
	java -Xmx512m -Xms64m -version
	# Picked up JAVA_TOOL_OPTIONS: 
	# Picked up _JAVA_OPTIONS: -Xmx1 -Xms1
	# Error occurred during initialization of VM
	# Too small initial heap



  [1]: https://stackoverflow.com/questions/3933300/
  [2]: http://docs.oracle.com/javase/8/docs/platform/jvmti/jvmti.html#tooloptions

Difference between _JAVA_OPTIONS, JAVA_TOOL_OPTIONS and JAVA_OPTS

I cannot for the life of me find a definition of what the Java VM flag `CMSClassUnloadingEnabled` actually does, other than some very fuzzy high-level definitions such as &quot;gets rid of your PermGen problems&quot; ([which it doesn&#39;t][1], btw).

I have looked on Sun&#39;s/Oracle&#39;s site, and even [the options list][2] doesn&#39;t actually say what it does.

Based upon the name of the flag, I&#39;m guessing that the CMS Garbage Collector doesn&#39;t by default unload classes, and this flag turns it on - but I can&#39;t be sure.




  [1]: https://stackoverflow.com/questions/3333807/the-various-options-for-solving-permgen-problems/3334397#3334397
  [2]: http://blogs.oracle.com/watt/resource/jvm-options-list.html

What does JVM flag CMSClassUnloadingEnabled actually do?

I need to check if some option that can be passed to JVM is explicitly set or has its default value.

To be more specific:
I need to create one specific thread with higher native stack size than the default one, but in case the user wants to take care of such things by himself by specifying the `-Xss` option I want to create all threads with default stack size (which will be specified by user in -Xss option).

I&#39;ve checked classes like `java.lang.System` and `java.lang.Runtime`, but these aren&#39;t giving me any useful information about VM arguments.

Is there any way to get the information I need?


How to get VM arguments from inside of Java application?

I want to increase the available heap space for Jenkins. But as it is installed as a service I don&#180;t know how to do it.

How to give Jenkins more heap space when it&#180;s started as a service under Windows?

First of all, I have a box with 8gb of ram, so I doubt total memory is the issue.
This application is running fine on machines with 6gb or less.

I am trying to reserve 3GB of space using -Xmx3G under &quot;VM Arguments&quot; in Run Configurations in Eclipse.

Every time I try to reserve more than 1500mb, I get this error:
“Error occurred during initialization of VM; Could not reserve enough space for object heap” using -Xmx3G

What is going on here?

“Error occurred during initialization of VM; Could not reserve enough space for object heap” using -Xmx3G

Normally to attach a debuger to a running jvm you would need start the jvm with arguments such as the following:

    &gt; java -Xdebug -Xrunjdwp:transport=dt_socket,address=1000,server=y,suspend=n

Now if I want to debug a process that wasn&#39;t started in debug mode, what can I do?

This situation arrises when a production system (i.e. started without debug args) exhibits a &#39;random&#39; (I use the term loosely) bug. So I can&#39;t restart the jvm with the appropriate arguments, because nobody knows how to reproduce the bug again. Is it impossible to attach to the JVM in this situation?

Just to clarify it is not possible to use tools like jdb to attach to already running JVMs unless they were started in debug mode

from the JVM man page


&gt; **Another way to use jdb is by attaching it to a Java VM that is
&gt; already running. A VM that is to be
&gt; debugged with jdb must be started with
&gt; the following options:**



Debug a java application without starting the JVM with debug arguments

Considering the following command line 

    java -Xms128m -Xms256m myapp.jar

Which settings will apply for JVM Minimum memory (`Xms` option) :  128m or 256m ?


Duplicated Java runtime options : what is the order of preference?

I need to run a Java memory intensive application that uses more than 2GB, but I am having problems to increase the heap maximum size. So far, I have tried the following approaches:

- Setting the -Xmx parameter, e.g. -Xmx3000m. This approaches fails at the creation of the JVM. From what I&#39;ve googled, it looks like that -Xmx must be less than 2GB.

- Using the [-XX:+AggressiveHeap option][1]. When I try this approach I get an &#39;Not enough memory&#39; error that tells that the heap size is 1273.4 MB, even though my computer has 8GB of memory.

Is there another approach that I can try to increase the maximum heap size of the JVM? Here&#39;s a summary of the computer specs:

- OS: Windows 7 (64 bit)
- Processor: Intel Core i7 (2.66 GHz)
- Memory: 8 GB
- java -version:

&gt;     java version &quot;1.6.0_18&quot;
&gt;     Java(TM) SE Runtime Environment (build 1.6.0_18-b07)
&gt;     Java HotSpot(TM) Client VM (build 16.0-b13, mixed mode, sharing)


  [1]: http://java.sun.com/docs/hotspot/gc1.4.2/#4.2.2.%20AggressiveHeap|outline

Increasing the JVM maximum heap size for memory intensive applications

They are algorithms for the young generation garbage collection. 

The second one (UseParNewGC) gets activated automatically with the concurrent tenured generation garbage collection (see [Java Concurrent and Parallel GC][1]) but, is there a difference between the two parallel algorithms?


  [1]: https://stackoverflow.com/questions/220388/java-concurrent-and-parallel-gc

Difference between -XX:+UseParallelGC and -XX:+UseParNewGC

I&#39;ve kind of asked this question before - https://stackoverflow.com/questions/3334911/what-does-jvm-flag-cmsclassunloadingenabled-actually-do, but this time it&#39;s slightly different!

If I start a Java VM with the `-XX:+CMSPermGenSweepingEnabled` flag set, the following message is printed:

&gt;Please use CMSClassUnloadingEnabled in place of CMSPermGenSweepingEnabled in the future

The `-XX:+CMSPermGenSweepingEnabled` flag is often used to mitigate against `PermGen OutOfMemory` errors, however I have [read elsewhere][2] that people have found that by following the above advice they have still had these errors, but by sticking with `-XX:+CMSPermGenSweepingEnabled` as well as `-XX:+CMSClassUnloadingEnabled` their VM has stayed up longer between restarts.

Does `-XX:+CMSClassUnloadingEnabled` really supersede `-XX:+CMSPermGenSweepingEnabled` or is there still some benefit in having them both?

Thanks in advance

Rich
ps: I know that the root cause of perm gen issues is still usually Classloader leaks, this is more about the message that the JVM produces if we use the above options.

  [2]: http://www.coderanch.com/t/461502/Performance/java/CMSClassUnloadingEnabled-vs-CMSPermGenSweepingEnabled#2060063

CMSPermGenSweepingEnabled vs CMSClassUnloadingEnabled

Given these two commands

A:

    $ java -Xms10G -Xmx10G myjavacode input.txt

B:

    $ java -Xms5G -Xmx5G myjavacode input.txt

I have two questions:

 1. Since command A reserves more memory with its parameters, will A run faster than B? 
 2. How do `-Xmx` and `-Xms` affect the running process and the output of my program?

Speed tradeoff of Java&#39;s -Xms and -Xmx options

After reading already asked question on the subject and a lot of googling I am still not able to have a clear view of **-Xms** option

My question is: what&#39;s the difference between `java -Xms=512m -Xmx=512m` and `java -Xms=64m -Xmx=512m`?

For now I have the following answer:

The only difference is in the number of garbage collections that will be run during my application&#39;s run and the number of memory allocations. Am I right ?

Here are my reasons for this answer:

Setting the `-Xms` option to `512m` doesn&#39;t result in my application using really `512M` of physical memory after startup. I guess this is related to modern OS virtual memory management and lazy pages allocations. (I noticed that setting `-Xms` to `512M` or to `64M` doesn&#39;t change at all the initial used memory reported either by top on Linux or by the task manager on windows)

Can someone help me to understand the impact of this `Xms` option or point me to links that will help me to understand it?

Thanks in advance

Manu


JVM heap parameters

I tried searching the internet about -Xmn option, without success.

Can someone please explain what this stands for and how can I use it to tune JVM? 


What does -Xmn jvm option stands for

I am running a program that I&#39;ve written in Java in Eclipse. The program has a very deep level of recursion for very large inputs. For smaller inputs the program runs fine however when large inputs are given, I get the following error:

    Exception in thread &quot;main&quot; java.lang.StackOverflowError

Can this be solved by increasing the Java stack size and if so, how do I do this in Eclipse?

&lt;b&gt;Update:&lt;/b&gt;

@Jon Skeet

The code is traversing a parse tree recursively in order to build up a datastructure. So, for example the code will do some work using a node in the parse tree and call itself on the node&#39;s two children, combining their results to give the overall result for the tree.

The total depth of the recursion depends on the size of the parse tree but the code seems to fail (without a larger stack) when the number of recursive calls gets into the 1000s.

Also I&#39;m pretty sure the code isn&#39;t failing because of a bug as it works for small inputs.

Java stack overflow error - how to increase the stack size in Eclipse?

In a shell script, I have set the JAVA_OPTS environment variable (to enable remote debugging and increase memory), and then I execute the jar file as follows:

    export JAVA_OPTS=&quot;-Xdebug -Xrunjdwp:transport=dt_socket,address=8001,server=y,suspend=n -Xms512m -Xmx512m&quot;
    java -jar analyse.jar $*

But it seems there is no effect of the JAVA_OPTS env variable as I cannot connect to remote-debugging and I see no change in memory for the JVM.

What could be the problem?

PS: I cannot use those settings in the `java -jar analyse.jar $*` command because I process command line arguments in the application. 

Running java with JAVA_OPTS env variable has no effect

This concerns Intellij from 9 to 11.
In the IDEA window On the bottom right corner I see the current memory usage, typically &quot;224M of 254M&quot; How do I give more memory to Idea so it may read like &quot;224M of 512M&quot; ?

Thank you. 


How to give more memory to IntelliJ Idea 9-11 

Is there a way that I can set the default heap size for the jvm on my own computer?  I want to set it to 1g, because I&#39;m always running custom programs that always hit the overage point in the default jvm size.

I just dont want to have to remember to type -XmX1g everytime I run my java app from the command line...  

There has to be an admin way to do this right?

increase the java heap size permanently?

What are the default values for the following options in Java 6 on a *non-server-class machine*?

 - -Xmx
 - -XX:MaxPermSize

Oracle&#39;s [documentation][1] states that:

&gt; On server-class machines running the server VM, the garbage collector (GC) has changed from the previous serial collector (-XX:+UseSerialGC) to a parallel collector (-XX:+UseParallelGC).

and

&gt; On server-class machines running either VM (client or server) with the parallel garbage collector (-XX:+UseParallelGC) the initial heap size and maximum heap size have changed

The page doesn&#39;t describe the defaults for non-server-class machines, only that, for example, the initial heap size is &quot;a reasonable minimum&quot;. Looking at [the &#39;man page&#39;][2] for the `java` command there is the following against `-Xms`:

&gt; The default value is chosen at runtime based on system configuration 


  [1]: http://docs.oracle.com/javase/6/docs/technotes/guides/vm/gc-ergonomics.html
  [2]: http://docs.oracle.com/javase/6/docs/technotes/tools/windows/java.html

All Jvm Arguments Solutions on Gang of Coders

Total of 20 Jvm Arguments Solutions