Just-In-Time Compilation Explained: How JITs Turn Bytecode Into Blazing Native Code

import java.util.HashMap;
import java.util.Map;

/**
 * Demonstrates tiered JIT compilation by measuring throughput
 * across the warmup curve. Run with:
 *   java -XX:+PrintCompilation -XX:+UnlockDiagnosticVMOptions \
 *        -XX:+PrintInlining TieredCompilationDemo
 *
 * You will see C1 compilations appear early (flags like '!'),
 * then C2 take over the hot methods later.
 */
public class TieredCompilationDemo {

    // This map lookup is our 'hot method' — simple, called millions of times
    private static final Map<String, Integer> wordFrequency = new HashMap<>();

    static {
        wordFrequency.put("java", 42);
        wordFrequency.put("jit", 99);
        wordFrequency.put("compiler", 7);
    }

    /**
     * A method that will become extremely hot and get fully C2-compiled.
     * Notice it's small — small methods get inlined at the call site,
     * which is even faster than a compiled method call.
     */
    private static int lookupFrequency(String word) {
        Integer frequency = wordFrequency.get(word);
        return (frequency != null) ? frequency : 0;
    }

    public static void main(String[] args) throws InterruptedException {
        String[] wordsToLookup = {"java", "jit", "compiler", "unknown"};
        int totalIterations = 500_000;

        // Measure throughput across 5 equal batches to see JIT warmup curve
        int batchSize = totalIterations / 5;

        for (int batch = 0; batch < 5; batch++) {
            long startNanos = System.nanoTime();

            for (int i = 0; i < batchSize; i++) {
                // Rotate through all words so the JIT sees a stable type profile
                String word = wordsToLookup[i % wordsToLookup.length];
                int freq = lookupFrequency(word);

                // Prevent dead-code elimination — the JIT is smart enough
                // to delete code whose result is never used
                if (freq < 0) {
                    System.out.println("Negative frequency — impossible but prevents DCE");
                }
            }

            long elapsedMs = (System.nanoTime() - startNanos) / 1_000_000;
            double throughput = (double) batchSize / elapsedMs * 1000;

            System.out.printf(
                "Batch %d: %,d lookups in %d ms → %,.0f lookups/sec%n",
                batch + 1, batchSize, elapsedMs, throughput
            );

            // Brief pause lets you see PrintCompilation output between batches
            Thread.sleep(50);
        }
    }
}

/**
 * Demonstrates speculative inlining and the deoptimization it causes.
 *
 * Run with:
 *   java -XX:+PrintDeoptimization -XX:+PrintCompilation \
 *        -XX:+UnlockDiagnosticVMOptions DeoptimizationTriggerDemo
 *
 * You'll see 'made not entrant' and 'uncommon trap' in the output
 * exactly when we introduce the second type at the call site.
 */
public class DeoptimizationTriggerDemo {

    interface Greeter {
        String greet(String name);
    }

    static class FriendlyGreeter implements Greeter {
        @Override
        public String greet(String name) {
            // JIT will speculatively inline THIS body if it's the only type seen
            return "Hey there, " + name + "!";
        }
    }

    static class FormalGreeter implements Greeter {
        @Override
        public String greet(String name) {
            return "Good day, " + name + ". How do you do?";
        }
    }

    /**
     * This is the polymorphic call site.
     * During Phase 1 the JIT sees only FriendlyGreeter here.
     * It speculatively inlines FriendlyGreeter.greet() and removes
     * the virtual dispatch overhead entirely.
     */
    private static String performGreeting(Greeter greeter, String name) {
        return greeter.greet(name); // <-- the hot call site
    }

