vFabric Elastic Memory for Java
Dramatically Improve Memory Efficiency of your Virtualized Java Applications with EM4J
VMware vFabric® Elastic Memory for Java (EM4J) is designed for customers running virtualized Java applications on VMware vSphere®. Focused primarily on memory management and performance analysis, EM4J gives you the insight and power to get the most efficiency and performance out of your virtualized Java applications.
EM4J greatly simplifies the most common configuration and management tasks, such as how to appropriately size virtual machines (VMs) running Java, how to gauge the real memory efficiency of your Java processes over time and how to avoid potential performance problems with configuration alerts.
EM4J also gives you the power to drive further memory efficiencies into your Java workloads by allowing the hypervisor to transparently reclaim memory directly from relatively idle Java Virtual Machines (JVMs), putting them where they are needed most in your virtual infrastructure.
See what's really going on inside your VMs running Java
VMs are opaque entities. In theory, they should be agnostic to the operating system and running applications – they simply need an appropriate capacity of compute resource and all should be well. However, this opaqueness combined with the resource hungry nature of the Java platform can make capacity planning difficult. There are resource management tools for Java, but none are designed specifically for optimizing Java workloads on vSphere.
Select any VM in vCenter and EM4J will clearly breakdown all the Java processes running in it: Memory usage, GC statistics, configuration parameters, PID, main class, JMX status, whether large pages is correctly configured, etc.
Do you suspect that your Java VMs are wasting memory?
VMs running Java are typically over-provisioned for a variety of reasons. The JVMs themselves are usually also configured to have plenty of headroom, and they often consume their maximum memory allocation regardless of load. In most cases, this over-provisioning is an insurance policy against the perceived risk of performance problems, but it can lead to huge and unnecessary inefficiencies of memory consumption on the host. The use of memory over-commitment can help reclaim some of this bloat, but it’s far better to avoid it in the first place.
Imagine if it were possible to look at the last 7 days memory usage of a VM running Java workloads and immediately see the inefficiencies. Alongside the amount of memory your Java processes actually consumed, it shows how much less memory they could have potentially used and how much was wasted.
EM4J monitoring empowers you to confidently make well-informed capacity planning decisions of both the VM and the Java processes running in it.
Do you worry that the changes to your Java configuration may be harmful?
Imagine being able to see the real impact of workload spikes on your JVM’s memory usage. How about knowing ahead of time that a configuration change has the potential to cause undesirable guest paging? And if guest paging does occur for any reason, being able to see exactly when it happened and the extent of it.
EM4J monitoring can give you a powerful before and after picture to help you make the right configuration decisions and monitor the results. For example, you can bring down your initial JVM heap size and allow the JVM to find a more efficient high water mark that reflects your real working set, then watch the impact on GC frequency.
EM4J gives you the insight you need to make the right configuration choices.
Configure your Java applications and apply best practices with confidence
VMware has long published excellent guidance and best practices on virtualizing Java applications. EM4J incorporates some of those key best practices into vCenter information and alerts. VM and JVM level guidance is just a mouse click away.
Back-of-the-envelope static memory calculations can now be replaced with real empirical data. See which of your JVMs are configured to use large memory pages and how many large pages they’re really using.
There is also first-class support for EM4J ballooning in the monitoring tool! Clearly see the effect over time of EM4J reclaiming memory from Java processes.
Do more with less! Memory over-commitment with Java is now feasible
The Elastic part of EM4J refers to the ability to take the long-established memory reclamation technique called ballooning and apply it directly to the JVM. This allows the hypervisor and the JVMs running on it to work together and co-operatively shuffle memory resources to the workloads that most need it.
Wouldn't it be great if the batch jobs you run overnight could utilize the memory currently chock full of stale session data, cold cache entries and garbage instead of requiring their own proprietary memory?
What if your servers running in Asia Pacific could take memory from the servers running in Western Europe and vice versa to maximize usage?
This is exactly what EM4J ballooning is designed to do. Work with Java to efficiently place memory where it's needed.