Index
Symbols
- -Djava.util.concurrent.ForkJoinPool.common.parallelism= switch, Fork/Join
- -javaagent:jHiccup.jar Java command-line switch, jHiccup
- -Xloggc:gc.log switch, Switching On GC Logging
- -Xms<size> switch, Basic GC Tuning
- -Xmx<size> switch, Basic GC Tuning
- -XX:+CMSIncrementalMode switch, Incremental CMS (iCMS)
- -XX:+CompactStrings switch, Compact Strings
- -XX:+EnableJVMCI switch, Graal and Truffle
- -XX:+FlightRecorder switch, Flight Recorder and Mission Control
- -XX:+GCLogFileSize=<size> switch, Switching On GC Logging
- -XX:+LogCompilation switch, Logging JIT Compilation, Introducing JITWatch
- -XX:+NumberOfGCLogFiles=<n> switch, Switching On GC Logging
- -XX:+PreserveFramePointer switch, Modern Profilers
- -XX:+PrintAssembly switch, Debug JVMs and hsdis
- -XX:+PrintCompilation switch, Logging JIT Compilation
- -XX:+PrintFlagsFinal switch, Confirmation Bias
- -XX:+PrintGCApplicationStoppedTime switch, Safepoints Revisited, Sampling and Safepointing Bias
- -XX:+PrintGCDateStamps switch, Switching On GC Logging
- -XX:+PrintGCDetails switch, Switching On GC Logging
- -XX:+PrintGCTimeStamps switch, Switching On GC Logging
- -XX:+PrintSafepointStatistics switch, Safepoints Revisited
- -XX:+PrintTenuringDistribution switch, Switching On GC Logging
- -XX:+TraceClassLoading switch, Introducing JITWatch
- -XX:+UnlockCommercialFeatures switch, Flight Recorder and Mission Control
- -XX:+UnlockDiagnosticVMOptions switch, Confirmation Bias, Logging JIT Compilation, Introducing JITWatch
- -XX:+UnlockExperimentalVMOptions switch, Tuning G1, Graal and Truffle
- -XX:+UseCMSInitiatingOccupancyOnly switch, Tuning CMS
- -XX:+UseCompressedOops switch, Representing Objects at Runtime
- -XX:+UseConcMarkSweepGC switch, Basic JVM Flags for CMS
- -XX:+UseGCLogFileRotation switch, Switching On GC Logging
- -XX:+UseJVMCICompiler switch, Graal and Truffle
- -XX:+UseShenandoahGC switch, Obtaining Shenandoah
- -XX:-CompactStrings switch, Compact Strings
- -XX:-EliminateLocks switch, Locks and Escape Analysis
- -XX:-EliminateNestedLocks switch, Locks and Escape Analysis
- -XX:CMSInitiatingOccupancyFraction=<n> switch, Tuning CMS
- -XX:ConcGCThreads=<n> switch, Tuning CMS
- -XX:EliminateAllocationArraySizeLimit=<n> switch, Limitations of Escape Analysis
- -XX:FreqInlineSize switch, Tuning the Inlining Subsystem
- -XX:G1HeapRegionSize=<n> switch, Basic JVM Flags for G1
- -XX:G1MaxNewSizePercent=<y> switch, Tuning G1
- -XX:G1NewSizePercent=<n> switch, Tuning G1
- -XX:HugeMethodLimit=<n> switch, Upper Method Size Limit for Compilation
- -XX:InlineSmallCode=<n> switch, Tuning the Inlining Subsystem
- -XX:MaxGCPauseMillis=200 switch, Basic JVM Flags for G1
- -XX:MaxHeapFreeRatio switch, Tuning Parallel GC
- -XX:MaxInlineLevel switch, Tuning the Inlining Subsystem
- -XX:MaxInlineSize switch, Tuning the Inlining Subsystem
- -XX:MaxMetaspaceSize=<size> switch, Basic GC Tuning
- -XX:MaxNewSize=<n> switch, Tuning Parallel GC
- -XX:MaxPermSize=<size> switch, Basic GC Tuning
- -XX:MaxTenuringThreshold=<n> switch, Understanding Allocation
- -XX:MinHeapFreeRatio switch, Tuning Parallel GC
- -XX:MinTLABSize=<n> switch, Understanding Allocation
- -XX:NewRatio=<n> switch, Tuning Parallel GC
- -XX:NewSize=<n> switch, Tuning Parallel GC
- -XX:PretenureSizeThreshold=<n> switch, Understanding Allocation
- -XX:PrintFLSStatistics=1 switch, Concurrent Mode Failures Due to Fragmentation
- -XX:ReservedCodeCacheSize=<n> switch, The Code Cache
- -XX:SurvivorRatio=<n> switch, Tuning Parallel GC
- -XX:UseG1GC switch, Basic JVM Flags for G1
- 0xCAFEBABE magic number, Executing Bytecode
- @CompilerControl annotation, Executing Benchmarks
- @HotSpotIntrinsicCandidate annotation, Intrinsics, C2 Compiler Improvements
- @State annotation, Executing Benchmarks
A
- AbstractConcurrentArrayQueue (Agrona), Queues
- AbstractQueuedSynchronizer, Locks in java.util.concurrent
- access flags, Executing Bytecode
- actors, Actor-Based Techniques
- adaptive sizing, Tuning CMS
- admin manuals, source of bad performance advice, Discussion
- Aeron, Aeron-How it works under the hood
- AgeCache, Read/Write Locks
- agents, Monitoring and Tooling for the JVM, Introduction to Profiling
- Agrona library, Agrona
- ahead-of-time compilation (see AOT compilation)
- Akka framework, Fork/Join, Actor-Based Techniques
- alerting tools vs. monitoring tools and profilers, Introduction to Profiling
- allocation profiling (see memory allocation; profiling)
- allocation rate (see memory allocation rate)
- Amdahl's Law, Reading Performance Graphs, Introduction to Parallelism
- Android, Meet the JVMs
- annotations, use in JMH, The JMH Framework
- antipatterns, Introducing Performance Antipatterns
- (see also performance antipatterns)
- AOT (ahead-of-time) compilation, Introducing HotSpot, AOT Compilation
- Application classloader, Interpreting and Classloading
- arenas (memory), GC Roots and Arenas
- ArgEscape object allocation, Eliminating Heap Allocations, Limitations of Escape Analysis
- arithmetic bytecodes, Introduction to JVM Bytecode
- ArrayList, ArrayList, Lists, maps, and sets
- arrays
- as-if-serial instruction (JMM), Understanding the JMM
- ASM bytecode manipulation library, Allocation Profiling
- assembly language
- associative containers, Optimizing Collections
- Async Profiler, Modern Profilers
- AsyncGetCallTrace private API in HotSpot, Modern Profilers
- asynchronous execution, Introducing Asynchronous Execution
- AtomicInteger class, Atomics and CAS, VarHandles in Java 9
- atomics
- Attach API, using jHiccup via, jHiccup
- automatic resource management (ARM), Avoid Finalization
- Avian JVM, Meet the JVMs
- AWS (Amazon Web Services) EC t2.2xlarge instance, Measurements
- Azul Systems, Zing, C4 (Azul Zing)
- (see also C4 garbage collector)
B
- back branches in loops, On-Stack Replacement
- back-to-back collection, Tuning CMS
- Balanced (IBM J9) garbage collector, Balanced (IBM J9)-NUMA and Balanced
- barriers, Latches and Barriers
- big endian and little endian hardware architectures, Introduction to JVM Bytecode
- bimorphic dispatch, Monomorphic Dispatch
- binary encoding, Simple Binary Encoding
- (see also Simple Binary Encoding)
- binary semaphores vs. mutexes, Semaphores
- blackholes (in JMH), Executing Benchmarks
- Blame Donkey antipattern, Description
- blocks of code, synchronized, Understanding the JMM
- Bootstrap classloader, Interpreting and Classloading
- bootstrap method (BSM), Method Handles, New String Concatenation
- boredom (developers), Boredom
- boxing, excessive, Understanding Allocation
- branch prediction in modern processors, Branch Prediction and Speculative Execution
- breaking point, Throughput Test
- Brooks barrier, Shenandoah
- Brooks pointer, Shenandoah
- BSD Unix, Klass Words, Vtables, and Pointer Swizzling
- buffers, Buffers
- burst rate, writing to/reading from memory, Memory Caches
- ByteBuffer class, Buffers
- bytecode
- bytecode interpretation, Overview of Bytecode Interpretation-HotSpot-Specific Details
C
- C1 and C2 compilers (HotSpot), Compilers Within HotSpot
- C4 (Azul Zing) garbage collector, C4 (Azul Zing)-The Loaded Value Barrier
- cache consistency protocols, Memory Caches
- caching
- call site, Introduction to JVM Bytecode
- call target, Method Handles
- Callable interface, Introducing Asynchronous Execution
- capacity, Capacity
- capacity planning tests, Capacity Planning Test
- card tables, Weak Generational Hypothesis, Young Parallel Collections, G1 Algorithm Design
- CAS (see compare and swap technique)
- causation vs. correlation, Spurious correlation
- Censum memory analyzer, GC Logs Versus JMX, Censum
- Censum SaaS monitoring service, Censum
- Chaos Monkey, Degradation Test
- .class files
- class slots, J9 Object Headers
- class-data sharing (CDS), Java 10
- classes, klassOops and Class objects in HotSpot, Representing Objects at Runtime
- classloaders, Interpreting and Classloading
- classloading, Interpreting and Classloading
- ClassNotFoundException, Interpreting and Classloading
- cloud technologies
- CMS (concurrent mark-and-sweep) garbage collector, CMS-Basic JVM Flags for CMS
- coarse bytecodes, Introduction to JVM Bytecode
- code cache, The Code Cache, Simple JIT Tuning
- code execution on JVM, Code Execution on the JVM-Summary
- cognitive biases affecting performance testing, Cognitive Biases and Performance Testing-Ellsberg’s Paradox
- collections
- Collections.synchronizedList method, ArrayList versus LinkedList
- compact strings, Compact Strings
- compacting garbage collectors, Garbage Collection Glossary
- compare and swap (CAS) technique, Building Concurrency Libraries
- compilation
- compilers
- compressed oops, Representing Objects at Runtime
- compressed references, J9 Object Headers
- concurrency, future directions in, Future Directions in Concurrency
- concurrent, Garbage Collection Glossary
- concurrent garbage collection, Concurrent GC Theory-Tri-Color Marking
- concurrent mark and sweep (see CMS garbage collector)
- concurrent mode failure, How CMS Works, Understanding Pause Time
- concurrent performance techniques, Concurrent Performance Techniques-Summary
- concurrent tasks, Executors and Task Abstraction
- ConcurrentHashMap, Concurrent Collections
- ConcurrentModificationException, Concurrent Collections
- conductor, Publishers
- confirmation bias, Confirmation Bias
- conservative GC scheme, Garbage Collection Glossary
- const opcodes, Introduction to JVM Bytecode
- constant dynamic capability, Future Directions in Bytecode
- constant pool, Executing Bytecode
- constants
- context switches, Context Switches
- Continuously Concurrent Compacting Collector (see C4 garbage collector)
- copying, Copy-free and native type mapping
- CopyOnWriteArrayList, Concurrent Collections
- CopyOnWriteArraySet, Concurrent Collections
- correlation, spurious, in measurements, Spurious correlation
- counter, incrementing, Fundamental Java Concurrency-Fundamental Java Concurrency
- CPU clock speeds, increases in, Memory
- CPU utilization, Utilization, Basic Detection Strategies
D
- DataLite antipattern, Description
- debug JVMs, Debug JVMs and hsdis
- degradation
- degradation tests, Degradation Test
- deprecated and removed GC combinations, Deprecated and Removed GC Combinations
- Dijkstra, Edsger, Concurrent GC Theory, Fundamental Java Concurrency
- Disruptor pattern, Lock-Free Techniques, Low Latency Using Real Logic Libraries
- Distracted by Shiny (antipattern), Description
- Distracted by Simple (antipattern), Description
- distributions
- domain objects, Understanding Allocation, Domain Objects-Domain Objects
E
- Eden region (memory), Weak Generational Hypothesis
- efficiency, Efficiency
- Ellsberg's Paradox, Ellsberg’s Paradox
- embarrassingly parallel workloads, Introduction to Parallelism
- emergent behavior of complex systems, Reductionist Thinking
- endianness, Introduction to JVM Bytecode
- endurance tests, Endurance Test
- Epsilon garbage collector, Epsilon
- equals method, Optimizing Collections
- error margin in benchmarkng code, Introduction to Measuring Java Performance
- errors in performance analysis, Types of Error
- escape analysis, Escape Analysis-Limitations of Escape Analysis
- evacuating collectors, Garbage Collection Glossary, Garbage Collection in HotSpot
- evaluation stack, Overview of Bytecode Interpretation
- exact GC scheme, Garbage Collection Glossary
- exception handling in thread lifetime, Introducing Asynchronous Execution
- Exclusive state (caches), Memory Caches
- execution profiling, Profiling
- executors and task abstraction, Executors and Task Abstraction-Fork/Join
- Executors class, new* factory methods, Introducing Asynchronous Execution
- ExecutorService, Introducing Asynchronous Execution
- explicit method call opcodes, Introduction to JVM Bytecode
- Extension classloader, Interpreting and Classloading
F
- Fiddle with Switches antipattern, Confirmation Bias, Representing Objects at Runtime
- final methods changed to be nonfinal, invocation by HotSpot interpreter, HotSpot-Specific Details
- finalization, avoiding, Avoid Finalization-try-with-resources
- finalize method, Why Not Use Finalization to Solve the Problem?
- FinalReference class, Why Not Use Finalization to Solve the Problem?
- fine-grained bytecodes, Introduction to JVM Bytecode
- fixed-width values for Java types, Project Valhalla and Value Types
- Flichel, Carey (blog post), Introducing Performance Antipatterns
- Flight Recorder and Mission Control (JFR/JMC) tools, Flight Recorder and Mission Control
- floating garbage, G1 Algorithm Design
- flow control opcodes, Introduction to JVM Bytecode
- flow-sensitive escape analysis, Limitations of Escape Analysis
- fog of war (action bias), Fog of War (Action Bias)
- Fork/Join framework, Fork/Join, Future Directions in Concurrency
- ForkJoinPool class, Fork/Join, Streams and Parallel Streams, Future Directions in Concurrency
- ForkJoinTask class, Fork/Join
- Futamuru projection, Graal and Truffle
G
- G1 (Garbage First) collector, G1-Basic JVM Flags for G1, Understanding Pause Time
- garbage collection (GC), JVM Memory Management, Understanding Garbage Collection-Summary, Advanced Garbage Collection-Summary
- allocation rate and object lifetime, Allocation and Lifetime-Weak Generational Hypothesis
- avoiding in Aeron, Latency and application principles
- avoiding in low-latency applications, Simple Binary Encoding
- Balanced (IBM J9) collector, Balanced (IBM J9)-NUMA and Balanced
- basic tuning, Basic GC Tuning-Collector Threads and GC Roots
- C4 (Azul Zing) collector, C4 (Azul Zing)-The Loaded Value Barrier
- CMS collector, CMS-Basic JVM Flags for CMS
- code cache fragmentation and, Fragmentation
- concurrent GC theory, Concurrent GC Theory-Tri-Color Marking
- effects of, timing code and, Introduction to Measuring Java Performance
- finalizable objects, Why Not Use Finalization to Solve the Problem?
- finalize method and, Why Not Use Finalization to Solve the Problem?
- fundamental rules, Understanding Garbage Collection
- G1 collector, G1-Basic JVM Flags for G1
- glossary of terms, Garbage Collection Glossary
- in HotSpot, Garbage Collection in HotSpot-Hemispheric Collection
- in performance analysis for Java app on Unix, Garbage Collection
- legacy HotSpot collectors, Legacy HotSpot Collectors-Epsilon
- log parsing tools, Log Parsing Tools-Different Visualizations of the Same Data
- logging, GC Logging, Monitoring, Tuning, and Tools-Benefits of GC Log Data
- mark-and-sweep algorithm, Introducing Mark and Sweep
- parallel collectors, tuning, Tuning Parallel GC
- profiling for loggers, Designing a Lower-Impact Logger
- role of memory allocation, The Role of Allocation-The Role of Allocation
- Shenandoah collector, Shenandoah-Obtaining Shenandoah
- stop-the-world (STW) pauses, Introduction to Profiling
- tradeoffs and pluggable collectors, Tradeoffs and Pluggable Collectors-Tradeoffs and Pluggable Collectors
- garbage collectors
- Gaussian distribution, Non-Normal Statistics
- GC roots, GC Roots and Arenas, Young Parallel Collections
- GCViewer, GCViewer
- generational regions, Balanced (IBM J9)
- generics, Project Valhalla and Value Types
- GetCallTrace function, Sampling and Safepointing Bias
- global garbage collection (Balanced GC), Balanced (IBM J9)
- global mark phase (Balanced GC), Balanced (IBM J9)
- Graal and Truffle, Graal and Truffle-Graal and Truffle
- guards (speculative optimization), Introducing JIT Compilation
H
- hand over hand compaction, The Loaded Value Barrier
- happens-before ordering (JMM), Understanding the JMM
- hardware, Hardware and Operating Systems-Hardware Memory Models
- hashCode method, Optimizing Collections
- HashMap, HashMap-LinkedHashMap
- HashSet, Optimization Considerations for Sets
- Hat/Elephant problem, Interpretation of Statistics, Interpretation of Statistics
- HdrHistogram library, Non-Normal Statistics
- heap
- controlling size of, Introduction to Measuring Java Performance
- description in terms of old and young areas, Weak Generational Hypothesis
- fragmentation, causing concurrent mode failure, How CMS Works, Concurrent Mode Failures Due to Fragmentation
- G1 layout and regions, G1 Heap Layout and Regions
- GC heap sizing flags, Basic GC Tuning
- layout for Shenandoah collector, Shenandoah
- leaking domain objects and, Domain Objects
- number of bytes allocated per type and number of instances, Introducing Mark and Sweep
- survivor ratio, new ratio, and heap size in parallel collectors, Tuning Parallel GC
- heap dump analysis, Heap Dump Analysis-hprof
- hemispheric collection in HotSpot, Hemispheric Collection
- Hibernate, Description
- high dynamic range distributions, Non-Normal Statistics
- high-performance logging and messaging, High-Performance Logging and Messaging-Summary
- histograms, Non-Normal Statistics
- (see also HdrHistogram library)
- Honest Profiler, Modern Profilers
- HotSpot JVM, Java Performance Overview, Introducing HotSpot
- AOT compilation, Comparing AOT and JIT Compilation
- bytecode interpretation, HotSpot-Specific Details
- garbage collection in, Garbage Collection in HotSpot-Hemispheric Collection
- JIT compilation, Introducing Just-in-Time Compilation, JIT Compilation, HotSpot JIT Basics-Tiered Compilation in HotSpot
- compiler optimization techniques, Introducing JIT Compilation
- compilers within HotSpot, Compilers Within HotSpot
- klass words, vtables, and pointer swizzling, Klass Words, Vtables, and Pointer Swizzling
- logging, Logging JIT Compilation
- loop unrolling optimizations, Loop Unrolling Summary
- tiered compilation, Tiered Compilation in HotSpot
- mechanisms taking advantage of weak generational hypothesis, Weak Generational Hypothesis
- runtime, Introducing the HotSpot Runtime-GC Roots and Arenas
- SIMD instructions support, C2 Compiler Improvements
- hprof profiler, hprof
- hsdis, Debug JVMs and hsdis
I
- I/O
- IBM J9 JVM, Balanced (IBM J9)
- (see also Balanced garbage collector)
- IcedTea, Meet the JVMs
- if opcode family, Introduction to JVM Bytecode
- Illuminate (jClarity), jClarity Illuminate
- incremental CMS (iCMS) garbage collector, Incremental CMS (iCMS)
- inflection point, Throughput Test
- inlining, Inlining
- instance method calls, Introduction to JVM Bytecode
- instanceOops, Representing Objects at Runtime
- Integer type, Integer class vs. AtomicInteger, Atomics and CAS
- interpreters, Interpreting and Classloading, Simple Interpreters
- intrinsic locks, Locks and Escape Analysis
- intrinsics, Introducing Just-in-Time Compilation, Intrinsics-Intrinsics, C2 Compiler Improvements
- Invalid state (caches), Memory Caches
- invocation count, Compilers Within HotSpot
- invoke method, Method Handles
- invokedynamic opcode, Introduction to JVM Bytecode, Method Handles, New String Concatenation, Future Directions in Bytecode
- invokeinterface opcode, Introduction to JVM Bytecode
- invokespecial opcode, Introduction to JVM Bytecode
- invokevirtual opcode, Introduction to JVM Bytecode, Monomorphic Dispatch
- iostat utility, Utilizing the CPU
- iterators and snaphot stye of iteration, Concurrent Collections
J
- J9 JVM, Meet the JVMs, Balanced (IBM J9)
- (see also Balanced garbage collector)
- JarScan tool, Upper Method Size Limit for Inlining, Upper Method Size Limit for Compilation
- Java
- Java 10, Java 10-Java 10
- Java agents (see agents)
- Java Concurrency in Practice (Goetz et al.), Concurrent Performance Techniques
- Java Enhancement Process (JEP), Java 10
- Java Management Extensions (see JMX)
- Java Memory Model (JMM), Threading and the Java Memory Model, Introduction to Parallelism, Understanding the JMM-Understanding the JMM
- Java Native Interface (JNI), The JVM and the Operating System
- Java Virtual Machines (see JVMs)
- Java-in-Java approach, JIT compiler, Graal and Truffle
- java.lang.Collections, Java Language Performance Techniques
- java.lang.instrument interfaces, Monitoring and Tooling for the JVM
- java.lang.invoke.MethodHandle, Method Handles
- java.lang.ref.Finalizer class, Why Not Use Finalization to Solve the Problem?
- java.util.concurrent, Building Concurrency Libraries
- java.util.logging format, java.util.logging format
- java.util.Queue interface, Queues
- javac, Executing Bytecode
- javap (class file disassembler), Executing Bytecode
- jClarity Censum, GC Logs Versus JMX, Censum
- jClarity Illuminate, jClarity Illuminate
- JCTools, Ring buffers
- jdk.unsupported modulle, Unsafe
- JEP (Java Enhancement Process), Java 10
- JFR/JMC (Flight Recorder and Mission Control) tools, Flight Recorder and Mission Control
- jHiccup, jHiccup-jHiccup
- JIT (Just-in-Time) compilation, Introducing Just-in-Time Compilation, Code Execution on the JVM, JIT Compilation, Understanding JIT Compilation-Summary
- basic tuning, Simple JIT Tuning
- comparing to AOT compilation, Comparing AOT and JIT Compilation
- escape analysis, Escape Analysis-Limitations of Escape Analysis
- Graal compiler for JVM written in Java, Graal and Truffle
- HotSpot JIT basics, HotSpot JIT Basics-Tiered Compilation in HotSpot
- impacts on core library methods, Core Library Methods-Upper Method Size Limit for Compilation
- inlining, Inlining
- intrinsics, Intrinsics-Intrinsics
- introduction to, Introducing JIT Compilation
- loop unrolling, Loop Unrolling-Loop Unrolling Summary
- monomorphic dispatch, Monomorphic Dispatch-Monomorphic Dispatch
- on-stack replacement (OSR), On-Stack Replacement-Safepoints Revisited
- performance testing and, Java-Specific Issues
- safepoints, Safepoints Revisited
- safepoints, polling for, JVM Safepoints
- JITWatch, Introducing JITWatch-Debug JVMs and hsdis
- jmap -histo command-line tool, Introducing Mark and Sweep, Domain Objects
- JMH framework, The JMH Framework-Executing Benchmarks
- JMM (see Java Memory Model)
- JMX (Java Management Extensions), Monitoring and Tooling for the JVM
- JNI (Java Native Interface), The JVM and the Operating System
- joatc tool, creating binaries from Java class files, Graal and Truffle
- JProfiler, JProfiler
- JRockit JVM, Flight Recorder and Mission Control
- JRuby, Introduction to JVM Bytecode, Graal and Truffle
- jsr and ret bytecodes (deprecated), Introduction to JVM Bytecode
- jstatd, VisualVM
- Just-in-Time compilation (see JIT compilation)
- JVM Compiler Interface (JVMCI), Graal and Truffle
- JVM intrinsics (see intrinsics)
- JVM Tooling Interface (JVMTI), Monitoring and Tooling for the JVM
- JVMs (Java Virtual Machines)
- benefits of multicore processors, Concurrent Performance Techniques
- code execution on, Code Execution on the JVM-Summary
- command-line options, fiddling with, Confirmation Bias
- deprecated and removed GC combination flags, Deprecated and Removed GC Combinations
- effect on microbenchmarking code, Introduction to Measuring Java Performance
- execution speed of code and, Java Performance—The Wrong Way
- GC logging and user space utilization, Garbage Collection
- hiccups in running, showing with jHiccup, jHiccup-jHiccup
- high-performance nature of, Performance as an Experimental Science
- improvements proposed in Java 10, Java 10
- JIT compilation, performance testing and, Java-Specific Issues
- mechanical sympathy and, Mechanical Sympathy
- operating system and, The JVM and the Operating System
- overview, Overview of the JVM-Summary
- performance tuning, experimental nature of, Performance as an Experimental Science
- safepoints, JVM Safepoints
- warmup before timing code, Introduction to Measuring Java Performance
- JVMTI technology, hprof
- Jython, Graal and Truffle
L
- lambdas, Streams and Parallel Streams
- latches, JVM Safepoints, Latches and Barriers
- latency
- latency tests, Latency Test
- ldc opcodes, Introduction to JVM Bytecode
- length word (HotSpot object headers), Representing Objects at Runtime
- licenses for JVMs, A Note on Licenses
- linear scaling, Reading Performance Graphs
- LinkedHashMap, LinkedHashMap
- LinkedList, LinkedList
- Linux
- Liskov Substitution Principle, HotSpot-Specific Details, Monomorphic Dispatch
- lists
- live object graph, Introducing Mark and Sweep
- load tests, Load Test
- loaded value barrier (LVB) in C4 collector, The Loaded Value Barrier
- local variables, Overview of Bytecode Interpretation, Introduction to JVM Bytecode
- local-variable type inference, Java 10
- lock coarsening optimization, Locks and Escape Analysis
- lock elision optimization, Locks and Escape Analysis
- locks, Threading and the Java Memory Model
- and spinlocks, Locks and Spinlocks
- implementation of compare and swap (CAS), Building Concurrency Libraries
- in java.util.concurrent, Locks in java.util.concurrent
- in Zing object headers, C4 (Azul Zing)
- lock-free techniques, Lock-Free Techniques
- locking via synchronization, Understanding the JMM
- optimizing performance with escape analysis, Locks and Escape Analysis
- read-write, Read/Write Locks
- release-before-acquire, Understanding the JMM
- synchronized, limitations of, Understanding the JMM
- using Akka instead of traditional locking schemes, Actor-Based Techniques
- LockSupport class, Locks in java.util.concurrent
- Log4j, Log4j format
- logarithmic percentiles, Non-Normal Statistics
- Logback, Logback format
- logging, Logging-Designing a Lower-Impact Logger
- designing a lower-impact logger, Designing a Lower-Impact Logger-Designing a Lower-Impact Logger
- garbage collection, GC Logging, Monitoring, Tuning, and Tools-Benefits of GC Log Data, Introduction to Profiling
- JIT compilation on HotSpot, Logging JIT Compilation
- logfile at the heart of Aeron, How it works under the hood
- microbenchmarks, Logging Microbenchmarks-Logger results
- selecting a production-grade system, antipatterns surrounding, Logging
- London Multi Asset Exchange (LMAX), Lock-Free Techniques
- lone genius hacker stereotype, Description
- long-tail distributions
- Long-Term Support (LTS) releases, New Release Process
- loop counter variables, comparing types, Loop Unrolling
- loop unrolling, Loop Unrolling-Loop Unrolling Summary, Sampling and Safepointing Bias
- loops
M
- macOS, A Question of Time, Obtaining Shenandoah
- magic numbers, Executing Bytecode
- “magic” configuration parameters, Description
- managed subsystems, Java Performance Overview
- maps
- mark word oops, Representing Objects at Runtime
- mark-and-sweep GC algorithm, Introducing Mark and Sweep-Garbage Collection Glossary
- mechanical sympathy, Hardware Memory Models, Lock-Free Techniques
- media, Publishers
- media driver, Publishers
- megamorphic call sites, Monomorphic Dispatch
- memory, Memory-Memory Caches, Basic Detection Strategies
- access control in operating systems, Operating Systems
- access to, in SBE, Streaming access and word-aligned access
- avoiding false sharing in queue accessed by producer and consumer concurrently, Queues
- caches, Memory Caches
- hardware memory models, Hardware Memory Models
- HotSpot GC roots and arenas, GC Roots and Arenas
- Java Memory Model (JMM), Understanding the JMM-Understanding the JMM
- layout, simple view of, Introducing Mark and Sweep
- low-level access to memory modes in JDK 9, VarHandles in Java 9
- NUMA and Balanced garbage collector, NUMA and Balanced
- threading and Java memory model, Threading and the Java Memory Model
- virtual and physical addresses in TLB, Translation Lookaside Buffer
- memory allocation
- memory allocation rate, Allocation and Lifetime
- memory leaks, diagnosing in domain objects, Domain Objects
- memory management, Java Performance Overview
- memory management unit (MMU), Operating Systems
- MESI protocol, Memory Caches
- messaging systems, High-Performance Logging and Messaging
- (see also high-performance logging and messaging)
- method handles, Method Handles-Method Handles, VarHandles in Java 9
- method invocation opcodes, Introduction to JVM Bytecode
- MethodData objects (MDOs), Introducing JIT Compilation
- methods
- Metropolis/Graal technology, Graal and Truffle
- microbenchmarking, Microbenchmarking and Statistics-Summary
- microbenchmarks, Introducing Just-in-Time Compilation
- missing messages, handling in Aeron, How it works under the hood
- missing the bigger picture, Description
- misunderstood/nonexistent problems, Misunderstood/Nonexistent Problem
- Modified state (caches), Memory Caches
- modules in Java 9, Java 9 and the Future
- Monitor tab (VisualVM), VisualVM
- monitoring tools vs. alerting tools and profilers, Introduction to Profiling
- monomorphic dispatch, Monomorphic Dispatch-Monomorphic Dispatch
- Moore's law, Hardware and Operating Systems, Concurrent Performance Techniques
- moving collectors, Garbage Collection Glossary
- multicore processors, Concurrent Performance Techniques
- MultiMap implementation, lack of, Lack of MultiMap
- multithreading, Threading and the Java Memory Model
- mutexes vs. binary semaphores, Semaphores
N
- Nashorn, Introduction to JVM Bytecode, Graal and Truffle
- native methods, The JVM and the Operating System
- native type mapping, Copy-free and native type mapping
- nested lock optimization, Locks and Escape Analysis
- New Relic Thread Profiler, Sampling and Safepointing Bias
- New Relic toolset, New Relic
- NoEscape object allocation, Eliminating Heap Allocations
- non-normal statistics, Non-Normal Statistics
- non-uniform memory access (NUMA), Balanced (IBM J9) garbage collector and, NUMA and Balanced
O
- object allocation rates, Memory Caches
- object heap, Overview of Bytecode Interpretation
- Object Pool pattern, Designing a Lower-Impact Logger
- object references, Introducing the HotSpot Runtime
- ObjectLayout website, Optimizing Collections, Streaming access and word-aligned access
- objects
- Ocelot interpreter, Simple Interpreters
- offsets (variable), Executing Bytecode
- on-stack replacement (OSR), HotSpot JIT Basics, On-Stack Replacement-Safepoints Revisited
- opcodes, Introduction to JVM Bytecode
- OpenJDK, Meet the JVMs
- operating systems, Operating Systems-Context Switches
- context switches, Context Switches
- Java support for, Klass Words, Vtables, and Pointer Swizzling
- JVM and, The JVM and the Operating System
- less reliance on in concurrency libraries, Building Concurrency Libraries
- performance problem analysis for Java app on Unix or Unix-like system, A Simple System Model-Mechanical Sympathy
- process scheduler, The Scheduler, Fundamental Java Concurrency
- timing calls from Java, A Question of Time
- virtualization of, Virtualization
- operational monitoring tools, Operational Tools
- Oracle Java, Meet the JVMs
- Oracle/Open JDK
- ordinary object pointers (oops), Representing Objects at Runtime
- org.agrona.concurrent.AbstractConcurrentArrayQueue, Queues
- org.agrona.concurrent.Pipe interface, Queues
- org.agrona.concurrent.RingBuffer, Ring buffers
- OSI layer 4 transport for messaging, Transport requirements
- Overview tab (VisualVM), VisualVM
P
- parallel garbage collection, Garbage Collection Glossary
- Parallel GC collector, The Parallel Collectors, Old Parallel Collections
- parallel streams, Streams and Parallel Streams
- parallelism, Introduction to Parallelism-Fundamental Java Concurrency
- ParallelOld collector, The Parallel Collectors, Old Parallel Collections
- park method, Locks in java.util.concurrent
- ParNew collector, The Parallel Collectors, CMS
- partial escape analysis, Limitations of Escape Analysis, Graal and Truffle
- partial failure tests, Degradation Test
- partial garbage collection (PGC), Balanced (IBM J9)
- partial specialization, Graal and Truffle
- pause goals (G1), Basic JVM Flags for G1
- pause times, Tradeoffs and Pluggable Collectors, Concurrent GC Theory
- PayPal blog on statistics and analysis, Interpretation of Statistics
- peer pressure among developers, Peer Pressure
- percentiles scheme, using with non-normal statistics, Non-Normal Statistics
- perf profiler, Modern Profilers
- performance, Optimization and Performance Defined-Summary
- analyzing for Java applicaton on Unix or Unix-like system, A Simple System Model-Mechanical Sympathy
- as experimental science, Performance as an Experimental Science
- C++ vs. Java positions on, High-Performance Logging and Messaging
- checking if GC causes issues, Basic GC Tuning
- connections between observables, Connections Between the Observables
- enhancements in Java 9, Small Performance Enhancements in Java 9-New Version of G1
- misconceptions about Java performance, Java Performance—The Wrong Way
- overview of Java performance, Java Performance Overview
- reading performance graphs, Reading Performance Graphs
- taxonomy for, A Taxonomy for Performance-Connections Between the Observables
- understanding the JVM, Overview of the JVM-Summary
- performance antipatterns, Introducing Performance Antipatterns-Resolutions
- performance elbow, Reading Performance Graphs
- performance metrics
- performance nonfunctional requirements, Identifying Performance Requirements
- performance optimizations, Optimization and Performance Defined
- performance testing, Performance Testing Patterns and Antipatterns-Summary
- best practices, Best Practices Primer-Performance Testing as Part of the SDLC
- capacity planning tests, Capacity Planning Test
- cognitive biases affecting, Cognitive Biases and Performance Testing-Ellsberg’s Paradox
- degradation tests, Degradation Test
- endurance tests, Endurance Test
- Epsilon garbage collector for, Epsilon
- latency tests, Latency Test
- load tests, Load Test
- stress tests, Stress Test
- throughput tests, Throughput Test
- types of tests, Types of Performance Test
- performance tips, Reality
- permits
- Pipe interface (Agrona), Queues
- platform opcodes, Introduction to JVM Bytecode
- pluggable garbage collectors, Tradeoffs and Pluggable Collectors-Tradeoffs and Pluggable Collectors
- pointer swizzling, Klass Words, Vtables, and Pointer Swizzling
- premature promotion, The Role of Allocation, Understanding Allocation
- pretenuring of large objects, Understanding Allocation
- primitive types, Introducing the HotSpot Runtime
- process scheduler, The Scheduler
- processor capabilities, detection by JVM, Introducing Just-in-Time Compilation
- production-like data, obtaining for tests, Description
- profile-guided optimization (PGO), JIT Compilation, Introducing JIT Compilation
- Profiler tab (VisualVM), VisualVM
- profiling, Profiling-Summary
- programming languages, HotSpot and, Introducing HotSpot
- Project Metropolis, Graal and Truffle
- Project Valhalla and value types, Project Valhalla and Value Types-Project Valhalla and Value Types
- publishers, Publishers
R
- random error, Types of Error, Random error
- ReadLock, Read/Write Locks
- Real Logic, Low Latency Using Real Logic Libraries
- receiver (Aeron), Publishers
- receiver object or receiver type, Introduction to JVM Bytecode, Monomorphic Dispatch
- recency bias, Cognitive Biases and Performance Testing
- Red Hat Thermostat, Red Hat Thermostat
- reductionist thinking, Reductionist Thinking
- ReentrantLock, Locks in java.util.concurrent
- ReentrantReadWriteLock, Read/Write Locks
- reference types, Project Valhalla and Value Types
- ReferencePipeline, Streams and Parallel Streams
- reflection
- regions JavaFX application, Tuning G1
- release process (new) for Java, New Release Process
- Remembered Sets (RSets) in G1, G1 Algorithm Design, Collector Threads and GC Roots
- resilience tests, Degradation Test
- (see also degradation tests)
- Resource Acquisition Is Initialization (RAII) pattern in C++, Avoid Finalization
- resource creation, try-with-resources, try-with-resources
- resource leaks, Reading Performance Graphs
- resource management, finalization and, Why Not Use Finalization to Solve the Problem?
- résumé padding (developers), Résumé Padding
- ret bytecode (deprecated), Introduction to JVM Bytecode
- ring buffers, Ring buffers
- risk bias, Risk Bias
- RMI-based communication channels, issues with, Drawbacks of JMX
- Runnable interface, Introducing Asynchronous Execution
- runtime-managed concurrency, Future Directions in Concurrency
- Runtime.getRuntime().availableProcessors()—1, Fork/Join
S
- safepoints
- safepoints (application threads), JVM Safepoints
- Sampler tab (VisualVM), VisualVM
- sampling data
- SATB (snapshot at the beginning), Tri-Color Marking
- scalability
- scheduler (process), The Scheduler
- SDLC (software development life cycle), performance testing in, Performance Testing as Part of the SDLC
- semaphores, Semaphores
- sender (Aeron), Publishers
- sequential containers, Optimizing Collections
- Serial and SerialOld garbage collectors, Serial and SerialOld
- Serviceability Agent (SA), Monitoring and Tooling for the JVM
- sets
- Shannon's Strict Avalanche Criteria, HashMap
- Shared state (caches), Memory Caches
- Shenandoah garbage collector, Shenandoah-Obtaining Shenandoah
- signature polymorphism, Method Handles
- Simple Binary Encoding (SBE), Simple Binary Encoding-Working with SBE
- simplest parts of a system, targeting, Description
- Single Instruction-Multiple Data (SIMD) extensions, C2 Compiler Improvements
- single static assignment, Compilers Within HotSpot
- snapshot at the beginning (SATB), Tri-Color Marking
- software development life cycle (SDLC), performance testing in, Performance Testing as Part of the SDLC
- speculative execution in modern CPUs, Branch Prediction and Speculative Execution
- speculative optimization, Introducing JIT Compilation
- spinlocks, Locks and Spinlocks, Lock-Free Techniques
- Spliterator, Streams and Parallel Streams
- Stack class, Optimization Considerations for Lists
- stack samples, collecting for application threads, Sampling and Safepointing Bias
- stack-based interpreted machine (JVM), Interpreting and Classloading
- state
- statistics
- stop-the-world (STW) pauses, Garbage Collection Glossary
- streams, Streams and Parallel Streams
- stress tests, Stress Test
- StringConcatFactory, New String Concatenation
- strings
- strong memory model, Understanding the JMM
- SubstrateVM research project, Graal and Truffle
- sun.misc.Unsafe class, Building Concurrency Libraries
- superhero types in development teams, Description
- survivor spaces, Hemispheric Collection
- Sync class, Locks in java.util.concurrent
- synchronization
- synchronized keyword, Understanding the JMM
- system calls, cost of, Context Switches
- system time, setting, The JVM and the Operating System
- systematic error, Types of Error
T
- task abstraction, executors and, Executors and Task Abstraction-Fork/Join
- Tenured generation, Weak Generational Hypothesis
- test environment, creating, Creating a Test Environment
- testing, Performance Testing Patterns and Antipatterns
- (see also performance testing)
- Epsilon garbage collector for, Epsilon
- Thermostat (Red Hat), Red Hat Thermostat
- Thompson, Martin, Lock-Free Techniques, Low Latency Using Real Logic Libraries
- “thread hot” performance, Executors and Task Abstraction
- thread-local allocation, Thread-Local Allocation, Understanding Allocation
- thread-local allocation buffers (TLABs), Thread-Local Allocation, Understanding Allocation
- Thread.suspend and Thread.resume methods, replacements for, Locks in java.util.concurrent
- ThreadFactory, Selecting an ExecutorService
- threading
- threads
- Threads tab (VisualVM), VisualVM
- throughput
- tiered compilation, Tiered Compilation in HotSpot
- TLBs (see translation lookaside buffers)
- top-down performance, Top-Down Performance
- transitive closure of reachable objects, Introducing Mark and Sweep
- translation lookaside buffers (TLBs), Translation Lookaside Buffer, Operating Systems
- TreeMap, TreeMap
- TreeSet, Optimization Considerations for Sets
- tri-color marking algorithm, Tri-Color Marking
- Truffle, Graal and Truffle
- try-with-resources, try-with-resources-try-with-resources
- Tuning by Folklore antipattern, Description
- type erasure, Project Valhalla and Value Types
- type system (Java), not single-rooted, Project Valhalla and Value Types
V
- value types, Optimizing Collections
- VarHandles in Java 9, VarHandles in Java 9
- variable-width types, Project Valhalla and Value Types
- variables
- Vector class (deprecated), Optimization Considerations for Lists
- virtual addressing of memory, in memory management unit (MMU), Operating Systems
- Virtual Dynamically Shared Objects (vDSO), Context Switches
- virtualization, Virtualization
- VisualGC plug-in for VisualVM, Introducing Mark and Sweep
- VisualVM, VisualVM, Domain Objects, VisualVM Profiler
- VMSpec, Code Execution on the JVM
- vmstat utility, Utilizing the CPU
- volatile keyword, Fundamental Java Concurrency
- vtables, Klass Words, Vtables, and Pointer Swizzling
W
- Wadler's Law, Java 10
- walls (in performance), Executing Benchmarks
- weak generational hypothesis, Weak Generational Hypothesis
- weak memory model, Understanding the JMM
- “Why Developers Keep Making Bad Technology Choices”, Introducing Performance Antipatterns
- Windows systems
- work-stealing algorithm, Fork/Join framework, Fork/Join
- write barrier, Tri-Color Marking
- write walls, protecting against in benchmarking, Executing Benchmarks
- write-back behavior, Memory Caches
- write-through behavior, Memory Caches
- WriteLock, Read/Write Locks
Optimizing Java
Published by
O'Reilly Media, Inc., 2018