enterprise professional expertise distilled

Transcription

1 Oracle JRockit The Definitive Guide Develop and manage robust Java applications with Oracle's high-performance Java Virtual Machine Marcus Hirt Marcus Lagergren PUBLISHING enterprise professional expertise distilled - BIRMINGHAM MUMBAI

2 Preface 1_ Chapter 1: Getting Started 11 Obtaining the JRockit JVM 11 Migrating to JRockit 13 Command-line options 13 System properties 13 Standardized options 14 Non-standard options 14 Changes in behavior 14 A note on JRockit versioning 15 Getting help 17 Summary 18 Chapter 2: Adaptive Code Generation 19 Platform independence 20 The Java Virtual Machine 21 Stack machine 21 Bytecode format 22 Operations and operands 23 The constant pool 24 Code generation strategies 24 Pure bytecode interpretation 24 Static compilation 26 Total JIT compilation 27 Mixed mode interpretation 28 Adaptive code generation 29 Determining "hotness" 30 Invocation counters 30 Software-based thread sampling 31 Hardware-based sampling 31

3 Optimizing a changing program 31 Inside the JIT compiler 34 Working with bytecode 34 Bytecode obfuscation 36 Bytecode "optimizers" 37 Abstract syntax trees 38 Where to optimize 41 The JRockit code pipeline 42 Why JRockit has no bytecode interpreter 43 Bootstrapping 44 Runtime code generation 44 Trampolines 45 Code generation requests 46 Optimization requests 47 On-stack replacement 47 Bookkeeping 48 A walkthrough of method generation in JRockit 49 The JRockit IR format 49 JIT compilation 51 Generating optimized code 58 Controlling code generation in JRockit 64 Command-line flags and directive files 64 Command-line flags 64 Directive files 67 Summary 70 Chapter 3: Adaptive Memory Management 7JL The concept of automatic memory management 72 Adaptive memory management 72 Advantages of automatic memory management 73 Disadvantages of automatic memory management 74 Fundamental heap management 74 Allocating and releasing objects 74 Fragmentation and compaction 75 Garbage collection algorithms 76 Reference counting 77 Tracing techniques 77 Mark and sweep 78 Stop and copy 80 Stopping the world 81 Conservative versus exact collectors 82 Livemaps 84 Generational garbage collection 87 Multi generation nurseries 88

4 Table ofcontents Write barriers 88 Throughput versus low latency 90 Optimizing for throughput 91 Optimizing for low latency 91 Garbage collection in JRockit 92 Old collections 93 Nursery collections 93 Permanent generations 94 Compaction 95 Speeding it up and making it scale 95 Thread local allocation 96 Larger heaps Bits and the 4-GB Barrier 97 The 64-bit world 98 Cache friendliness 100 Prefetching 101 Data placement 102 NUMA 102 Large pages 104 Adaptability 105 Near-real-time garbage collection 107 Hard and soft real-time 107 JRockit Real Time 108 Does the soft real-time approach work? 109 How does it work? 111 The Java memory API 112 Finalizers 112 References 113 Weak references 113 Soft references 114 Phantom references 114 Differences in JVM behavior 116 Pitfalls and false optimizations 116 Java is not C Controlling JRockit memory management 117 Basic switches 118 Outputting GC data 118 Set initial and maximum heap size 119 Controlling what to optimize for 119 Specifying a garbage collection strategy 120 Compressed references 120 Advanced switches 121 Summary 121

5 Chapter 4: Threads and Synchronization 123 Fundamental concepts 124 Hard to debug 126 Difficult to optimize 126 Latency analysis 127 Java API 129 The synchronized keyword 129 The java.lang.thread class 129 The java.util.concurrent package 130 Semaphores 131 The volatile keyword 133 Implementing threads and synchronization in Java 135 The Java Memory Model 135 Early problems and ambiguities 136 JSR Implementing synchronization 139 Primitives 139 Locks 141 The Java bytecode implementation 146 Lock pairing 148 Implementing threads 150 Green threads 150 OS threads 151 Optimizing threads and synchronization 152 Lock inflation and lock deflation 152 Recursive locking 153 Lock fusion 154 Lazy unlocking 155 Implementation 156 Object banning 157 Class banning 157 Results Pitfalls and false optimizations 159 Thread.stop, Thread.resume and Thread.suspend 159 Double checked locking 160 JRockit flags 162 Examining locks and lazy unlocking 162 Lock details from -Xverbose:locks 162 Controlling lazy unlocking with -XX:UseLazyUnlocking 163 Using SIGQUIT or Ctrl-Break for Stack Traces

6 Lock profiling 166 Enabling lock profiling with -XX:UseLockProfiling 166 Setting thread stack size using -Xss 168 Controlling lock heuristics 168 Summary 168 Chapter 5: Benchmarking and Tuning 171 Reasons for benchmarking 172 Performance goals 172 Performance regression testing 173 Easier problem domains to optimize 174 Commercial success 175 What to think of when creating a benchmark 175 Measuring outside the system 177 Measuring several times 179 Micro benchmarks 179 Micro benchmarks and on-stack replacement 181 Micro benchmarks and startup time 182 Give the benchmark a chance to warm-up 183 Deciding what to measure 183 Throughput 184 Throughput with response time and latency 184 Scalability 185 Power consumption 186 Other issues 187 Industry-standard benchmarks 187 The SPEC benchmarks 188 The SPECjvm suite 188 The SPECjAppServer / SPECjEnterprise2010 suite 189 The SPECjbb suite 190 SipStone 192 The DaCapo benchmarks 192 Real world applications 193 The dangers of benchmarking 193 Tuning 194 Out of the box behavior 194 What to tune for 196 Tuning memory management 196 Tuning code generation 202 Tuning locks and threads 204 Generic tuning 205

