What do you get with Print?

Instant access to your digital copy whilst your Print order is Shipped

Paperback book shipped to your preferred address

Redeem a companion digital copy on all Print orders

Access this title in our online reader with advanced features

DRM FREE - Read whenever, wherever and however you want

Oracle JRockit: The Definitive Guide

Chapter 1. Getting Started

While parts of this book, mainly the first part, contain generic information on the inner workings of all adaptive runtimes, the examples and in-depth information still assume that the JRockit JVM is used. This chapter briefly explains how to obtain the JRockit JVM and covers porting issues that may arise while deploying your Java application on JRockit.

In this chapter, you will learn:

How to obtain JRockit
The platforms supported by JRockit
How to migrate to JRockit
About the command-line options to JRockit
How to interpret JRockit version numbers
Where to get help if you run into trouble

Obtaining the JRockit JVM

To get the most out of this book, the latest version of the JRockit JVM is required. For JRockit versions prior to R27.5, a license key was required to access some of the more advanced features in JRockit. As part of the Oracle acquisition of BEA Systems, the license system was removed and it is now possible to access all features in JRockit without any license key at all. This makes it much easier to evaluate JRockit and to use JRockit in development. To use JRockit in production, a license must still be purchased. For Oracle customers, this is rarely an issue, as JRockit is included with most application suites, for example, any suite that includes WebLogic Server will also include JRockit.

At the time of writing, the easiest way to get a JRockit JVM is to download and install JRockit Mission Control—the diagnostics and profiling tools suite for JRockit. The folder layout of the Mission Control distribution is nearly identical to that of any JDK and can readily be used as a JDK. The authors would very much like to be able to provide a self-contained JVM-only JDK for JRockit, but this is currently beyond our control. We anticipate this will change in the near future.

Before JRockit Mission Control is downloaded, ensure that a supported platform is used. The server part of Mission Control is supported on all platforms for which JRockit is supported.

Following is the platform matrix for JRockit Mission Control 3.1.x:

Platform	Java 1.4.2	Java 5.0	Java 6
Linux x86	X	X	X
Linux x86-64	N/A	X	X
Linux Itanium	X (server only)	X (server only)	N/A
Solaris SPARC (64-bit)	X (server only)	X (server only)	X (server only)
Windows x86	X	X	X
Windows x86-64	N/A	X (server only)	X (server only)
Windows Itanium	X (server only)	X (server only)	N/A

Following is the platform matrix for JRockit Mission Control 4.0.0:

Platform	Java 5.0	Java 6
Linux x86	X	X
Linux x86-64	X	X
Solaris SPARC (64-bit)	X (server only)	X (server only)
Windows x86	X	X
Windows x86-64	X	X

Note that the JRockit Mission Control client is not (yet) supported on Solaris, but that 64-bit Windows support has been added in 4.0.0.

Note

When running JRockit Mission Control on Windows, ensure that the system's temporary directory is on a file system that supports per-user file access rights. In other words, make sure it is not on a FAT formatted disk. On a FAT formatted disk, essential features such as automatic discovery of local JVMs will be disabled.

The easiest way to get to the JRockit home page is to go to your favorite search engine and type in "download JRockit". You should end up on a page on the Oracle Technology Network from which the JVM and the Mission Control suite can be downloaded. The installation process varies between platforms, but should be rather self explanatory.

Migrating to JRockit

Throughout this book, we will refer to the directory where the JRockit JVM is installed as JROCKIT_HOME. It might simplify things to make JROCKIT_HOME a system variable pointing to that particular path. After the installation has completed, it is a good idea to put the JROCKIT_HOME/bin directory on the path and to update the scripts for any Java applications that should be migrated to JRockit. Setting the JAVA_HOME environment variable to JROCKIT_HOME is also recommended. In most respects JRockit is a direct drop in replacement for other JVMs, but some startup arguments, for example arguments that control specific garbage collection behavior, typically differ between JVMs from different vendors. Common arguments, however, such as arguments for setting a maximum heap size, tend to be standardized between JVMs.

Note

For more information about specific migration details, see the Migrating Applications to the Oracle JRockit JDK Chapter in the online documentation for JRockit.

Command-line options

There are three main types of command-line options to JRockit—system properties, standardized options (-X flags), and non-standard ones (-XX flags).

System properties

Startup arguments to a JVM come in many different flavors. Arguments starting with –D are interpreted as a directive to set a system property. Such system properties can provide configuration settings for various parts of the Java class libraries, for example RMI. JRockit Mission Control provides debugging information if started with –Dcom.jrockit.mc.debug=true. In JRockit versions post R28, the use of system properties to provide parameters to the JVM has been mostly deprecated. Instead, most options to the JVM are provided through non-standard options and the new HotSpot style VM flags.

