Приемлемость для анализа эвакуации/распределения стека с помощью Java 7

Ответ 1

EA - это то, что анализирует компилятор C2, основываясь на IR, который он генерирует, поэтому вам нужно его скомпилировать, чтобы воспользоваться преимуществами. Каждый тест вызывается только один раз, поэтому у него нет шансов для его компиляции. Подробная информация о EA и C2 IR в вики внутренней точки доступа (https://wiki.openjdk.java.net/display/HotSpot/Overview+of+Ideal,+C2%27s+high+level+intermediate+representation и https://wiki.openjdk.java.net/display/HotSpot/EscapeAnalysis)

Вот версия, которая пытается показать влияние

import com.sun.management.ThreadMXBean;

import java.lang.management.ManagementFactory;
import java.util.ArrayList;
import java.util.Iterator;


public class EscapeAnalysisTest {

    private static final long TIME_TO_TEST = 10L * 1000L; // 10s

    static class Timestamp {
        private long millis;

        public Timestamp(long millis) {
            this.millis = millis;
        }

        public long getTime() {
            return millis;
        }

        public void setTime(long time) {
            millis = time;
        }
    }

    public static void main(String[] args) {
        System.out.println("****");
        doIt();
        System.out.println("****");
        doIt();
        System.out.println("****");
        doIt();
        System.out.println("****");
        doIt();
        System.out.println("****");
    }

    private static void doIt() {
        final ThreadMXBean mxbean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
        final long tid = Thread.currentThread().getId();
        long r = 0;
        final long allocPre = mxbean.getThreadAllocatedBytes(tid);
        r += test1();
        long alloc1 = mxbean.getThreadAllocatedBytes(tid);
        System.out.println("test1 - " + (alloc1 - allocPre));
        r += test2();
        final long alloc2 = mxbean.getThreadAllocatedBytes(tid);
        System.out.println("test2 - " + (alloc2 - alloc1));
        r += test3();
        final long alloc3 = mxbean.getThreadAllocatedBytes(tid);
        System.out.println("test3 - " + (alloc3 - alloc2));
        r += test4();
        final long alloc4 = mxbean.getThreadAllocatedBytes(tid);
        System.out.println("test4 - " + (alloc4 - alloc3));
        r += test5();
        final long alloc5 = mxbean.getThreadAllocatedBytes(tid);
        System.out.println("test5 - " + (alloc5 - alloc4));
        r += test6();
        final long alloc6 = mxbean.getThreadAllocatedBytes(tid);
        System.out.println("test6 - " + (alloc6 - alloc5));
        System.out.println(r);
    }

    public static long test1() {
        long r = 0;
        long start = System.currentTimeMillis();
        while (System.currentTimeMillis() - start < TIME_TO_TEST) {
            r += new Timestamp(System.currentTimeMillis()).getTime();
        }
        return r;
    }

    public static long test2() {
        ArrayList<Integer> l = new ArrayList<Integer>(1000);
        for (int i = 0; i < 1000; ++i) {
            l.add(i);
        }
        long r = 0;
        long start = System.currentTimeMillis();
        while (System.currentTimeMillis() - start < TIME_TO_TEST) {
            for (Iterator<Integer> it = l.iterator(); it.hasNext(); ) {
                r += it.next().longValue();
            }
        }
        return r;
    }

    public static long test3() {
        long r = 0;
        long start = System.currentTimeMillis();
        while (System.currentTimeMillis() - start < TIME_TO_TEST) {
            Timestamp ts = new Timestamp(System.currentTimeMillis());
            ts.setTime(42);
            r += ts.getTime();
        }
        return r;
    }

    public static long test4() {
        ArrayList<Integer> l = new ArrayList<Integer>(1000);
        for (int i = 0; i < 1000; ++i) {
            l.add(i);
        }
        long r = 0;
        long start = System.currentTimeMillis();
        while (System.currentTimeMillis() - start < TIME_TO_TEST) {
            Iterator<Integer> it = l.iterator();
            r += it.next().longValue();
            r += it.next().longValue();
            r += it.next().longValue();
            r += it.next().longValue();
        }
        return r;
    }

    public static long test5() {
        ArrayList<Integer> l = new ArrayList<Integer>(1000);
        for (int i = 0; i < 1000; ++i) {
            l.add(i);
        }
        long r = 0;
        long start = System.currentTimeMillis();
        while (System.currentTimeMillis() - start < TIME_TO_TEST) {
            Iterator<Integer> it = l.iterator();
            for (int i = 0; i < l.size(); ++i) {
                r += it.next().longValue();
            }
        }
        return r;
    }

    public static long test6() {
        long r = 0;
        long start = System.currentTimeMillis();
        while (System.currentTimeMillis() - start < TIME_TO_TEST) {
            for (Timestamp ts = new Timestamp(System.currentTi());
                 ts.getTime() > 0;
                 ts.setTime(ts.getTime() + System.currentTimeMillis())) {
                r += ts.getTime();
            }
        }
        return r;
    }

}

который генерирует следующий вывод при запуске с -server -XX:CompileThreshold=1

****
test1 - 109048
test2 - 89243416
test3 - 16664
test4 - 42840
test5 - 71982168
test6 - 1400
-5351026995119026839
****
test1 - 16432
test2 - 85921464
test3 - 16664
test4 - 42840
test5 - 66777600
test6 - 1368
7844020592566674506
****
test1 - 48
test2 - 18256
test3 - 272
test4 - 18264
test5 - 18264
test6 - 272
-2137858376905291730
****
test1 - 48
test2 - 18256
test3 - 272
test4 - 18264
test5 - 18264
test6 - 272
3273987624143297143
****

Здесь есть одна опасность: компиляция этого метода изменила его более фундаментально, я не пытался защититься от этого, поэтому может потребоваться некоторое использование LogCompilation или PrintCompilation для проверки.

Ответ 2

Анализ Escape в значительной степени зависит от встраивания вызовов функций.

Как и в случае любого другого микрообъектива - особенно на сервере VM - требуется разминка. Если вы удалите -XX:CompileThreshold=1 и выполните свой основной тест в цикле, вы заметите, что после 1-2 итераций он перестанет собирать мусор, потому что компилятор собрал достаточную информацию профилирования, чтобы встроить методы, а затем выполнить анализ escape.

Ответ 3

Я только что исследовал то же самое, но для Java 8. Я поместил свой ответ в дубликат вопроса, так как я не нашел его вовремя.

Резюме от полного ответа:

Прежде всего, это зависит от реализации. Этот ответ относится к OpenJDK 1.8 и, возможно, также к Oracle JVM 1.8.

Во-вторых, как уже говорили другие, распределение стека происходит только тогда, когда метод компилируется компилятором C2, что происходит только после того, как метод был вызван достаточно раз.

Если это так, объекты могут быть размещены в стеке, если

• все вызовы методов, которые его используют, встроены
• оно никогда не присваивается никаким статическим или объектным полям, только локальным переменным (параметры для встроенных вызовов методов становятся локальными переменными)
• в каждой точке программы локальные переменные, содержащие ссылки на объект, должны определяться во времени JIT и не зависеть от непредсказуемого потока условного управления.
• Если объект является массивом, его размер должен быть константой времени JIT, а для индексации в нем должны использоваться константы времени JIT.

Встраивание особенно непредсказуемо, если вы не знаете некоторых специфических особенностей Hotspot. Смотрите связанный ответ для некоторых деталей.

Редактировать: я попытался запустить ваш тест на Java 8 (OpenJDK), и все там встроено. Таким образом, существуют различия в распределении стека между Java 7 и 8.