JVM Performance Engineering Inside OpenJDK and the HotSpot Java Virtual Machine (Monica Beckwith)（Z-Library） (1)

【One-Line Pitch】 A working engineer's tour of how the OpenJDK HotSpot VM actually behaves — from JIT tiering and GC choices to startup, virtual threads, and GPU/FPGA experiments — for Java developers who already ship code and now need to explain and fix its runtime behavior. 【Book Arc】 - **Opening (~0%–10%)**: Frames the book's scope and the author's vantage point (AMD, Sun, Microsoft), then sets up the JVM's dual identity — language evolution and execution engine — as the lens for everything that follows. - **Early (~10%–35%)**: Builds the runtime foundation: interpreter vs. JIT, `-XX:+PrintCompilation` output, tiered compilation T0–T4, inline caches and monomorphic→megamorphic call sites, deoptimization, and generational GC vocabulary. Also walks Java's version history (1.1 through 17) as a performance story rather than a feature list. - **Middle (~35%–55%)**: Turns to the type system as a performance surface — generics, lambdas, sealed and hidden classes, records, and how Project Valhalla aims to change memory layout. Excerpts here thin out, so treat this stage as conceptual framing. - **Late (~55%–80%)**: Moves into operational territory: GC selection (G1, ZGC), memory management trade-offs, the Unified JVM Logging interface with asynchronous logging, and the shift from thread-per-task to virtual threads for scalability. - **Ending (~80%–100%)**: Closes on time-to-steady-state — startup phases, class data sharing, AOT, GraalVM, Project Leyden — then exotic hardware: LWJGL, Aparapi, Project Sumatra, TornadoVM, and Project Panama's Vector and Foreign Function & Memory APIs. 【Key Takeaways】 - **Compilation is a ladder, not a switch** (Early): T0 interpretation through T4 server compilation, with profiling collected at client tiers — this is why warm-up behavior differs so much from steady state. - **Call-site shape drives dispatch cost** (Early): Monomorphic, bimorphic, and megamorphic sites are handled differently, and adding a new subtype can force deoptimization — a concrete reason to watch type profiles in hot paths. - **Language features are performance decisions** (Middle): Records, sealed and hidden classes, and eventually Valhalla's value types change object layout and hierarchy control, not just syntax. - **GC choice is a latency/throughput trade, not a default** (Late): G1 and ZGC are presented as different answers to pause-time and reclamation problems; string deduplication is one example of a targeted heap-size reduction. - **Logging is a first-class diagnostic surface** (Late): The Unified JVM Logging interface, including asynchronous logging, is positioned as the practical entry point for monitoring and performance testing. - **Startup and steady state are separate problems** (Ending): Class data sharing, AOT, GraalVM, and Leyden target time-to-readiness, which is distinct from peak throughput tuning. - **Virtual threads change the concurrency model** (Late): The progression from one-to-one thread mapping to thread-per-request to virtual threads reframes scalability limits for request-heavy services. - **Off-heap hardware is arriving** (Ending): Panama's Vector API and Foreign Function & Memory API, plus TornadoVM and HAT/Babylon on the horizon, signal where JVM performance work is heading. 【Reading Tips】 - Deep-read the early compilation and GC chapters — they are the vocabulary the rest of the book assumes; skim the Java version history if you lived through it. - Keep a JVM running alongside the `-XX:+PrintCompilation` and logging material; the book's value compounds when you match log lines to your own workload. - Treat the type-system middle as conceptual: excerpts are thin there, so follow the Valhalla thread rather than expecting implementation detail. - Read the startup and exotic-hardware chapters as a roadmap of where to invest next, not as recipes you can apply immediately. - Note the author's hardware background (NUMA, SPARC, Arm ports) — it explains why hardware/JVM interaction gets more weight than pure API tuning. 【Coverage Limits】 Excerpts concentrate on the preface, table of contents, and early chapters; the middle type-system and later GC/logging/virtual-thread chapters are represented mainly by headings and fragments, so specific tuning parameters and case-study results are not covered here.