Standardized options

Configuration settings for the JVM typically start with -X for settings that are commonly supported across vendors. For example, the option for setting the maximum heap size, -Xmx, is the same on most JVMs, JRockit included. There are a few exceptions here. The JRockit flag –Xverbose provides logging with optional sub modules. The similar (but more limited) flag in HotSpot is called just –verbose.

Non-standard options

Vendor-specific configuration options are usually prefixed with -XX. These options should be treated as potentially unsupported and subject to change without notice. If any JVM setup depends on -XX-prefixed options, those flags should be removed or ported before an application is started on a JVM from a different vendor.

Once the JVM options have been determined, the user application can be started. Typically, moving an existing application to JRockit leads to an increase in runtime performance and a slight increase in memory consumption.

The JVM documentation should always be consulted to determine if non-standard command-line options have the same semantics between different JVMs and JVM versions.

VM flags

In JRockit versions post R28, there is also a subset of the non-standard options called VM flags. The VM flags use the -XX:<flag>=<value> syntax. These flags can also be read and, depending on the particular flag, written using the command-line utility JRCMD after the JVM has been started. For more information on JRCMD, see Chapter 11.

Changes in behavior

Sometimes there is a change of runtime behavior when moving from one JVM to another. Usually it boils down to different JVMs interpreting the Java Language Specification or Java Virtual Machine Specification differently, but correctly. In several places there is some leeway in the specification that allows different vendors to implement the functionality in a way that best suits the vendor's architecture. If an application relies too much on a particular implementation of the specification, the application will almost certainly fail when switching to another implementation.