    public static void main(String[] args) throws InterruptedException {
        Greeter friendlyGreeter = new FriendlyGreeter();
        Greeter formalGreeter   = new FormalGreeter();

        System.out.println("=== Phase 1: Warming up with monomorphic call site ===");
        System.out.println("JIT will speculatively inline FriendlyGreeter.greet()\n");

        // 100,000 calls with only one concrete type — C2 will inline aggressively
        long sumLength = 0;
        for (int i = 0; i < 100_000; i++) {
            String result = performGreeting(friendlyGreeter, "Alice");
            sumLength += result.length(); // consume the result to prevent DCE
        }
        System.out.printf("Phase 1 complete. Total chars processed: %,d%n%n", sumLength);

        // Pause so PrintCompilation output is clearly separated
        Thread.sleep(200);

        System.out.println("=== Phase 2: Introducing second type — watch for deoptimization ===");
        System.out.println("The guard check will now fail. Expect 'made not entrant' in logs.\n");

        // Now we alternate between two types — this blows the monomorphic assumption
        sumLength = 0;
        for (int i = 0; i < 50_000; i++) {
            // Alternating receivers make the call site bimorphic
            Greeter active = (i % 2 == 0) ? friendlyGreeter : formalGreeter;
            String result = performGreeting(active, "Bob");
            sumLength += result.length();
        }
        System.out.printf("Phase 2 complete. Total chars processed: %,d%n", sumLength);
        System.out.println("\nCheck your console above for PrintDeoptimization output.");
        System.out.println("Look for: 'bimorphic' or 'type profile changed' reason codes.");
    }
}

/**
 * Shows how method size affects JIT inlining and the performance
 * difference between an inlined vs non-inlined hot path.
 *
 * Run both scenarios and compare throughput:
 *   java -XX:+PrintInlining -XX:+UnlockDiagnosticVMOptions \
 *        -XX:+PrintCompilation InliningThresholdDemo
 *
 * To artificially lower the inline threshold and see more failures:
 *   java -XX:MaxInlineSize=10 InliningThresholdDemo
 */
public class InliningThresholdDemo {

    /**
     * Small method — well within the 35-byte default MaxInlineSize.
     * The JIT will inline this at every call site, making the call
     * effectively zero-cost and enabling constant folding in callers.
     */
    private static double calculateCircleArea(double radius) {
        return Math.PI * radius * radius; // compiles to ~8 bytecodes
    }

    /**
     * Artificially inflated method — same logic, but padded with
     * unnecessary intermediate variables that push bytecode size past
     * the inlining threshold. In real code this happens with logging,
     * null checks, and defensive validation scattered through hot methods.
     */
    private static double calculateCircleAreaVerbose(double radius) {
        double pi          = Math.PI;
        double radiusSquared = radius * radius;
        double rawArea     = pi * radiusSquared;
        double roundedArea = Math.round(rawArea * 1_000_000.0) / 1_000_000.0;
        // Extra branching and method calls push this over MaxInlineSize
        if (Double.isNaN(roundedArea) || Double.isInfinite(roundedArea)) {
            throw new ArithmeticException("Invalid radius produced non-finite area: " + radius);
        }
        return roundedArea;
    }

    private static long benchmarkSmallMethod(int iterations) {
        double accumulator = 0.0; // accumulate to prevent dead-code elimination
        long startNanos = System.nanoTime();

        for (int i = 1; i <= iterations; i++) {
            double radius = i * 0.001; // different radius each time prevents constant folding
            accumulator += calculateCircleArea(radius);
        }

        long elapsedNanos = System.nanoTime() - startNanos;
        // Print accumulator so the JIT can't eliminate the loop
        System.out.printf("  Small method total area sum: %.2f%n", accumulator);
        return elapsedNanos;
    }

    private static long benchmarkVerboseMethod(int iterations) {
        double accumulator = 0.0;
        long startNanos = System.nanoTime();

        for (int i = 1; i <= iterations; i++) {
            double radius = i * 0.001;
            accumulator += calculateCircleAreaVerbose(radius);
        }

        long elapsedNanos = System.nanoTime() - startNanos;
        System.out.printf("  Verbose method total area sum: %.2f%n", accumulator);
        return elapsedNanos;
    }

