Oracle JRockit: The Definitive Guide

Table of Contents

• Preface

• Chapter 1: Getting Started
  • Obtaining the JRockit JVM
  • Migrating to JRockit
    • Command-line options
      • System properties
      • Standardized options
      • Non-standard options
    • Changes in behavior
  • A note on JRockit versioning
  • Getting help
  • Summary

• Chapter 2: Adaptive Code Generation
  • Platform independence
  • The Java Virtual Machine
    • Stack machine
    • Bytecode format
      • Operations and operands
      • The constant pool
  • Code generation strategies
    • Pure bytecode interpretation
    • Static compilation
    • Total JIT compilation
    • Mixed mode interpretation
  • Adaptive code generation
    • Determining "hotness"
      • Invocation counters
      • Software-based thread sampling
      • Hardware-based sampling
    • Optimizing a changing program
  • Inside the JIT compiler
    • Working with bytecode
      • Bytecode obfuscation
    • Bytecode "optimizers"
      • Abstract syntax trees
    • Where to optimize
  • The JRockit code pipeline
    • Why JRockit has no bytecode interpreter
    • Bootstrapping
    • Runtime code generation
      • Trampolines
      • Code generation requests
      • Optimization requests
      • On-stack replacement
      • Bookkeeping
    • A walkthrough of method generation in JRockit
      • The JRockit IR format
      • JIT compilation
      • Generating optimized code
  • Controlling code generation in JRockit
    • Command-line flags and directive files
      • Command-line flags
      • Directive files
  • Summary

• Chapter 3: Adaptive Memory Management
  • The concept of automatic memory management
    • Adaptive memory management
    • Advantages of automatic memory management
    • Disadvantages of automatic memory management
  • Fundamental heap management
    • Allocating and releasing objects
    • Fragmentation and compaction
  • Garbage collection algorithms
    • Reference counting
    • Tracing techniques
      • Mark and sweep
      • Stop and copy
    • Stopping the world
      • Conservative versus exact collectors
      • Livemaps
    • Generational garbage collection
      • Multi generation nurseries
      • Write barriers
    • Throughput versus low latency
      • Optimizing for throughput
      • Optimizing for low latency
    • Garbage collection in JRockit
      • Old collections
      • Nursery collections
      • Permanent generations
      • Compaction
  • Speeding it up and making it scale
    • Thread local allocation
    • Larger heaps
      • 32-Bits and the 4-GB Barrier
      • The 64-bit world
    • Cache friendliness
      • Prefetching
      • Data placement
    • NUMA
    • Large pages
    • Adaptability
  • Near-real-time garbage collection
    • Hard and soft real-time
    • JRockit Real Time
      • Does the soft real-time approach work?
      • How does it work?
  • The Java memory API
    • Finalizers
    • References
      • Weak references
      • Soft references
      • Phantom references
    • Differences in JVM behavior
  • Pitfalls and false optimizations
    • Java is not C++
  • Controlling JRockit memory management
    • Basic switches
      • Outputting GC data
      • Set initial and maximum heap size
      • Controlling what to optimize for
      • Specifying a garbage collection strategy
    • Compressed references
    • Advanced switches
  • Summary

• Chapter 4: Threads and Synchronization
  • Fundamental concepts
    • Hard to debug
    • Difficult to optimize
      • Latency analysis
  • Java API
    • The synchronized keyword
    • The java.lang.Thread class
    • The java.util.concurrent package
    • Semaphores
    • The volatile keyword
  • Implementing threads and synchronization in Java
    • The Java Memory Model
      • Early problems and ambiguities
      • JSR-133
    • Implementing synchronization
      • Primitives
      • Locks
    • The Java bytecode implementation
      • Lock pairing
    • Implementing threads
      • Green threads
      • OS threads
  • Optimizing threads and synchronization
    • Lock inflation and lock deflation
    • Recursive locking
    • Lock fusion
    • Lazy unlocking
      • Implementation
      • Object banning
      • Class banning
      • Results
  • Pitfalls and false optimizations
    • Thread.stop, Thread.resume and Thread.suspend
    • Double checked locking
  • JRockit flags
    • Examining locks and lazy unlocking
      • Lock details from -Xverbose:locks
      • Controlling lazy unlocking with–XX:UseLazyUnlocking
    • Using SIGQUIT or Ctrl-Break for Stack Traces
    • Lock profiling
      • Enabling lock profiling with -XX:UseLockProfiling
    • Setting thread stack size using -Xss
    • Controlling lock heuristics
  • Summary

• Chapter 5: Benchmarking and Tuning
  • Reasons for benchmarking
    • Performance goals
    • Performance regression testing
    • Easier problem domains to optimize
    • Commercial success
  • What to think of when creating a benchmark
    • Measuring outside the system
    • Measuring several times
    • Micro benchmarks
      • Micro benchmarks and on-stack replacement
      • Micro benchmarks and startup time
    • Give the benchmark a chance to warm-up
  • Deciding what to measure
    • Throughput
    • Throughput with response time and latency
    • Scalability
    • Power consumption
    • Other issues
  • Industry-standard benchmarks
    • The SPEC benchmarks
      • The SPECjvm suite
      • The SPECjAppServer / SPECjEnterprise2010 suite
      • The SPECjbb suite
    • SipStone
    • The DaCapo benchmarks
    • Real world applications
  • The dangers of benchmarking
  • Tuning
    • Out of the box behavior
    • What to tune for
      • Tuning memory management
      • Tuning code generation
      • Tuning locks and threads
      • Generic tuning
  • Common bottlenecks and how to avoid them
    • The –XXaggressive flag
    • Too many finalizers
    • Too many reference objects
    • Object pooling
    • Bad algorithms and data structures
      • Classic textbook issues
      • Unwanted intrinsic properties
    • Misuse of System.gc
    • Too many threads
    • One contended lock is the global bottleneck
    • Unnecessary exceptions
    • Large objects
    • Native memory versus heap memory
  • Wait/notify and fat locks
    • Wrong heap size
    • Too much live data
    • Java is not a silver bullet
  • Summary

