MethodHandles или LambdaMetafactory?

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

Напротив, создание явного кода для всего дерева сопряжено с риском превышения пороговых значений JVM, тогда у вас есть код, который наверняка не имеет накладных расходов на отправку, но может работать интерпретируемым все время.

Дерево адаптированных MethodHandle начинается так же, как и любое другое дерево, но с более высокими накладными расходами. Спорный вопрос, способна ли его собственная оптимизация превзойти собственную стратегию встраивания HotSpots. И, как вы заметили, требуется большое количество вызовов, прежде чем сработает самонастройка. Похоже, что пороговые значения накапливаются неудачным образом для составных дескрипторов методов.

Чтобы назвать один из ярких примеров шаблона дерева оценки, когда вы используете _ 2_, чтобы подготовить операцию сопоставления регулярных выражений, ни байт-код, ни машинный код не будут сгенерированы, несмотря на то, что название метода может ввести в заблуждение мышление в этом направлении. Внутреннее представление - это просто неизменное дерево узлов, представляющее комбинации различных видов операций. Оптимизатор JVM должен сгенерировать для него сплющенный код, если это будет сочтено полезным.

Лямбда-выражения не меняют правила игры. Они позволяют создавать (небольшие) классы, выполняющие интерфейс и вызывающие целевой метод. Вы можете использовать их для построения неизменяемого оценочного дерева, и, хотя маловероятно, что оно будет иметь производительность, отличную от явно запрограммированных классов оценочных узлов, он позволяет использовать гораздо более простой код:

public class Arithmetics {
    public static void main(String[] args) {
        // x * (3 + y)
        DoubleBinaryOperator func=op(MUL, X, op(ADD, constant(3), Y));
        System.out.println(func.applyAsDouble(5, 4));
        PREDEFINED_UNARY_FUNCTIONS.forEach((name, f) ->
            System.out.println(name+"(0.42) = "+f.applyAsDouble(0.42)));
        PREDEFINED_BINARY_FUNCTIONS.forEach((name, f) ->
            System.out.println(name+"(0.42,0.815) = "+f.applyAsDouble(0.42,0.815)));
        // sin(x)+cos(y)
        func=op(ADD,
            op(PREDEFINED_UNARY_FUNCTIONS.get("sin"), X),
            op(PREDEFINED_UNARY_FUNCTIONS.get("cos"), Y));
        System.out.println("sin(0.6)+cos(y) = "+func.applyAsDouble(0.6, 0.5));
    }
    public static DoubleBinaryOperator ADD = Double::sum;
    public static DoubleBinaryOperator SUB = (a,b) -> a-b;
    public static DoubleBinaryOperator MUL = (a,b) -> a*b;
    public static DoubleBinaryOperator DIV = (a,b) -> a/b;
    public static DoubleBinaryOperator REM = (a,b) -> a%b;

    public static <T> DoubleBinaryOperator op(
        DoubleUnaryOperator op, DoubleBinaryOperator arg1) {
        return (x,y) -> op.applyAsDouble(arg1.applyAsDouble(x,y));
    }
    public static DoubleBinaryOperator op(
        DoubleBinaryOperator op, DoubleBinaryOperator arg1, DoubleBinaryOperator arg2) {
        return (x,y)->op.applyAsDouble(arg1.applyAsDouble(x,y),arg2.applyAsDouble(x,y));
    }
    public static DoubleBinaryOperator X = (x,y) -> x, Y = (x,y) -> y;
    public static DoubleBinaryOperator constant(double value) {
        return (x,y) -> value;
    }

    public static final Map<String,DoubleUnaryOperator> PREDEFINED_UNARY_FUNCTIONS
        = getPredefinedFunctions(DoubleUnaryOperator.class,
            MethodType.methodType(double.class, double.class));
    public static final Map<String,DoubleBinaryOperator> PREDEFINED_BINARY_FUNCTIONS
        = getPredefinedFunctions(DoubleBinaryOperator.class,
            MethodType.methodType(double.class, double.class, double.class));

    private static <T> Map<String,T> getPredefinedFunctions(Class<T> t, MethodType mt) {
        Map<String,T> result=new HashMap<>();
        MethodHandles.Lookup l=MethodHandles.lookup();
        for(Method m:Math.class.getMethods()) try {
            MethodHandle mh=l.unreflect(m);
            if(!mh.type().equals(mt)) continue;
            result.put(m.getName(), t.cast(LambdaMetafactory.metafactory(
            MethodHandles.lookup(), "applyAsDouble", MethodType.methodType(t),
            mt, mh, mt) .getTarget().invoke()));
        }
        catch(RuntimeException|Error ex) { throw ex; }
        catch(Throwable ex) { throw new AssertionError(ex); }
        return Collections.unmodifiableMap(result);
    }
}

Это все, что вам нужно для составления оценщиков для выражений, состоящих из основных арифметических операторов и функций, найденных в java.lang.Math, последние собираются динамически, чтобы решить этот аспект вашего вопроса.

Обратите внимание, что технически

public static DoubleBinaryOperator MUL = (a,b) -> a*b;

это просто сокращение для

public static DoubleBinaryOperator MUL = Arithmetics::mul;
public static double mul(double a, double b){
    return a*b;
}

Я добавил main метод, содержащий несколько примеров. Имейте в виду, что эти функции ведут себя как скомпилированный код, прямо при первом вызове, поскольку на самом деле они состоят только из скомпилированного кода, но состоят из нескольких функций.