Book Image

Oracle JRockit: The Definitive Guide

Book Image

Oracle JRockit: The Definitive Guide

Overview of this book

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.

Related Content you might be interested in

Current Title:

Small book image
Oracle JRockit: The Definitive Guide
Jun, 2010 | 588 pages
No titles found
Table of Contents (23 chapters)
Oracle JRockit
Oracle JRockit
Credits
Credits
Foreword
Foreword
About the Authors
About the Authors
Acknowledgement
Acknowledgement
About the Reviewers
About the Reviewers
Preface
Preface
Free Chapter
1
Getting Started
Getting Started
Obtaining the JRockit JVM
Migrating to JRockit
A note on JRockit versioning
Getting help
Summary
2
Adaptive Code Generation
Adaptive Code Generation
Platform independence
The Java Virtual Machine
Code generation strategies
Adaptive code generation
Inside the JIT compiler
The JRockit code pipeline
Controlling code generation in JRockit
Summary
3
Adaptive Memory Management
Adaptive Memory Management
The concept of automatic memory management
Fundamental heap management
Garbage collection algorithms
Speeding it up and making it scale
Near-real-time garbage collection
The Java memory API
Pitfalls and false optimizations
Controlling JRockit memory management
Summary
4
Threads and Synchronization
Threads and Synchronization
Fundamental concepts
Java API
Implementing threads and synchronization in Java
Optimizing threads and synchronization
Pitfalls and false optimizations
JRockit flags
Summary
5
Benchmarking and Tuning
Benchmarking and Tuning
Reasons for benchmarking
What to think of when creating a benchmark
Deciding what to measure
Industry-standard benchmarks
The dangers of benchmarking
Tuning
Common bottlenecks and how to avoid them
Wait/notify and fat locks
Summary
6
JRockit Mission Control
JRockit Mission Control
Background
Mission Control overview
The Experimental Update Site
Debugging JRockit Mission Control
Summary
7
The Management Console
The Management Console
A JMX Management Console
Using the console
Extending the JRockit Mission Control Console
Summary
8
The Runtime Analyzer
The Runtime Analyzer
The need for feedback
Analyzing JRA recordings
Troubleshooting
Summary
9
The Flight Recorder
The Flight Recorder
The evolved Runtime Analyzer
Flight Recorder in JRockit Mission Control
Differences to JRA
Adding custom events
Extending the Flight Recorder client
Summary
10
The Memory Leak Detector
The Memory Leak Detector
A Java memory leak
Detecting a Java memory leak
Memleak technology
Tracking down the leak
Interactive memory leak hunting
The general purpose heap analyzer
Allocation traces
Troubleshooting Memleak
Summary
11
JRCMD
JRCMD
Introduction
Overriding SIGQUIT
Limitations of JRCMD
JRCMD command reference
Summary
12
Using the JRockit Management APIs
Using the JRockit Management APIs
JMAPI
JMXMAPI
Summary
13
JRockit Virtual Edition
JRockit Virtual Edition
Introduction to virtualization
Virtualizing Java
A look ahead—can virtual be faster than real?
Summary
Bibliography
Bibliography
Glossary
Glossary
Abstract syntax tree
Access file
Adaptive code generation
Adaptive memory management
Agent
Ahead-of-time compilation
Allocation profiling
AST
Atomic instructions
Automatic memory management
Balloon driver
Basic block
Benchmark driver
Biased locking
Bytecode
Bytecode interpretation
Call profiling
Card
Card Table
CAS
Class block
Class garbage collection
Client-side template
Cloud
Code generation queue
Color
Compaction
Compare and swap
Compressed references
Concurrent garbage collection
Conservative garbage collection
Constant pool
Continuous JRA
Control flow graph
CPU profiling
Critical section
Dead code
Deadlock
Deadlock detection
Design mode
Deterministic garbage collection
Diagnostic command
Double-checked locking
Driver
Editor
Escape analysis
Event
Event attribute
Event field
Event settings
Event type
Exact garbage collection
Exact profiling
Extension point
Fairness
Fat lock
Fragmentation
Free list
Full virtualization
GC heuristic
GC pause ratio
GC strategy
Generation
Generational garbage collection
Graph coloring
Graph fusion
Green threads
Guard page
Guest
Hard real-time
Hardware prefetching
Heap
HIR
Hosted hypervisor
Hypervisor
Inlining
Intermediate representation
Internal pointer
IR
Invocation counters
Java bytecode
Java Memory Model
JFR
JIT compilation
JMAPI
JMX
JMXMAPI
JRA
JRCMD
JRMC
JRockit
JRockit Flight Recorder
JRockit Memory Leak Detector
JRockit Mission Control
JRockit Runtime Analyzer
JSR
JSR-133
JSR-174
JSR-292
JVM Browser
Keystore
Lane
Large pages
Latency
Latency threshold
Lazy unlocking
LIR
Livelock
Livemap
Live object
Live set
Live Set + Fragmentation
Lock deflation
Lock fusion
Lock inflation
Lock pairing
Lock token
Lock word
Mark and sweep
Master password
MBean
MBean server
MD5
Memleak
Memory Model
Method garbage collection
Micro benchmark
MIR
Mixed mode interpretation
Monitor
Name mangling
Native code
Native hypervisor
Native memory
Native threads
Non-contiguous heaps
NxM threads
NUMA
Nursery
Obfuscation
Object header
Object pooling
Old space
On-stack replacement
Operative set
Optimization queue
Out of the box behavior
Overprovisioning
OS threads

Page protection
Parallel garbage collection
Paravirtualization
Password file
PDE
Perspective
Phantom References
Prefetching
Producer
Promotion
RCP
Read barrier
Real-time
Recording agent
Recording engine
Recursive lock
Reference compression
Reference counting
Reference decompression
Register allocation
Relational key
Rich client platform
Role
Rollforwarding
Root set
Run mode
Safepoint
Samples
Sample-based profiling
Semaphore
Server-side template
Soft real-time
Soft references
Software prefetching
Spilling
Spinlock
SSA form
Static compilation
Stop and copy
Stopping the world
Strong references
SWT
Synthetic attribute
Tab group
Tab group toolbar
Thin lock
Thread local allocation
Thread local area
Thread local heap
Thread pooling
Thread sampling
Throughput
TLA
Tracing garbage collection
Trampoline
Trigger action
Trigger condition
Trigger constraint
Trigger rule
Truststore
Virtualization
Virtual machine image
Volatile fields
Warm up round
Weak reference
Write barrier
Young space
Index
Index

The Java Virtual Machine

While platform-independent bytecode provides complete portability between different hardware platforms, a physical CPU still can't execute it. The CPU only knows to execute its particular flavor of native code.

Note

Throughout this text, we will refer to code that is specific to a certain hardware architecture as native code. For example, x86 assembly language or x86 machine code is native code for the x86 platform. Machine code should be taken to mean code in binary platform-dependent format. Assembly language should be taken to mean machine code in human-readable form.

Thus, the JVM is required to turn the bytecodes into native code for the CPU on which the Java application executes. This can be done in one of the following two ways (or a combination of both):

  • The Java Virtual Machine specification fully describes the JVM as a state machine, so there is no need to actually translate bytecode to native code. The JVM can emulate the entire execution state of the Java...

Previous Section
End of Section 3
Next Section