如何使用 `MethodHandle` 模仿 `tableswitch`？
How to mimic `tableswitch` using `MethodHandle`?
上下文： 我一直在对使用 invokedynamic 和手动生成字节码之间的区别进行基准测试（这是在决定针对 JVM 的编译器是否应该发出更冗长的“传统”字节码或仅使用巧妙的 bootstrap 方法的 invokedynamic 调用）。在这样做的过程中，将字节码映射到至少同样快的 MethodHandles 组合器非常简单，除了 tableswitch.
问题：有没有用MethodHandle模仿tableswitch的技巧？我尝试用一个跳转 table 来模仿它：使用常量 MethodHandle[]，用 arrayElementGetter 索引到它，然后用 MethodHandles.invoker 调用找到的句柄。然而，当我通过 JMH 运行 它时，它最终比原始字节码慢了大约 50%。
这是生成方法句柄的代码：
private static MethodHandle makeProductElement(Class<?> receiverClass, List<MethodHandle> getters) {
MethodHandle[] boxedGetters = getters
.stream()
.map(getter -> getter.asType(getter.type().changeReturnType(java.lang.Object.class)))
.toArray(MethodHandle[]::new);
MethodHandle getGetter = MethodHandles // (I)H
.arrayElementGetter(MethodHandle[].class)
.bindTo(boxedGetters);
MethodHandle invokeGetter = MethodHandles.permuteArguments( // (RH)O
MethodHandles.invoker(MethodType.methodType(java.lang.Object.class, receiverClass)),
MethodType.methodType(java.lang.Object.class, receiverClass, MethodHandle.class),
1,
0
);
return MethodHandles.filterArguments(invokeGetter, 1, getGetter);
}
这是初始字节码（我试图用一个 invokedynamic 调用替换它）
public java.lang.Object productElement(int);
descriptor: (I)Ljava/lang/Object;
flags: (0x0001) ACC_PUBLIC
Code:
stack=3, locals=3, args_size=2
0: iload_1
1: istore_2
2: iload_2
3: tableswitch { // 0 to 2
0: 28
1: 38
2: 45
default: 55
}
28: aload_0
29: invokevirtual #62 // Method i:()I
32: invokestatic #81 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
35: goto 67
38: aload_0
39: invokevirtual #65 // Method s:()Ljava/lang/String;
42: goto 67
45: aload_0
46: invokevirtual #68 // Method l:()J
49: invokestatic #85 // Method java/lang/Long.valueOf:(J)Ljava/lang/Long;
52: goto 67
55: new #87 // class java/lang/IndexOutOfBoundsException
58: dup
59: iload_1
60: invokestatic #93 // Method java/lang/Integer.toString:(I)Ljava/lang/String;
63: invokespecial #96 // Method java/lang/IndexOutOfBoundsException."<init>":(Ljava/lang/String;)V
66: athrow
67: areturn
事情是，tableswitch 。对于少量标签，例如您的示例，它可能充当二进制搜索。因此，使用常规“if-then”MethodHandles 树将是最接近的等价物。
invokedynamic的好处是它允许推迟决定，如何执行操作到实际的运行时。这是 LambdaMetafactory 或 StringConcatFactory 背后的技巧，它可能 return 组合方法句柄，如您的示例代码或动态生成的代码，由特定实现自行决定。
甚至还有一种可能的组合方法，生成 classes，您可以将其组合到一个操作中，例如解决已经存在的 LambdaMetafactory:
private static MethodHandle makeProductElement(
MethodHandles.Lookup lookup, Class<?> receiverClass, List<MethodHandle> getters)
throws Throwable {
Function[] boxedGetters = new Function[getters.size()];
MethodType factory = MethodType.methodType(Function.class);
for(int ix = 0; ix < boxedGetters.length; ix++) {
MethodHandle mh = getters.get(ix);
MethodType actual = mh.type().wrap(), generic = actual.erase();
boxedGetters[ix] = (Function)LambdaMetafactory.metafactory(lookup,
"apply", factory, generic, mh, actual).getTarget().invokeExact();
}
Object switcher = new Object() {
final Object get(Object receiver, int index) {
return boxedGetters[index].apply(receiver);
}
};
return lookup.bind(switcher, "get",
MethodType.methodType(Object.class, Object.class, int.class))
.asType(MethodType.methodType(Object.class, receiverClass, int.class));
}
这使用 LambdaMetafactory 为每个 getter 生成一个 Function 实例，类似于等效方法引用。然后，实例化一个实际的 class 调用右 Function 的 apply 方法，并实例化其 get 方法的方法句柄 returned.
这是与您的方法句柄类似的组合，但在参考实现中，不使用句柄，而是使用完全具体化的 classes。我希望组合句柄和这种方法能够针对大量调用收敛到相同的性能，但是物化 classes 在中等数量的调用中具有先发优势。
我添加了第一个参数MethodHandles.Lookup lookup，它应该是invokedynamic指令的bootstrap方法接收到的lookup对象。如果以这种方式使用，生成的函数可以像包含 invokedynamic 指令的代码一样访问所有方法，包括 class.
的 private 方法
或者，您可以自己生成包含真实开关指令的 class。使用 the ASM library，它可能看起来像：
private static MethodHandle makeProductElement(
MethodHandles.Lookup lookup, Class<?> receiverClass, List<MethodHandle> getters)
throws ReflectiveOperationException {
ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
cw.visit(V1_8, ACC_INTERFACE|ACC_ABSTRACT,
lookup.lookupClass().getName().replace('.', '/')+"$Switch", null,
"java/lang/Object", null);
MethodType type = MethodType.methodType(Object.class, receiverClass, int.class);
MethodVisitor mv = cw.visitMethod(ACC_STATIC|ACC_PUBLIC, "get",
type.toMethodDescriptorString(), null, null);
mv.visitCode();
Label defaultCase = new Label();
Label[] cases = new Label[getters.size()];
for(int ix = 0; ix < cases.length; ix++) cases[ix] = new Label();
mv.visitVarInsn(ALOAD, 0);
mv.visitVarInsn(ILOAD, 1);
mv.visitTableSwitchInsn(0, cases.length - 1, defaultCase, cases);
String owner = receiverClass.getName().replace('.', '/');
for(int ix = 0; ix < cases.length; ix++) {
mv.visitLabel(cases[ix]);
MethodHandle mh = getters.get(ix);
mv.visitMethodInsn(INVOKEVIRTUAL, owner, lookup.revealDirect(mh).getName(),
mh.type().dropParameterTypes(0, 1).toMethodDescriptorString(), false);
if(mh.type().returnType().isPrimitive()) {
Class<?> boxed = mh.type().wrap().returnType();
MethodType box = MethodType.methodType(boxed, mh.type().returnType());
mv.visitMethodInsn(INVOKESTATIC, boxed.getName().replace('.', '/'),
"valueOf", box.toMethodDescriptorString(), false);
}
mv.visitInsn(ARETURN);
}
mv.visitLabel(defaultCase);
mv.visitTypeInsn(NEW, "java/lang/IndexOutOfBoundsException");
mv.visitInsn(DUP);
mv.visitVarInsn(ILOAD, 1);
mv.visitMethodInsn(INVOKESTATIC, "java/lang/String",
"valueOf", "(I)Ljava/lang/String;", false);
mv.visitMethodInsn(INVOKESPECIAL, "java/lang/IndexOutOfBoundsException",
"<init>", "(Ljava/lang/String;)V", false);
mv.visitInsn(ATHROW);
mv.visitMaxs(-1, -1);
mv.visitEnd();
cw.visitEnd();
lookup = lookup.defineHiddenClass(
cw.toByteArray(), true, MethodHandles.Lookup.ClassOption.NESTMATE);
return lookup.findStatic(lookup.lookupClass(), "get", type);
}
这会生成一个新的 class，其中包含 static 方法，其中包含 tableswitch 指令和调用（以及我们现在必须自己进行的装箱转换）。此外，它还具有必要的代码来为越界值创建和抛出异常。在生成 class 之后，它 return 是那个 static 方法的句柄。
我不知道你的时间表。但是在Java17中很可能会有一个MethodHandles.tableSwitch操作。目前正在通过https://github.com/openjdk/jdk/pull/3401/
进行整合
这里有更多关于它的讨论：
https://mail.openjdk.java.net/pipermail/core-libs-dev/2021-April/076105.html
上下文： 我一直在对使用 invokedynamic 和手动生成字节码之间的区别进行基准测试（这是在决定针对 JVM 的编译器是否应该发出更冗长的“传统”字节码或仅使用巧妙的 bootstrap 方法的 invokedynamic 调用）。在这样做的过程中，将字节码映射到至少同样快的 MethodHandles 组合器非常简单，除了 tableswitch.
问题：有没有用MethodHandle模仿tableswitch的技巧？我尝试用一个跳转 table 来模仿它：使用常量 MethodHandle[]，用 arrayElementGetter 索引到它，然后用 MethodHandles.invoker 调用找到的句柄。然而，当我通过 JMH 运行 它时，它最终比原始字节码慢了大约 50%。
这是生成方法句柄的代码：
private static MethodHandle makeProductElement(Class<?> receiverClass, List<MethodHandle> getters) {
MethodHandle[] boxedGetters = getters
.stream()
.map(getter -> getter.asType(getter.type().changeReturnType(java.lang.Object.class)))
.toArray(MethodHandle[]::new);
MethodHandle getGetter = MethodHandles // (I)H
.arrayElementGetter(MethodHandle[].class)
.bindTo(boxedGetters);
MethodHandle invokeGetter = MethodHandles.permuteArguments( // (RH)O
MethodHandles.invoker(MethodType.methodType(java.lang.Object.class, receiverClass)),
MethodType.methodType(java.lang.Object.class, receiverClass, MethodHandle.class),
1,
0
);
return MethodHandles.filterArguments(invokeGetter, 1, getGetter);
}
这是初始字节码（我试图用一个 invokedynamic 调用替换它）
public java.lang.Object productElement(int);
descriptor: (I)Ljava/lang/Object;
flags: (0x0001) ACC_PUBLIC
Code:
stack=3, locals=3, args_size=2
0: iload_1
1: istore_2
2: iload_2
3: tableswitch { // 0 to 2
0: 28
1: 38
2: 45
default: 55
}
28: aload_0
29: invokevirtual #62 // Method i:()I
32: invokestatic #81 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
35: goto 67
38: aload_0
39: invokevirtual #65 // Method s:()Ljava/lang/String;
42: goto 67
45: aload_0
46: invokevirtual #68 // Method l:()J
49: invokestatic #85 // Method java/lang/Long.valueOf:(J)Ljava/lang/Long;
52: goto 67
55: new #87 // class java/lang/IndexOutOfBoundsException
58: dup
59: iload_1
60: invokestatic #93 // Method java/lang/Integer.toString:(I)Ljava/lang/String;
63: invokespecial #96 // Method java/lang/IndexOutOfBoundsException."<init>":(Ljava/lang/String;)V
66: athrow
67: areturn
事情是，tableswitch
invokedynamic的好处是它允许推迟决定，如何执行操作到实际的运行时。这是 LambdaMetafactory 或 StringConcatFactory 背后的技巧，它可能 return 组合方法句柄，如您的示例代码或动态生成的代码，由特定实现自行决定。
甚至还有一种可能的组合方法，生成 classes，您可以将其组合到一个操作中，例如解决已经存在的 LambdaMetafactory:
private static MethodHandle makeProductElement(
MethodHandles.Lookup lookup, Class<?> receiverClass, List<MethodHandle> getters)
throws Throwable {
Function[] boxedGetters = new Function[getters.size()];
MethodType factory = MethodType.methodType(Function.class);
for(int ix = 0; ix < boxedGetters.length; ix++) {
MethodHandle mh = getters.get(ix);
MethodType actual = mh.type().wrap(), generic = actual.erase();
boxedGetters[ix] = (Function)LambdaMetafactory.metafactory(lookup,
"apply", factory, generic, mh, actual).getTarget().invokeExact();
}
Object switcher = new Object() {
final Object get(Object receiver, int index) {
return boxedGetters[index].apply(receiver);
}
};
return lookup.bind(switcher, "get",
MethodType.methodType(Object.class, Object.class, int.class))
.asType(MethodType.methodType(Object.class, receiverClass, int.class));
}
这使用 LambdaMetafactory 为每个 getter 生成一个 Function 实例，类似于等效方法引用。然后，实例化一个实际的 class 调用右 Function 的 apply 方法，并实例化其 get 方法的方法句柄 returned.
这是与您的方法句柄类似的组合，但在参考实现中，不使用句柄，而是使用完全具体化的 classes。我希望组合句柄和这种方法能够针对大量调用收敛到相同的性能，但是物化 classes 在中等数量的调用中具有先发优势。
我添加了第一个参数MethodHandles.Lookup lookup，它应该是invokedynamic指令的bootstrap方法接收到的lookup对象。如果以这种方式使用，生成的函数可以像包含 invokedynamic 指令的代码一样访问所有方法，包括 class.
private 方法
或者，您可以自己生成包含真实开关指令的 class。使用 the ASM library，它可能看起来像：
private static MethodHandle makeProductElement(
MethodHandles.Lookup lookup, Class<?> receiverClass, List<MethodHandle> getters)
throws ReflectiveOperationException {
ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
cw.visit(V1_8, ACC_INTERFACE|ACC_ABSTRACT,
lookup.lookupClass().getName().replace('.', '/')+"$Switch", null,
"java/lang/Object", null);
MethodType type = MethodType.methodType(Object.class, receiverClass, int.class);
MethodVisitor mv = cw.visitMethod(ACC_STATIC|ACC_PUBLIC, "get",
type.toMethodDescriptorString(), null, null);
mv.visitCode();
Label defaultCase = new Label();
Label[] cases = new Label[getters.size()];
for(int ix = 0; ix < cases.length; ix++) cases[ix] = new Label();
mv.visitVarInsn(ALOAD, 0);
mv.visitVarInsn(ILOAD, 1);
mv.visitTableSwitchInsn(0, cases.length - 1, defaultCase, cases);
String owner = receiverClass.getName().replace('.', '/');
for(int ix = 0; ix < cases.length; ix++) {
mv.visitLabel(cases[ix]);
MethodHandle mh = getters.get(ix);
mv.visitMethodInsn(INVOKEVIRTUAL, owner, lookup.revealDirect(mh).getName(),
mh.type().dropParameterTypes(0, 1).toMethodDescriptorString(), false);
if(mh.type().returnType().isPrimitive()) {
Class<?> boxed = mh.type().wrap().returnType();
MethodType box = MethodType.methodType(boxed, mh.type().returnType());
mv.visitMethodInsn(INVOKESTATIC, boxed.getName().replace('.', '/'),
"valueOf", box.toMethodDescriptorString(), false);
}
mv.visitInsn(ARETURN);
}
mv.visitLabel(defaultCase);
mv.visitTypeInsn(NEW, "java/lang/IndexOutOfBoundsException");
mv.visitInsn(DUP);
mv.visitVarInsn(ILOAD, 1);
mv.visitMethodInsn(INVOKESTATIC, "java/lang/String",
"valueOf", "(I)Ljava/lang/String;", false);
mv.visitMethodInsn(INVOKESPECIAL, "java/lang/IndexOutOfBoundsException",
"<init>", "(Ljava/lang/String;)V", false);
mv.visitInsn(ATHROW);
mv.visitMaxs(-1, -1);
mv.visitEnd();
cw.visitEnd();
lookup = lookup.defineHiddenClass(
cw.toByteArray(), true, MethodHandles.Lookup.ClassOption.NESTMATE);
return lookup.findStatic(lookup.lookupClass(), "get", type);
}
这会生成一个新的 class，其中包含 static 方法，其中包含 tableswitch 指令和调用（以及我们现在必须自己进行的装箱转换）。此外，它还具有必要的代码来为越界值创建和抛出异常。在生成 class 之后，它 return 是那个 static 方法的句柄。
我不知道你的时间表。但是在Java17中很可能会有一个MethodHandles.tableSwitch操作。目前正在通过https://github.com/openjdk/jdk/pull/3401/
进行整合这里有更多关于它的讨论： https://mail.openjdk.java.net/pipermail/core-libs-dev/2021-April/076105.html