Use JVM Flags to Print JIT Compilation Logs

Topic Overview

PrintCompilation Logs

\`-XX:+PrintCompilation\` prints one line each time HotSpot compiles a method. Reading that log connects bytecode behavior to real JIT decisions.

Log Format

Typical fields:

• Timestamp since JVM start
• Compile ID
• Tier marker (e.g., \`%\` for C1, \`@\` for C2)
• Method name and bytecode size
• Compile level

A line like \`1234 4% 3 com.example.Hot::loop (50 bytes)\` means compile ID 4, C1 compile, level 3, for method \`loop\` of 50 bytecode bytes.

Pair with \`-XX:CompileThreshold\` to see how invocation counts influence promotion. Profiling builds on the same counters.

For example, run a tight loop one million times, watch \`PrintCompilation\` fire, then compare wall time before and after the compile line appears.

Design Notes

Correlate compile log timestamps with wall-clock improvements on the same method. A C2 compile that inlines a callee can remove more dispatch than the root method's bytecode size suggests.

For This Exercise

This exercise asks you to document JVM flags and sample \`PrintCompilation\` output. You will explain how to read compile tiers from log lines and tie them to the tiered compilation model.

You will use the same mental model here when reading production interpreter source later in the track. Sketch one concrete input on paper, predict the outcome, then confirm with code. That discipline catches logic errors early and makes debugging far faster when you extend the implementation in follow-on tasks.

Your Task

Write an analyzer for HotSpot's -XX:+PrintCompilation log. Parse each line's timestamp, compile id, attribute flags, tier, method, OSR bci, size and status. Match the made not entrant and made zombie lines back to the compile they invalidate. Then report what happened to every method: its tier path, the code currently running, OSR compiles, invalidations and skipped compiles.

Input: log lines

cCopy
Loading…

• FLAGS: any of % (OSR), s (synchronized), ! (has exception handlers), b (blocking) and n (native wrapper), each followed by spaces. A flag character counts only when it is followed by a space or another flag.
• TIER: a single digit 0-4 followed by a space.
• METHOD: one token containing ::.
• SUFFIX:
  • made not entrant / made zombie invalidates the latest earlier compile with the same id and OSR-ness (the line is not a new compile);
  • COMPILE SKIPPED: REASON records a failed compile;
  • (static) is ignored;
  • anything else prints line N: unknown suffix "TEXT", but the compile still counts.

Blank lines are ignored. A line that doesn't fit prints line N: unparseable (lines are numbered from 1, counting blank lines). An invalidation of an id that was never compiled prints line N: made not entrant for unknown compile id X (or made zombie).

Output

cCopy
Loading…

1. Totals: the number of compile lines (including skipped ones), with the OSR, native and skipped counts. between T0 and T1 ms uses the first and last parsed line's time, including invalidation lines, and is omitted if there are none.
2. by tier: counts per tier, in increasing order, of the compiles that are neither skipped nor native, including OSR ones. Print none when there are no such compiles.
3. One line per method, sorted by name (strcmp):
   • a native wrapper method prints native wrapper;
   • otherwise, tiers joins the tiers of its non-OSR, non-skipped compiles with -> (none if empty). Then running tier T (id I) for the last such compile that is still valid, or interpreted;
   • then , OSR T@BCI ... if any, , K invalidated if any, and [synchronized] / [has exception handlers] if the flags ever appeared.
4. Invalidations and skips, in compile order: invalidated: id I METHOD tier T[ OSR] (not entrant|zombie) and skipped: id I METHOD tier T: REASON.
5. K unparseable line(s), if any.

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. Parse positionally but tolerantly. Column widths vary between JDK versions, so split on runs of spaces rather than fixed offsets.
2. An invalidation refers to a compile id. Resolve it against earlier compiles instead of treating it as a new event.

Hidden tests cover a zombie after not-entrant, an invalidated OSR compile, tiers 1 and 2 with the blocking flag, an unknown id, unknown suffixes, out-of-range tiers, blank and malformed lines, and a trailing (static) suffix.