Compiler deoptimization behaviour

[David Griffiths]

I wrote a simple little test to better understand the compiler frame layout
but it exhibits strange behaviour in that it starts off very fast and then
slows to a million times slower. From running with -XX:+PrintCompilation I
_think_ it is something to do with one of the bottom level methods getting
deoptimized - this message appears just as the performance falls off the
cliff:

115   48       3       TestFrames::add2 (31 bytes)   made not entrant

but I don't understand why the more optimized version doesn't then kick in.
I've tried various things like breaking out of all the loops and starting
again when my monitor thread wakes up but it still stays slow. The slowdown
occurs randomly when "i" is typically between 150 and 500.

public class TestFrames {
    long var;

    public static void main(String[] args) {
        new TestFrames();
    }

    TestFrames() {
        // monitor thread
        new Thread() {
            public void run() {
                for (;;) {
                    try {
                        Thread.sleep(5000);
                    } catch (Exception e) {}
                    System.out.println("var = " + var);
                }
            }
        }.start();

        for (int i = 0; i < 100000; i++) {
            System.out.println("i = " + i + " var = " + var);
            add1(1);
        }
    }

    private void add1(int n) {
        var += n;
        for (int i = 0; i < 10; i++)
            add2(2);
    }

    private void add2(int n) {
        var += n;
        for (int i = 0; i < 10; i++)
            add3(3);
    }

    private void add3(int n) {
        var += n;
        for (int i = 0; i < 10; i++)
            add4(4);
    }

    private void add4(int n) {
        var += n;
        for (int i = 0; i < 10; i++)
            add5(5);
    }

    private void add5(int n) {
        var += n;
        for (int i = 0; i < 10; i++)
            add6(6);
    }

    private void add6(int n) {
        var += n;
        for (int i = 0; i < 10; i++)
            add7(7);
    }

    private void add7(int n) {
        var += n;
        for (int i = 0; i < 10; i++)
            add8(8);
    }

    private void add8(int n) {
        var += n;
        for (int i = 0; i < 10; i++)
            add9(9);
    }

    private void add9(int n) {
        var += n;
        for (int i = 0; i < 10; i++)
            add10(10);
    }

    private void add10(int n) {
        var += n;
        for (int i = 0; i < 10; i++)
            add11(11);
    }

    private void add11(int n) {
        var += n;
        for (int i = 0; i < 10; i++)
            add12(12);
    }

    private void add12(int n) {
        var += n;
        for (int i = 0; i < 10; i++)
            add13(13);
    }

    private void add13(int n) {
        var += n;
    }
}

Is there any tweak I can make to the program such that the optimized methof
will get picked up (if that is indeed the problem)?

Thanks,

David