• Chapter 6: JRockit Mission Control
  • Background
    • Sampling-based profiling versus exact profiling
    • A different animal to different people
  • Mission Control overview
    • Mission Control server-side components
    • Mission Control client-side components
    • Terminology
    • Running the standalone version of Mission Control
    • Running JRockit Mission Control inside Eclipse
    • Starting JRockit for remote management
      • The JRockit Discovery Protocol
    • Running in a secure environment
    • Troubleshooting connections
      • Hostname resolution issues
  • The Experimental Update Site
  • Debugging JRockit Mission Control
  • Summary

• Chapter 7: The Management Console
  • A JMX Management Console
  • Using the console
    • General
      • The Overview
    • MBeans
      • MBean Browser
      • Triggers
    • Runtime
      • System
      • Memory
      • Threads
    • Advanced
      • Method Profiler
      • Exception Count
      • Diagnostic Commands
    • Other
      • JConsole
  • Extending the JRockit Mission Control Console
  • Summary

• Chapter 8: The Runtime Analyzer
  • The need for feedback
    • Recording
  • Analyzing JRA recordings
    • General
      • Overview
      • Recording
      • System
    • Memory
      • Overview
      • GCs
      • GC Statistics
      • Allocation
      • Heap Contents
      • Object Statistics
    • Code
      • Overview
      • Hot Methods
      • Optimizations
    • Thread/Locks
      • Overview
      • Threads
      • Java Locks
      • JVM Locks
      • Thread Dumps
    • Latency
      • Overview
      • Log
      • Graph
      • Threads
      • Traces
      • Histogram
    • Using the Operative Set
  • Troubleshooting
  • Summary

• Chapter 9: The Flight Recorder
  • The evolved Runtime Analyzer
    • A word on events
    • The recording engine
    • Startup options
      • Starting time-limited recordings
  • Flight Recorder in JRockit Mission Control
    • Advanced Flight Recorder Wizard concepts
  • Differences to JRA
    • The range selector
    • The Operative Set
    • The relational key
    • What's in a Latency?
    • Exception profiling
    • Memory
  • Adding custom events
  • Extending the Flight Recorder client
  • Summary

• Chapter 10: The Memory Leak Detector
  • A Java memory leak
    • Memory leaks in static languages
    • Memory leaks in garbage collected languages
  • Detecting a Java memory leak
  • Memleak technology
  • Tracking down the leak
    • A look at classloader-related information
  • Interactive memory leak hunting
  • The general purpose heap analyzer
  • Allocation traces
  • Troubleshooting Memleak
  • Summary

• Chapter 11: JRCMD
  • Introduction
  • Overriding SIGQUIT
    • Special commands
  • Limitations of JRCMD
  • JRCMD command reference
    • check_flightrecording (R28)
    • checkjrarecording (R27)
    • command_line
    • dump_flightrecording (R28)
    • heap_diagnostics (R28)
    • hprofdump (R28)
    • kill_management_server
    • list_vmflags (R28)
    • lockprofile_print
    • lockprofile_reset
    • memleakserver
    • oom_diagnostics (R27)
    • print_class_summary
    • print_codegen_list
    • print_memusage (R27)
    • print_memusage (R28)
    • print_object_summary
    • print_properties
    • print_threads
    • print_utf8pool
    • print_vm_state
    • run_optfile (R27)
    • run_optfile (R28)
    • runfinalization
    • runsystemgc
    • set_vmflag (R28)
    • start_flightrecording (R28)
    • start_management_server
    • startjrarecording (R27)
    • stop_flightrecording (R28)
    • timestamp
    • verbosity
    • version
  • Summary

• Chapter 12: Using the JRockit Management APIs
  • JMAPI
    • JMAPI examples
  • JMXMAPI
    • The JRockit internal performance counters
    • An example—building a remote version of JRCMD
  • Summary

• Chapter 13: JRockit Virtual Edition
  • Introduction to virtualization
    • Full virtualization
    • Paravirtualization
    • Other virtualization keywords
    • Hypervisors
      • Hosted hypervisors
      • Native hypervisors
      • Hypervisors in the market
    • Advantages of virtualization
    • Disadvantages of virtualization
  • Virtualizing Java
    • Introducing JRockit Virtual Edition
      • The JRockit VE kernel
    • The virtual machine image concept and management frameworks
    • Benefits of JRockit VE
      • Performance and better resource utilization
      • Manageability
      • Simplicity and security
    • Constraints and limitations of JRockit VE
  • A look ahead—can virtual be faster than real?
    • Quality of hot code samples
    • Adaptive heap resizing
    • Inter-thread page protection
      • Improved garbage collection
      • Concurrent compaction
  • Summary

• Appendix A: Bibliography

• Appendix B: Glossary

• Index

Marcus Hirt

Marcus Lagergren

This book is a must-have for any serious enterprise Java developer or administrator who uses JRockit and wants to better understand how to tune, manage and monitor the JVM. Read More

My personal conclusion about this book: It's really a must for everybody who is working with the Oracle JRockit, no matter if you are a developer or a WebLogic Server Administrator. Read More

Code Downloads

Download the code and support files for this book.

Submit Errata

Please let us know if you have found any errors not listed on this list by completing our errata submission form. Our editors will check them and add them to this list. Thank you.

Sample chapters

You can view our sample chapters and prefaces of this title on PacktLib or download sample chapters in PDF format.