Epsilon: The JDK’s Do-Nothing Garbage Collector
blogs.oracle.com
Epsilon: The JDK’s Do-Nothing Garbage Collector
1–10 of 77 posts
Re: Epsilon: The JDK’s Do-Nothing Garbage Collector
#2Now I'm no Java expert, far from it, so would appreciate any answers to this. I'm interacting with bunch of CLIs that are either in Java or using the JVM otherwise (Clojure mostly), how much of the startup time for this things can be attributed to the GC? It's mentioned in the article that short-running programs (almost all CLIs I use) could use Epsilon since the heap is cleared on exit anyways. But wondering how much of the typical program actually spends on, what I guess is initializing the GC?
Re: Epsilon: The JDK’s Do-Nothing Garbage Collector
#3To address the short-running program issue, can't the regular GCs just not clean up on program exit?
Re: Epsilon: The JDK’s Do-Nothing Garbage Collector
#4Now I'm no Java expert, far from it, so would appreciate any answers to this. I'm interacting with bunch of CLIs that are either in Java or using the JVM otherwise (Clojure mostly), how much of the startup time for this things can be attributed to the GC? It's mentioned in the article that short-running programs (almost all CLIs I use) could use Epsilon since the heap is cleared on exit anyways. But wondering how muc…
There's an use-case in twelve factor apps where GC pauses would be unacceptable but high availability would allow downtime of an individual stateless app instance. So instead of spending any time GCing, just eat memory and throw it all away and start over fresh as necessary. With various tricks, an instance can be swapped quickly (start a new instance just before killing)... probably want some sort of user-space "OOM killer" to handle it. ulimits lower than JVM option limits would work too, but wouldn't have fast restarts without some magic.
Re: Epsilon: The JDK’s Do-Nothing Garbage Collector
#5Now I'm no Java expert, far from it, so would appreciate any answers to this. I'm interacting with bunch of CLIs that are either in Java or using the JVM otherwise (Clojure mostly), how much of the startup time for this things can be attributed to the GC? It's mentioned in the article that short-running programs (almost all CLIs I use) could use Epsilon since the heap is cleared on exit anyways. But wondering how muc…
There's an use-case in twelve factor apps where GC pauses would be unacceptable but high availability would allow downtime of an individual stateless app instance. So instead of spending any time GCing, just eat memory and throw it all away and start over fresh as necessary. With various tricks, an instance can be swapped quickly (start a new instance just before killing)... probably want some sort of user-space "OOM…
You might be replying to the wrong comment, or I'm not making my question clear enough. I'm wondering how much of the startup time the GC currently takes, and if using Epsilon will make startup faster.
Re: Epsilon: The JDK’s Do-Nothing Garbage Collector
#6To address the short-running program issue, can't the regular GCs just not clean up on program exit?
That's an interesting concept but unfortunately, garbage collection is not as simple as that.
Re: Epsilon: The JDK’s Do-Nothing Garbage Collector
#7To address the short-running program issue, can't the regular GCs just not clean up on program exit?
It's not a issue? It's one of the cases where it does make sense to use Epsilon as the heap is cleared anyway on program exit.
From the post:
> There is a strong temptation to use Epsilon on deployed programs, rather than to confine it to performance tuning work. As a rule, the Java team discourages this use, with two exceptions. Short-running programs, like all programs, invoke the garbage collector at the end of their run. However, as JEP 318 explains, “accepting the garbage collection cycle to futilely clean up the heap is a waste of time, because the heap would be freed on exit anyway.”
Re: Epsilon: The JDK’s Do-Nothing Garbage Collector
#8Now I'm no Java expert, far from it, so would appreciate any answers to this. I'm interacting with bunch of CLIs that are either in Java or using the JVM otherwise (Clojure mostly), how much of the startup time for this things can be attributed to the GC? It's mentioned in the article that short-running programs (almost all CLIs I use) could use Epsilon since the heap is cleared on exit anyways. But wondering how muc…
If you have assigned a JVM too little memory for the short running task it might be a significant amount of time, but if the amount of memory is set correctly the initial GC setup is a fraction of the time compared to the time spent JIT:ing.
Although you might gain some performance, I guess this "GC" is going to be used mostly by people running financial - or other - low latency analysis/streaming code where it has been common for years to try to tune the JVM to never even attempt to GC - to avoid latency.
The code in these cases are written to reuse most memory, and when the unreclaimable part grows to big, that cluster node stops taking requests - and is then restarted.
Re: Epsilon: The JDK’s Do-Nothing Garbage Collector
#9To address the short-running program issue, can't the regular GCs just not clean up on program exit?
Setting aside GC, nailgun (JDK Also these help reduce load times:
- Class Data Sharing (CDS; JDK 5+) https://docs.oracle.com/en/java/javase/11/vm/class-data-shar...
- Application Class Data Sharing (AppCDS; JDK 10+) https://openjdk.java.net/jeps/310
- Ahead-Of-Time compilation (AOT; jaotc; JDK 9+ Linux-x86_64 only): http://openjdk.java.net/jeps/295 - JVM runtime trimmer (jlink; JDK 9+): http://openjdk.java.net/jeps/282
---
Drip: https://github.com/ninjudd/drip
Nailgun:
Re: Epsilon: The JDK’s Do-Nothing Garbage Collector
#10Now I'm no Java expert, far from it, so would appreciate any answers to this. I'm interacting with bunch of CLIs that are either in Java or using the JVM otherwise (Clojure mostly), how much of the startup time for this things can be attributed to the GC? It's mentioned in the article that short-running programs (almost all CLIs I use) could use Epsilon since the heap is cleared on exit anyways. But wondering how muc…
Might want to check out https://github.com/facebook/nailgun