For example, during the milestone testing for an older version of Eclipse, some of the tests started failing when running on JRockit. This was due to the tests having inter-test dependencies, and this particular set of tests were relying on the test harness running the tests in a particular order. The JRockit implementation of the reflective listing of methods (Class#getDeclaredMethods) did not return the methods in the same order as other JVMs, which according to the specification is fine. It was later decided by the Eclipse development team that relying on a particular method ordering was a bug, and the tests were consequently corrected.

If an application has not been written to the specification, but rather to the behavior of the JVM from a certain vendor, it can fail. It can even fail when running with a more recent version of the JVM from the same vendor. When in doubt, consult the Java Language Specification and the documentation for the JDK.

Differences in performance may also be an issue when switching JVMs for an application. Latent bugs that weren't an issue with one JVM may well be an issue with another, if for example, performance differences cause events to trigger earlier or later than before. These things tend to generate support issues but are rarely the fault of the JVM.

For example, a customer reported that JRockit crashed after only a day. Investigation concluded that the application also crashed with a JVM from another vendor, but it took a few more days for the application to crash. It was found that the crashing program ran faster in JRockit, and that the problem; a memory leak, simply came to light much more quickly.

Naturally, any JVM, JRockit included, can have bugs. In order to brand itself "Java", a Java Virtual Machine implementation has to pass an extensive test suite—the Java Compatibility Kit (JCK).

JRockit is continuously subjected to a battery of tests using a distributed test system. Large test suites, of which the JCK is one component, are run to ensure that JRockit can be released as a stable, Java compatible, and certified JVM. Large test suites from various high profile products, such as Eclipse and WebLogic Server, as well as specially designed stress tests, are run on all supported platforms before a release can take place. Continuous testing against performance regressions is also done as a fundamental part of our QA infrastructure. Even so, bugs do happen. If JRockit does crash, it should always be reported to Oracle support engineers.

A note on JRockit versioning

The way JRockit is versioned can be a little confusing. There are at least three version numbers of interest for each JRockit release:

The JRockit JVM version.
The JDK version.
The Mission Control version.

One way to obtain the version number of the JVM is to run java –version from the command prompt. This would typically result in something like the following lines being printed to the console:

java version "1.6.0_14"
  Java(TM) SE Runtime Environment (build 1.6.0_14-b08)
  Oracle JRockit(R) (build R28.0.0-582-123273-1.6.0_14-20091029-2121-windows-ia32, compiled mode)

The first version number is the JDK version being bundled with the JVM. This number is in sync with the standard JDK versions, for the JDK shipped with HotSpot. From the example, we can gather that Java 1.6 is supported and that it is bundled with the JDK classes from update 14-b08. If you, for example, are looking to see what JDK class-level security fixes are included in a certain release, this would be the version number to check.

The JRockit version is the version number starting with an 'R'. In the above example this would be R28.0.0. Each version of the JRockit JVM is built for several different JDKs. The R27.6.5, for instance, exists in versions for Java 1.4, 1.5 (5.0) and 1.6 (6.0). With the R28 version of JRockit, the support for Java 1.4 was phased out.

The number following the version number is the build number, and the number after that is the change number from the versioning system. In the example, the build number was 582 and the change number 123273. The two numbers after the change number are the date (in compact ISO 8601 format) and time (CET) the build was made. After that comes the operating system and CPU architecture that the JVM was built for.

The version number for JRockit Mission Control can be gathered by executing jrmc -version or jrmc -version | more from the command line.

Note

On Windows, the JRockit Mission Control launcher (jrmc) is based on the javaw launcher to avoid opening a console window. Console output will not show unless explicitly redirected, for example to more.

The output should look like this:

Oracle JRockit(R) Mission Control(TM) 4.0 (for JRockit R28.0.0)
  java.vm.version = R28.0.0-582-123273-1.6.0_14-20091029-2121-windows-ia32
  build = R28.0.0-582
  chno = 123217
  jrmc.fullversion = 4.0.0
  jrmc.version = 4.0
  jrockit.version = R28.0.0
  year = 2009

The first line tells us what version of Mission Control this is and what version of JRockit it was created for. The java.vm.version line tells us what JVM Mission Control is actually running on. If Mission Control has been launched too "creatively", for example by directly invoking its main class, there may be differences between the JVM information in the two lines. If this is the case, some functionality in JRockit Mission Control, such as automatic local JVM discovery, may be disabled.

Key benefits

Learn about the fundamental building blocks of a JVM, such as code generation and memory management, and utilize this knowledge to develop code you can count on

Realize the full potential of Java applications by learning how to apply advanced tuning and analysis

Work with the JRockit Mission Control 3.1/4.0 tools suite to debug or profile your Java applications

Learn the simplicity and performance benefits of virtualizing Java through JRockit Virtual Edition

Written by Marcus Hirt and Marcus Lagergren, founder members of Appeal Virtual Machines, the company that created the Java Virtual Machine: JRockit

Description

Oracle JRockit is one of the industry’s highest performing Java Virtual Machines. Java developers are always on the lookout for better ways to analyze application behavior and gain performance. As we all know, this is not as easy as it looks. Welcome to JRockit: The Definitive Guide.This book helps you gain in-depth knowledge of Java from the JVM’s point of view. We will explain how to write code that works well with the JVM to gain performance and scalability. Starting with the inner workings of the JRockit JVM and finishing with a thorough walkthrough of the tools in the JRockit Mission Control suite, this book is for anyone who wants to know more about how the JVM executes your Java application and how to profile for better performance.

Who is this book for?

This book is for intermediate to advanced Java Developers, who want to monitor, diagnose, profile and enhance the performance of their Java applications. It is also for people who want to understand more about the internal workings of a modern Java Virtual Machine or adaptive runtime. Parts of the book are suitable as course material for education about runtimes.

What you will learn

Get to grips with the fundamental building blocks of a JVM: the code generator, the garbage collector, and the implementation of threads and synchronization. Learn the design philosophy behind the JRockit JVM in these areas.

Become a better Java programmer through enhanced understanding of the Java runtime.

Learn how program execution works in an adaptive environment.

Create relevant benchmarks and accurately measure the performance of your Java application.

Learn the most important command-line flags that control JRockit subsystems and their use for performance tuning.

Get to know what JRockit Mission Control is, how to set it up, and how to trouble-shoot it.

Use the JRockit Management Console to monitor and manage a running JRockit instance.

Profile your JRockit JVM and Java application with near zero overhead using the JRockit Runtime Analyzer and the JRockit Flight Recorder.

Detect and resolve Java memory leaks using the JRockit Memory Leak Detector tool.

Learn how JRockit Virtual Edition works and why it outperforms other Java solutions in traditional virtualized environments.

What do you get with Print?

Instant access to your digital copy whilst your Print order is Shipped

Paperback book shipped to your preferred address

Redeem a companion digital copy on all Print orders

Access this title in our online reader with advanced features

DRM FREE - Read whenever, wherever and however you want

Frequently bought together

Getting Started with Oracle WebLogic Server 12c: Developer's Guide

$60.99

$76.99

Total $ 137.98

Filter reviews by

All

Amazon verified reviews

Alexey Shurygin Oct 28, 2019

Love it. Not so many books out there about JVM development. This is one of a few and an excellent one. Thanks Marcus!

Amazon Verified review

Norman Maurer Sep 24, 2013

If you ever wanted to know what is going on behind the scenes of the JVM, this book is your best bet. I highly recommend it to everyone who wants to do serious programming of high-performance applications on the JVM. For me it's one of the most important books in my book shelf. The authors are well known for their knowledge in this area and make it easy to gasp the ideas while reading it. It contains many informations which includes (to only name a few) JIT optimizations, GC, Allocations, Memory management, best practices and known pitfalls.Don't get confused by the name of the book, most of the informations inside apply to other JVM implementations as well. Now that most of the "original" code of JRockit is part of openjdk / oracle jdk it's even more spot on then before. As Mission Control was just released as part of oracle jdk7u40 the contained chapters in the book that covers the "JRockit Mission Control" are a nice addition to the docs out there.So to make it short, if you are looking for something that explains the JVM in detail this book is the one to buy right away.

Noora Peura Aug 09, 2010

I have been involved in developing both the JRockit JVM and JRockit Mission Control for nine years and I am thus very familiar with the subject of this book. I already knew that the authors are brilliant engineers who know what they are talking about. This book also shows that they can talk about it well. Marcus and Marcus have managed to condense years of research and development into one book and translate it to "human readable" format. This book takes you under the hood and behind the scenes of JRockit. It digs deep and goes personal, explaining not only how the JVM works but also why.This is a book for Java developers who take their craft seriously and want to open the black box beneath them and make friends with the mystical creature that resides inside. This is a book for Java administrators who want hands-on tips on how to make their life easier and their applications run better and faster. This is a book for the computer science geek who simply needs to know how all the magic is done.The first part of the book opens up the JVM, pulls out the parts and puts them on display. These chapters describe code generation, memory management, threads and locks, both in general and in the specific example of the JRockit JVM. This is more than a whitepaper on JRockit internals, this is a complete schoolbook in JVMs. With each chapter you also get pointers for what to do and especially what not to do in order to work with the black box rather than against it.After a chapter on benchmarking and tuning comes the probably most comprehensive guide available to the JRockit tools - JRockit Mission Control and JRCMD. Plenty of screenshots and example outputs take you through the tools, how to use them and even how to extend them.The last chapter introduces JRockit Virtual Edition that takes the JVM closer to the hardware by eliminating the operating system. It also takes a look at where JVM development may be heading in the future.Personally, I especially enjoyed reading the history of the JRockit JVM, and the authors' own comments on Java and software development. These are the details that take the book beyond a technical description of JRockit and help you understand the design choices behind this complex piece of technology.

M. Eisele Nov 23, 2010

This one was on my list of things to buy for quite some time. The only reason for this is simple: Oracle JRockit is one of the industry's highest performing Java Virtual Machines and I loved it's JIT everything approach since the beginning. I did not manage to do this, since it was published. But a few days ago, the digital edition arrived on my iPad and I finally found the time to read it. Sit back and relax. This is my personal view about the most stunning Java related book of 2010!The AuthorsAs usual, I start with a short introduction of the authors. In this special case, I feel this is very important to understand the book. Both started out with Appeal Virtual Machines where they were founders. This was the company, which initially developed JRockit. Marcus Lagergren holds a M.Sc. in computer science from the Royal Institute of Technology in Stockholm, Sweden. He has a background in computer security but has worked with runtimes since 1999. Marcus has been team lead and architect for the JRockit code generators and has been involved in pretty much every other aspect of the JRockit JVM internals. Since 2007 Marcus works for Oracle on fast Virtualization technology.Marcus Hirt is currently working for Oracle as Team Lead, Engineering Manager and Architect for the JRockit Mission Control team. Marcus has been an appreciated speaker on Oracle Open World, eWorld, BEAWorld, EclipseCon, Nordev and Expert Zone Developer Summit, and has contributed JRockit related articles and webinars to the JRockit community. Marcus Hirt got his M.Sc. education in computer science from the Royal Institute of Technology in Stockholm.The ContentJava developers are always on the lookout for better ways to analyze application behavior and gain performance. As we all know, this is not as easy as it looks. If you are trying to understand more about all this you need to know far more than simple Java. The big things in terms of performance happen elsewhere: In the JVM. If you are looking for the best Server JVM out there, you'll come across JRockit. And this book is there to reveal it's secrets. This book helps you gain in-depth knowledge of Java from the JVM's point of view. It explains how to write code that works well with the JVM to gain performance and scalability.The first chapter get's you started. You learn about the real basics. Cmd-line options and JRockit versioning. The real content starts with chapter 2. It brings you down to the inner workings of the JVM and the adaptive code generation ürinciples. If you are not used to assembly code examples, you will learn it. Examples are explained with bytecode and assemly code. If necessary instruction by instruction. Further on, code generation strategies, JIT compiling and runtime optimizations are explained as concepts with additional JRockit details. Chapter 3 takes you over to adaptive memory management. Here you will learn about the basics of heap management and garbage collection algorithms. Also scaling and performance are touched here. You get a glimpse at pitfalls and things, that will not work. Chapter 4 follows with everything about threads and synchronization and topics that are hard to debug and difficult to optimize. You get a more detailed look at special JRockit flags which help optimizing the topic. Chapter 5 gives your everything about benchmarking and tuning. You get basic hints about what to think about while creating a benchmark and about which measures to take. It also contains a brief overview about industry-standard benchmarks. After that you get to know about common bottlenecks and how to avoid them. Chapter 6 presents an overview about the JRockit Mission Control. Followed by chapter 7 which dives into the management console, touching MBeans, the runtime and further topics. The runtime analyzer is detailed in chapter 8. Learn about the recordings and how to analyze them in terms of memory, code, threads/locks and latency findings. As expected the flight recorder follows in chapter 9. Another JRockit tool, the memory leak detector is the major player in chapter 10. Chapter 11 dives into the JRCMD cmd-line utility and shows how it can be used for listing and sending diagnostic cmds to one or more locally running instance of the JVM. It's an alphabetical reference guide to the JRCMD commands. Chapter 12 contains everything you need to know about using the JRockit management APIs by showcasing examples. The last chapter 13 summarizes the basics about the JRockit Virtual Edition and gives some basics about the challenges by virtualizing Java. If needed you can dive deeper with the bibliography or even look through the glossary or index. 477 pages of content without the preface and the appendix is a big hit for your weekend. You better have some very silent times to follow this stuff!Writing and styleAs you might have guessed already: I am impressed by the book. Being used to read complex and detailed stuff which takes time, I really flew through this book. You get used to the direct and technical style very easy and it's still personal enough to be interesting so you keep on reading page after page. Even non native speakers should be able to follow, if they know the technical terms. I needed to lookup some very uncommon and hardware near things but this did not disturb the overall reading experience.This was my fist eBook as PDF from Packt Publishing and I am not sure, if I am still willing to have the printed version, too. The many assembly and other code examples always makes you want to scroll back. If you are using a book you just need your thumb to solve this problem :) But I still like the digital reading experience in general.My expectationsThe structure is a bit different from the one I expected. The tooling around JRockit is covered a lot; something I wasn't expecting. But this is the only part, that did not fulfill my expectations. Especially because even those parts are excellent.I expected to read some very technical content. But it was far more than that. It goes down to the metal and handles and registers and the JVM internals. If you thought, you know anything about the inner workings of a JVM ... here is what really happens. Don't ask what you can do for your JVM; ask, what your JVM can do for you :)Conclusion and recommendationBuy one! No .. better two! The digital edition and of course the paperback. It's worth it. If you have both, you can always carry the digital edition around and recall the basics and optimizations to yourself every time you think about writing optimized code for the JVM. Make shure, you have a silent place to read this one. And you should get a recent JRockit R28 to play around with. I wrote articles about it and I have seen it in the wild since some time. I thought I know a bit. Now, I know even more!If you are a beginner, you probably need some more basics before reading this one.

