4

In Bash, I use the commmand java -Xmx8192m -Xms512m -jar jarfile to start a Java process with an initial heap space of 512MB and maximum heap space of 8GB.

I like how the heap space increases based on demand, but once the heap space has been increased, it doesn't release although the process doesn't need the memory. How can I release the memory that isn't being used by the process?

Example: Process starts, and uses 600MB of memory. Heap space increases from 512MB to a little over 600MB. Process then drops down to 400MB RAM usage, but heap allocation stays at 600MB. How would I make the allocation stay near the RAM usage?

Improve this question
4
  • OS might take back the memory when it is needed. Otherwise the JVM is unlikely to give up the memory. Commented Jul 11, 2012 at 18:44
  • how is JVM supposed to know that it will not need 600MB memory or more in the future? AFAIK it is not possible to explicitly "give back" allocated heap memory back to the OS. Commented Jul 11, 2012 at 18:44
  • AFAIK it is not possible to explicitly "give back" allocated heap memory back to the OS of course it is! posix/linux way: pubs.opengroup.org/onlinepubs/7908799/xsh/munmap.html Commented Jul 11, 2012 at 18:58
  • @Peter, stop the world collectors can return memory to the OS. Commented Jul 11, 2012 at 19:28

3 Answers 3

Reset to default
6

You cannot; it's simply not designed to work that way. Note that unused memory pages will simply be mapped out by your hardware, and so won't consume any real memory.

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

Note that unused memory pages will simply be mapped out by your hardware, and so won't consume any real memory. How? They are very much part of the process mapped memory, unless possibly swapped out they are just like any other memory.
Exactly. If they're not being used, they'll be swapped out.
First swapping is bad to boot - if the OS needs memory it means no disk cache and disks trashing, no performance whatsoever. I always run w/ swapoff -a or just remove the swap partitions altogether. The way java organizes memory is heavily GC dependent and non-compacting collectors (like CMS) being swapped out looks indistinguishable from system crash. The sheer truth is you'd never want to mix JVM and swap. On Linux I'd say compiling the kernel w/o swapping is a no-breainer (provided compiling the kernel is an option)
5

Generally you would not like JVM to return memory to the OS and later claim in back as both operations are not so cheap.

There are a couple XX parameters that may or may not work with your preferred garbage collector, namely

  • -XX:MaxHeapFreeRatio=70 Maximum percentage of heap free after GC to avoid shrinking.
  • -XX:MinHeapFreeRatio=40 Minimum percentage of heap free after GC to avoid expansion.

Source

I believe you'd need stop the world collector for them to be enforced. Other JVMs may have their own parameters.

I'd normally have not replied but the amount of negative/false info ain't cool.

Improve this answer

Comments

1

No, it is a required function. I think, the JVM in Android probably can do this, but I'm not sure.

But most of them - including all Java EE VMs - simply doesn't interested about this.

This is not so simple, as it seems - the VM is a process from the OS view, and has somewhere a mapped memory region for it, which is a stack or data segment.

In most cases it needs to be a continous interval. Memory allocation and release from the OS view happens with a system call, which the process uses to ask the OS its new segment limit.

What to do, if you have for example 2 gigabytes of RAM for your JVM, which uses only 500 megs, but this 500 meg is dispersed in some ten-bytes fragment in this 2 gigs? This memory release function would need also a defragmentation step, which would multiply the resource costs of the GC runs.

As Java runs, and Java objects are constructed and destructed by the garbage collector, the free and allocated memory areas are dispersed in the stack/data segment.

When we don't see java, but native OS processes, the situation is the same: if you malloc() ten 1meg block, and then release the first 9, there is no way to give it back to the OS, altough newer libraries and os apis have extensive development about this. Of course, if you later allocates memory again, this allocation will be done from the just-freed regions.

My opinion is, that even if this is a little bit costly and complex (and a quite large programming work), it worths its price, and I think it isn't the best image from our collective programming culture, that it isn't done since decades in everything, included the java vms.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.