    public static void main(String[] args) {
        int warmupIterations = 200_000;
        int benchIterations  = 2_000_000;

        // Warmup phase — let both methods reach C2 compilation tier
        System.out.println("Warming up JIT (both methods to Tier 4)...");
        benchmarkSmallMethod(warmupIterations);
        benchmarkVerboseMethod(warmupIterations);

        // Actual benchmark
        System.out.println("\n--- Benchmark (" + benchIterations + " iterations each) ---");

        long smallNanos   = benchmarkSmallMethod(benchIterations);
        long verboseNanos = benchmarkVerboseMethod(benchIterations);

        System.out.printf("%n  Small method (likely inlined):   %,d ms%n", smallNanos / 1_000_000);
        System.out.printf("  Verbose method (may not inline): %,d ms%n", verboseNanos / 1_000_000);
        System.out.printf("  Overhead factor: %.2fx%n",
            (double) verboseNanos / smallNanos);
        System.out.println("\nCheck PrintInlining output for '@ X callee is too large' to confirm.");
    }
}

/**
 * Demonstrates On-Stack Replacement (OSR) by creating a single
 * method with a loop long enough to trigger JIT compilation
 * while the method is already executing.
 *
 * Run with:
 *   java -XX:+PrintCompilation -XX:+TraceOSR OsrAndWarmupDemo
 *
 * Look for '%' sign in PrintCompilation output — that's OSR compilation.
 * Normal compilations show no '%'. OSR compilations do.
 *
 * Example line:
 *   1234  42 %  4   OsrAndWarmupDemo::longRunningSetup @ 15 (88 bytes)
 *   The '@15' means the OSR entry point is at bytecode index 15 (the loop back-edge).
 */
public class OsrAndWarmupDemo {

    /**
     * This method is called ONCE but runs long enough that the JIT
     * compiles it mid-execution. Without OSR, we'd interpret all
     * 5 million iterations. With OSR, after ~10,000 iterations the
     * JIT compiles the method and swaps us into native code seamlessly.
     */
    private static double longRunningSetup(int iterationCount) {
        double runningTotal = 0.0;

        // This loop is the OSR candidate — it runs long enough in a single
        // method call to trigger compilation via back-edge counter
        for (int i = 1; i <= iterationCount; i++) {
            // Enough work that the loop body isn't trivially eliminated
            runningTotal += Math.sqrt(i) * Math.log1p(i);

            // Progress marker — remove in real code, just for demo visibility
            if (i == 10_000) {
                System.out.println("  [iteration 10,000] — JIT likely compiling this method NOW via OSR");
            }
            if (i == 50_000) {
                System.out.println("  [iteration 50,000] — now running in OSR-compiled native code");
            }
        }

        return runningTotal;
    }

    /**
     * Demonstrates the production warmup pattern: calling lightweight
     * versions of your hot paths during startup before accepting traffic.
     */
    private static void simulateWarmupPhase() {
        System.out.println("\n=== Warmup Phase (simulating pre-traffic JIT priming) ===");

        // In production this would be replayed production requests.
        // Here we call our hot method multiple times with representative inputs
        // so C2 compiles it before real users arrive.
        for (int warmupRound = 0; warmupRound < 5; warmupRound++) {
            double result = longRunningSetup(20_000); // short but enough to profile
            System.out.printf("  Warmup round %d result: %.2f%n", warmupRound + 1, result);
        }

        System.out.println("Warmup complete — instance ready to serve traffic.\n");
    }

    public static void main(String[] args) {
        System.out.println("=== Phase 1: Single Long-Running Method Call (OSR Demo) ===");
        System.out.println("Calling longRunningSetup ONCE with 5 million iterations.");
        System.out.println("Watch for OSR compilation to fire mid-execution:\n");

        long startNanos = System.nanoTime();
        double osrResult = longRunningSetup(5_000_000); // one call, very long loop
        long osrElapsedMs = (System.nanoTime() - startNanos) / 1_000_000;

        System.out.printf("OSR demo result: %.4f | Elapsed: %d ms%n", osrResult, osrElapsedMs);

        // Now show the production warmup pattern
        simulateWarmupPhase();

        System.out.println("=== Phase 2: Post-warmup benchmark (fully C2 compiled) ===");
        startNanos = System.nanoTime();
        double warmResult = longRunningSetup(5_000_000);
        long warmElapsedMs = (System.nanoTime() - startNanos) / 1_000_000;

        System.out.printf("Warm result: %.4f | Elapsed: %d ms%n", warmResult, warmElapsedMs);
        System.out.printf("Speedup after full warmup: %.1fx%n",
            (double) osrElapsedMs / Math.max(warmElapsedMs, 1));
    }
}