7 Common bottlenecks and how to avoid them 206 The-XXaggressive flag 207 Too many finalizers 207 Too many reference objects 207 Object pooling 208 Bad algorithms and data structures 209 Classic textbook issues 209 Unwanted intrinsic properties 210 Misuse of System.gc 211 Too many threads 211 One contended lock is the global bottleneck 212 Unnecessary exceptions 212 Large objects 214 Native memory versus heap memory 215 Wait/notify and fat locks 216 Wrong heap size 216 Too much live data 216 Java is not a silver bullet 217 Summary 218 Chapter 6: JRockit Mission Control 219 Background 220 Sampling-based profiling versus exact profiling 221 A different animal to different people 223 Mission Control overview 224 Mission Control server-side components 226 Mission Control client-side components 226 Terminology 228 Running the standalone version of Mission Control 230 Running JRockit Mission Control inside Eclipse 232 Starting JRockit for remote management 235 The JRockit Discovery Protocol 236 Running in a secure environment 241 Troubleshooting connections 243 Hostname resolution issues 245 The Experimental Update Site 246 Debugging JRockit Mission Control 247 Summary 249 Chapter 7: The Management Console 251 A JMX Management Console 252 Using the console 253 General 254

8 The Overview 254 MBeans 261 MBean Browser 262 Triggers 266 Runtime 271 System 272 Memory 273 Threads 275 Advanced 276 Method Profiler 277 Exception Count 280 Diagnostic Commands 281 Other 283 JConsole 283 Extending the JRockit Mission Control Console 284 Summary 292 Chapter 8: The Runtime Analyzer 293 The need for feedback 294 Recording 295 Analyzing JRA recordings 298 General 299 Overview 299 Recording 300 System 301 Memory 302 Overview 302 GCs 302 GC Statistics 306 Allocation 308 Heap Contents 309 Object Statistics 309 Code 310 Overview 310 Hot Methods 312 Optimizations 314 Thread/Locks 315 Overview 316 Threads 317 Java Locks 318 JVM Locks 320 Thread Dumps 320 Latency 321 Overview 322 Log 323 Graph 324

9 Threads 325 Traces 326 Histogram 327 Using the Operative Set 327 Troubleshooting 331 Summary 331 Chapter 9: The Flight Recorder 33j3 The evolved Runtime Analyzer 334 A word on events 334 The recording engine 335 Startup options 337 Starting time-limited recordings 339 Flight Recorder in JRockit Mission Control 340 Advanced Flight Recorder Wizard concepts 345 Differences to JRA 348 The range selector 349 The Operative Set 351 The relational key 351 What's in a Latency? 354 Exception profiling 357 Memory 359 Adding custom events 361 Extending the Flight Recorder client 366 Summary 377 Chapter 10: The Memory Leak Detector 379 A Java memory leak 379 Memory leaks in static languages 380 Memory leaks in garbage collected languages 380 Detecting a Java memory leak 381 Memleak technology 382 Tracking down the leak 383 A look at classloader-related information 392 Interactive memory leak hunting 394 The general purpose heap analyzer 397 Allocation traces 398 Troubleshooting Memleak 399 Summary 401

10 Chapter 11: JRCMD 403 Introduction 404 Overriding SIGQUIT 405 Special commands 407 Limitations of JRCMD 407 JRCMD command reference 408 check_flightrecording (R28) 408 checkjrarecording (R27) 409 commandjine 410 dump_flightrecording (R28) 410 heap_diagnostics (R28) 411 hprofdump (R28) 415 kill_management_server 416 list_vmflags (R28) 416 lockprofile_print 417 lockprofile_reset 418 memleakserver 418 oom_diagnostics (R27) 419 pri nt_cl ass_s umma ry 419 print_codegenjist 420 print_memusage (R27) 421 printjnemusage (R28) 422 print_object_summary 428 print_properties 431 prinmhreads 432 print_utf8pool 434 print_vm_state 434 run_optfile (R27) 435 run_optfile (R28) 436 runfinalization 436 runsystemgc 436 set_vmflag (R28) 437 startjlightrecording (R28) 437 start_management_server 438 startjrarecording (R27) 439 stop_flightrecording (R28) 440 timestamp 441 verbosity 441 version 443 Summary 443

11 Chapter 12: Using the JRockit Management APIs 445 JMAPI 445 JMAPI examples 447 JMXMAPI 450 The JRockit internal performance counters 452 An example building a remote version of JRCMD 455 Summary 460 Chapter 13: JRockit Virtual Edition 461 Introduction to visualization 462 Full virtualization 464 Paravirtualization 464 Other virtualization keywords 465 Hypervisors 465 Hosted hypervisors 465 Native hypervisors 466 Hypervisors in the market 466 Advantages of virtualization 467 Disadvantages of virtualization 468 Virtualizing Java 468 Introducing JRockit Virtual Edition 470 The JRockit VE kernel 472 The virtual machine image concept and management frameworks 474 Benefits of JRockit VE 481 Performance and better resource utilization 481 Manageability 484 Simplicity and security 484 Constraints and limitations of JRockit VE 486 A look ahead can virtual be faster than real? 486 Quality of hot code samples 486 Adaptive heap resizing 487 Inter-thread page protection 488 Improved garbage collection 488 Concurrent compaction 491 Summary 491 Appendix A: Bibliography 493 Appendix B: Glossary 503 Index 545