GR Feb 08, 2012

As a technical performance tester this book was great in understanding more about JVMs (in particular JRockit!), well written and easy to read.

Oracle JRockit: The Definitive Guide: Understanding Adaptive Runtimes using JRockit R27/28

What do you get with Print?

Oracle JRockit: The Definitive Guide

Chapter 1. Getting Started

Obtaining the JRockit JVM

Note

Migrating to JRockit

Note

Command-line options

System properties

Standardized options

Non-standard options

VM flags

Changes in behavior

A note on JRockit versioning

Note

Getting help

Note

Summary

Page 1 of 6

Key benefits

Description

Who is this book for?

What you will learn

Product Details

What do you get with Print?

Product Details

Frequently bought together

Table of Contents

Recommendations for you

Customer reviews

Filter reviews by

People who bought this also bought

FAQs

Oracle JRockit: The Definitive Guide: Understanding Adaptive Runtimes using JRockit R27/28

What do you get with Print?

Contact Details

Shipping Address

Billing Address

VM flags

Key benefits

Description

Who is this book for?

What you will learn

Product Details

What do you get with Print?

Contact Details

Shipping Address

Billing Address

Product Details

Packt Subscriptions

Frequently bought together

Table of Contents

Recommendations for you

Customer reviews

Filter reviews by

People who bought this also bought

FAQs