Oracle JRockit The Definitive Guide -- Table of Contents -- Oracle JRockit -- Credits -- Foreword -- About the Authors -- Acknowledgement -- About the Reviewers -- Preface -- What this book covers -- What you need for this book -- Who this book is for -- Conventions -- Reader feedback -- Customer support -- Errata -- Piracy -- Questions -- 1. Getting Started -- Obtaining the JRockit JVM -- Migrating to JRockit -- Command-line options -- System properties -- Standardized options -- Non-standard options -- VM flags -- Changes in behavior -- A note on JRockit versioning -- Getting help -- Summary -- 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 -- Object information for GC -- Source code and variable information -- Assumptions made about the generated code -- A walkthrough of method generation in JRockit -- The JRockit IR format -- Data flow -- Control flow -- A word about exceptions -- JIT compilation -- Generating HIR -- MIR -- LIR -- Register allocation -- Native code emission -- Generating optimized code -- A general overview -- How does the optimizer work?.

Controlling code generation in JRockit -- Command-line flags and directive files -- Command-line flags -- Logging -- Turning off optimizations -- Changing the number of code generation threads -- Directive files -- Summary -- 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 -- Compressed references -- 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.

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 -- Immutability -- JSR-133 -- Implementing synchronization -- Primitives -- Locks -- Thin locks -- Fat locks -- A word on fairness -- The lock word in JRockit -- The Java bytecode implementation -- Lock pairing -- Implementing threads -- Green threads -- N x M threads -- OS threads -- Thread pooling -- 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 -- JRCMD -- Setting thread stack size using -Xss -- Controlling lock heuristics -- Summary -- 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 -- Heap sizes -- The GC algorithm -- Compaction -- Tweaking System.gc -- Nursery size -- GC strategies -- Thread local area size and large objects -- Number of GC threads -- NUMA and CPU affinity -- Tuning code generation -- Call profiling -- Changing the number of optimization threads -- Turning off code optimizations -- Tuning locks and threads -- Lazy unlocking -- Enforcing thread priorities -- Thresholds for inflation and deflation -- Generic tuning -- Compressed references -- Large pages -- 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 -- 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 -- 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 -- 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 -- 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 -- 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 -- 11. JRCMD -- Introduction -- Overriding SIGQUIT -- Special commands.

Limitations of JRCMD.