VALUE = new MostlyConstant<>(42.0, double.class);
134 | static final DoubleSupplier VALUE_GETTER = VALUE.doubleGetter();
135 | }
136 |
137 | @Test
138 | public void testDoubleSimpleChangeOptimized() {
139 | class Fake {
140 | double test() {
141 | return DoubleSandbox2.VALUE_GETTER.getAsDouble();
142 | }
143 | }
144 |
145 | Fake fake = new Fake();
146 | for (int i = 0; i < 1_000_000; i++) {
147 | assertEquals(42L, fake.test());
148 | }
149 | assertEquals(42L, fake.test());
150 |
151 | DoubleSandbox2.VALUE.setAndDeoptimize(43.0);
152 | assertEquals(43L, fake.test());
153 | }
154 |
155 | @Test
156 | public void testConstructorWithVoidType() {
157 | assertThrows(IllegalArgumentException.class, () -> new MostlyConstant<>(null, void.class));
158 | }
159 |
160 | @Test
161 | public void testConstructorWithNullType() {
162 | assertThrows(NullPointerException.class, () -> new MostlyConstant<>(null, null));
163 | }
164 |
165 | @Test
166 | public void testSpecializedGettersWithWrapperTypes() {
167 | assertThrows(
168 | IllegalStateException.class, () -> new MostlyConstant<>(0, Integer.class).intGetter());
169 | assertThrows(
170 | IllegalStateException.class, () -> new MostlyConstant<>(0L, Long.class).longGetter());
171 | assertThrows(
172 | IllegalStateException.class, () -> new MostlyConstant<>(0.0, Double.class).doubleGetter());
173 |
174 | assertThrows(
175 | IllegalStateException.class, () -> new MostlyConstant<>(0, Object.class).intGetter());
176 | assertThrows(
177 | IllegalStateException.class, () -> new MostlyConstant<>(0L, Object.class).longGetter());
178 | assertThrows(
179 | IllegalStateException.class, () -> new MostlyConstant<>(0.0, Object.class).doubleGetter());
180 | }
181 | }
182 |
--------------------------------------------------------------------------------
/src/main/java/com.github.forax.exotic/Visitor.java:
--------------------------------------------------------------------------------
1 | package com.github.forax.exotic;
2 |
3 | import static java.lang.invoke.MethodHandles.insertArguments;
4 |
5 | import java.lang.invoke.MethodHandle;
6 | import java.lang.invoke.MethodType;
7 | import java.util.HashMap;
8 | import java.util.Objects;
9 | import java.util.function.Consumer;
10 |
11 | /**
12 | * A open visitor based on lambdas that tries hard to optimize all intra-visitor calls.
13 | *
14 | * The visitor let you ({@link Registry#register(Class, Visitlet)}) a computation for any type you want
15 | * (they do not have to have a root interface by example) and then when {@link Visitor#visit(Object, Object) visiting}
16 | * the visitor, the right computation is called depending on the class of the expression.
17 | *
18 | * The idea of the implementation is to send an object that has the same interface as the Visitor as first parameter of each lambda
19 | * that implement an inlining cache specific for this lambda, thus mimicking the inlining caches that
20 | * you naturally have when implementing the double-dispatch (the visitor pattern of the Gof).
21 | *
22 | * Let suppose we have the following abstract syntax tree,
23 | *
24 | * interface Expr { }
25 | * class Value implements Expr { final int value; Value(int value) { this.value = value; }}
26 | * class Add implements Expr { final Expr left, right; Add(Expr left, Expr right) { this.left = left; this.right = right; }}
27 | *
28 | *
29 | * to evaluate it, we can use a visitor configured like this
30 | *
31 | * private static final Visitor<Void, Integer> VISITOR = Visitor.create(Void.class, int.class, opt -> opt
32 | * .register(Value.class, (visitor, value, __) -> value.value)
33 | * .register(Add.class, (visitor, add, __) -> visitor.visit(add.left, null) + visitor.visit(add.right, null))
34 | * );
35 | * ...
36 | * Expr expr = new Add(new Add(new Value(7), new Value(10)), new Value(4));
37 | * int value = VISITOR.visit(expr, null); // 21
38 | *
39 | *
40 | * @param type of the parameter value (the inherited attribute)
41 | * @param type of the return value (the synthesized attribute)
42 | */
43 | @FunctionalInterface
44 | public interface Visitor {
45 | /**
46 | * Visit one of the {@link Visitlet} depending on the class of the expression {@code expr}.
47 | *
48 | * @param expr an expression
49 | * @param parameter a parameter or null.
50 | * @return the return value of the called {@link Visitlet}.
51 | * @throws NullPointerException if {@code expr} is null.
52 | * @throws IllegalStateException if the expression class has no corresponding visitlet defined
53 | */
54 | R visit(Object expr, P parameter);
55 |
56 | /**
57 | * A computation part of a visitor specific for a type.
58 | *
59 | * @param the type of the expression.
60 | * @param the type of the parameter, can be Void if the parameter is null.
61 | * @param the type of the return value.
62 | *
63 | * @see Registry#register(Class, Visitlet)
64 | * @see Visitor#visit(Object, Object)
65 | */
66 | @FunctionalInterface
67 | interface Visitlet {
68 | /**
69 | * The computation for a part of an expression.
70 | *
71 | * @param visitor a visitor that can be called to do a recursive computation.
72 | * @param expr an expression.
73 | * @param parameter the value of a parameter or null.
74 | * @return the value of the computation.
75 | */
76 | R visit(Visitor visitor, T expr, P parameter);
77 | }
78 |
79 | /**
80 | * Registry that contains the association between a type and its corresponding computation as a {@link Visitlet}.
81 | *
82 | * @param the type of the parameter, can be Void if the parameter is null.
83 | * @param the type of the return value.
84 | */
85 | interface Registry {
86 | /**
87 | * Register a computation for a specific type.
88 | *
89 | * @param type of the expression.
90 | * @param type the class of the expression that will be computed by the computation.
91 | * @param visitlet a computation.
92 | * @return itself so calls to register can be chained (as a build).
93 | * @throws NullPointerException if the {@code type} or {@code visitlet} is null.
94 | * @throws IllegalStateException if a computation has already register for a type.
95 | */
96 | Registry register(Class type, Visitlet visitlet);
97 | }
98 |
99 | /**
100 | * Creates a visitor with the {@link Visitlet visitlets} registered in the {@link Registry}.
101 | *
102 | * @param type of the parameter, can be Void if the parameter is null.
103 | * @param type of the return value.
104 | * @param pType class of the parameter type.
105 | * @param rType class of the return type.
106 | * @param consumer consumer that will register the {@link Visitlet visitlet} in the {@link Registry}.
107 | * @return a visitor configured with the {@link Visitlet visitlets}.
108 | * @throws NullPointerException if {@code pType}, {@code rType} or {@code consumer} is null.
109 | */
110 | static Visitor create(Class pType, Class rType, Consumer> consumer) {
111 | Objects.requireNonNull(pType);
112 | Objects.requireNonNull(rType);
113 | Objects.requireNonNull(consumer);
114 | HashMap, MethodHandle> map = new HashMap<>();
115 |
116 | MethodType methodType = MethodType.methodType(rType, Object.class, pType);
117 | consumer.accept(new Registry() {
118 | @Override
119 | public Registry register(Class type, Visitlet visitlet) {
120 | Objects.requireNonNull(type);
121 | Objects.requireNonNull(visitlet);
122 | if (map.containsKey(type)) {
123 | throw new IllegalStateException("there is already a visitlet register for type " + type.getName());
124 | }
125 | MethodHandle mh = insertArguments(VisitorCallSite.VISIT, 0, visitlet, VisitorCallSite.visitor(methodType, map))
126 | .asType(methodType.changeParameterType(0, type))
127 | .asType(methodType);
128 | map.put(type, mh);
129 | return this;
130 | }
131 | });
132 | return VisitorCallSite.visitor(methodType, map);
133 | }
134 | }
135 |
--------------------------------------------------------------------------------
/src/test/java/com.github.forax.exotic/ConstantMemoizerTests.java:
--------------------------------------------------------------------------------
1 | package com.github.forax.exotic;
2 |
3 | import static org.junit.jupiter.api.Assertions.assertEquals;
4 | import static org.junit.jupiter.api.Assertions.assertThrows;
5 |
6 | import java.util.function.Function;
7 | import java.util.function.ToDoubleFunction;
8 | import java.util.function.ToIntFunction;
9 | import java.util.function.ToLongFunction;
10 |
11 | import org.junit.jupiter.api.Test;
12 |
13 | @SuppressWarnings("static-method")
14 | public class ConstantMemoizerTests {
15 | private static final Function OBJECT_FIBO =
16 | ConstantMemoizer.memoizer(n -> objectFibo(n), int.class, int.class);
17 |
18 | private static int objectFibo(int n) {
19 | if (n < 2) {
20 | return 1;
21 | }
22 | return OBJECT_FIBO.apply(n - 2) + OBJECT_FIBO.apply(n - 1);
23 | }
24 |
25 | @Test
26 | public void testObjectRecursive() {
27 | assertEquals(21, (int) OBJECT_FIBO.apply(7));
28 | }
29 |
30 | private static final ToIntFunction INT_FIBO =
31 | ConstantMemoizer.intMemoizer(n -> intFibo(n), int.class);
32 |
33 | private static int intFibo(int n) {
34 | if (n < 2) {
35 | return 1;
36 | }
37 | return INT_FIBO.applyAsInt(n - 2) + INT_FIBO.applyAsInt(n - 1);
38 | }
39 |
40 | @Test
41 | public void testIntRecursive() {
42 | assertEquals(21, INT_FIBO.applyAsInt(7));
43 | }
44 |
45 | private static final ToLongFunction LONG_FIBO =
46 | ConstantMemoizer.longMemoizer(n -> longFibo(n), int.class);
47 |
48 | private static long longFibo(int n) {
49 | if (n < 2) {
50 | return 1L;
51 | }
52 | return LONG_FIBO.applyAsLong(n - 2) + LONG_FIBO.applyAsLong(n - 1);
53 | }
54 |
55 | @Test
56 | public void testLongRecursive() {
57 | assertEquals(21L, LONG_FIBO.applyAsLong(7));
58 | }
59 |
60 | private static final ToDoubleFunction DOUBLE_FIBO =
61 | ConstantMemoizer.doubleMemoizer(n -> doubleFibo(n), int.class);
62 |
63 | private static double doubleFibo(int n) {
64 | if (n < 2) {
65 | return 1.0;
66 | }
67 | return DOUBLE_FIBO.applyAsDouble(n - 2) + DOUBLE_FIBO.applyAsDouble(n - 1);
68 | }
69 |
70 | @Test
71 | public void testDoubleRecursive() {
72 | assertEquals(21.0, DOUBLE_FIBO.applyAsDouble(7));
73 | }
74 |
75 | @Test
76 | public void testObjectSimple() {
77 | Function parseInt =
78 | ConstantMemoizer.memoizer(Integer::parseInt, String.class, int.class);
79 | assertEquals(666, (int) parseInt.apply("666"));
80 | assertEquals(666, (int) parseInt.apply("666"));
81 | }
82 |
83 | @Test
84 | public void testIntSimple() {
85 | ToIntFunction parseInt = ConstantMemoizer.intMemoizer(Integer::parseInt, String.class);
86 | assertEquals(777, parseInt.applyAsInt("777"));
87 | assertEquals(777, parseInt.applyAsInt("777"));
88 | }
89 |
90 | @Test
91 | public void testLongSimple() {
92 | ToLongFunction parseLong = ConstantMemoizer.longMemoizer(Long::parseLong, String.class);
93 | assertEquals(888L, parseLong.applyAsLong("888"));
94 | assertEquals(888L, parseLong.applyAsLong("888"));
95 | }
96 |
97 | @Test
98 | public void testDoubleSimple() {
99 | ToDoubleFunction parseLong =
100 | ConstantMemoizer.doubleMemoizer(Double::parseDouble, String.class);
101 | assertEquals(999.0, parseLong.applyAsDouble("999"));
102 | assertEquals(999.0, parseLong.applyAsDouble("999"));
103 | }
104 |
105 | @Test
106 | public void testObjectArgumentNull() {
107 | Function fun =
108 | ConstantMemoizer.memoizer(x -> x, Integer.class, Integer.class);
109 | assertThrows(NullPointerException.class, () -> fun.apply(null));
110 | }
111 |
112 | @Test
113 | public void testIntArgumentNull() {
114 | ToIntFunction fun = ConstantMemoizer.intMemoizer(x -> x, Integer.class);
115 | assertThrows(NullPointerException.class, () -> fun.applyAsInt(null));
116 | }
117 |
118 | @Test
119 | public void testLongArgumentNull() {
120 | ToLongFunction fun = ConstantMemoizer.longMemoizer(x -> x, Integer.class);
121 | assertThrows(NullPointerException.class, () -> fun.applyAsLong(null));
122 | }
123 |
124 | @Test
125 | public void testDoubleArgumentNull() {
126 | ToDoubleFunction fun = ConstantMemoizer.doubleMemoizer(x -> x, Integer.class);
127 | assertThrows(NullPointerException.class, () -> fun.applyAsDouble(null));
128 | }
129 |
130 | @Test
131 | public void testObjectReturnValueNull() {
132 | Function fun =
133 | ConstantMemoizer.memoizer(x -> null, Integer.class, Integer.class);
134 | assertThrows(NullPointerException.class, () -> fun.apply(3));
135 | }
136 |
137 | @Test
138 | public void testWrongReturnType() {
139 | @SuppressWarnings("unchecked")
140 | Function fun =
141 | ConstantMemoizer.memoizer(
142 | (Function) (Function) x -> x, String.class, Integer.class);
143 | assertThrows(ClassCastException.class, () -> fun.apply("boom !"));
144 | }
145 |
146 | @Test
147 | public void testObjectWrongParameterType() {
148 | @SuppressWarnings("unchecked")
149 | Function fun =
150 | ConstantMemoizer.memoizer(
151 | (Function) (Function) (String x) -> x,
152 | Integer.class,
153 | String.class);
154 | assertThrows(ClassCastException.class, () -> fun.apply(666));
155 | }
156 |
157 | @Test
158 | public void testIntWrongParameterType() {
159 | @SuppressWarnings("unchecked")
160 | ToIntFunction fun =
161 | ConstantMemoizer.intMemoizer(
162 | (ToIntFunction) (ToIntFunction) (String x) -> Integer.parseInt(x),
163 | Integer.class);
164 | assertThrows(ClassCastException.class, () -> fun.applyAsInt(666));
165 | }
166 |
167 | @Test
168 | public void testLongWrongParameterType() {
169 | @SuppressWarnings("unchecked")
170 | ToLongFunction fun =
171 | ConstantMemoizer.longMemoizer(
172 | (ToLongFunction) (ToLongFunction) (String x) -> Long.parseLong(x),
173 | Integer.class);
174 | assertThrows(ClassCastException.class, () -> fun.applyAsLong(666));
175 | }
176 |
177 | @Test
178 | public void testDoubleWrongParameterType() {
179 | @SuppressWarnings("unchecked")
180 | ToDoubleFunction fun =
181 | ConstantMemoizer.doubleMemoizer(
182 | (ToDoubleFunction) (ToDoubleFunction) (String x) -> Double.parseDouble(x),
183 | Integer.class);
184 | assertThrows(ClassCastException.class, () -> fun.applyAsDouble(666));
185 | }
186 | }
187 |
--------------------------------------------------------------------------------
/src/main/java/com.github.forax.exotic/MostlyConstant.java:
--------------------------------------------------------------------------------
1 | package com.github.forax.exotic;
2 |
3 | import static java.lang.invoke.MethodHandles.constant;
4 |
5 | import java.lang.invoke.MethodHandle;
6 | import java.lang.invoke.MutableCallSite;
7 | import java.util.Objects;
8 | import java.util.function.DoubleSupplier;
9 | import java.util.function.IntSupplier;
10 | import java.util.function.LongSupplier;
11 | import java.util.function.Supplier;
12 |
13 | /**
14 | * Create a constant value that can be changed from time to time. If the {@link #getter()} is stored
15 | * in a static final field, the result of the supplier is guaranteed to be seen as a constant by the
16 | * Virtual Machine.
17 | *
18 | * To avoid unnecessary boxing in common cases of constant of type {@code int}, {@code long} and
19 | * {@code double}, there are specialized version of the {@link #getter()}, {@link #intGetter()},
20 | * {@link #longGetter()} and {@link #doubleGetter()}.
21 | *
22 | *
This work because when {@link #setAndDeoptimize(Object)} is called, all the assembly code
23 | * (JITed code) that where containing the constant are de-optimized and in the future they will be
24 | * re-optimized with the new value of the constant. So calling {@link #setAndDeoptimize(Object)} in
25 | * a loop will kill performance.
26 | *
27 | *
Example of usage
28 | *
29 | *
30 | * private static final MostlyConstant<Integer> FOO = new MostlyConstant<>(42, int.class);
31 | * private static final IntSupplier FOO_GETTER = FOO.intGetter();
32 | *
33 | * public static int getFoo() {
34 | * return FOO_GETTER.getAsInt();
35 | * }
36 | * public static void setFoo(int value) {
37 | * FOO.setAndDeoptimize(value);
38 | * }
39 | *
40 | *
41 | * @param the type of the constant.
42 | */
43 | public final class MostlyConstant {
44 | private final Class type;
45 | private final MutableCallSite callSite;
46 | private final MethodHandle invoker;
47 |
48 | /**
49 | * Create a constant with a value ({@code constant}) and its class ({@code type}).
50 | *
51 | * @param constant the value of the constant.
52 | * @param type the class of the constant.
53 | * @throws NullPointerException if type is null.
54 | * @throws ClassCastException if the constant cannot be converted to the type
55 | * @throws IllegalArgumentException is type is void.class
56 | */
57 | public MostlyConstant(T constant, Class type) {
58 | this.type = Objects.requireNonNull(type);
59 | MethodHandle target = constant(type, constant);
60 | MutableCallSite callSite = new MutableCallSite(target.asType(target.type().erase()));
61 | this.callSite = callSite;
62 | this.invoker = callSite.dynamicInvoker();
63 | }
64 |
65 | /**
66 | * Change the value of the constant. This call requires the VM to de-optimize all the assembly
67 | * codes that contains the previous value of this constant, so this call will slow down the
68 | * application. Use this method with care, you have been warned.
69 | *
70 | * @param constant the new value of the constant.
71 | * @throws ClassCastException if the constant cannot be converted to constant type.
72 | */
73 | public void setAndDeoptimize(T constant) {
74 | MethodHandle target = constant(type, constant);
75 | callSite.setTarget(target.asType(callSite.type()));
76 | MutableCallSite.syncAll(new MutableCallSite[] { callSite });
77 | }
78 |
79 | /**
80 | * Returns a supplier that will return the value of this constant as a constant value. The
81 | * returned supplier should be stored in a static field for performance.
82 | *
83 | * @return a supplier that will return the value of this constant as a constant value.
84 | * @see MostlyConstant#intGetter()
85 | * @see MostlyConstant#longGetter()
86 | * @see MostlyConstant#doubleGetter()
87 | */
88 | public Supplier getter() {
89 | MethodHandle invoker = this.invoker;
90 | return () -> {
91 | try {
92 | return (T) invoker.invokeExact();
93 | } catch (Throwable e) {
94 | throw Thrower.rethrow(e);
95 | }
96 | };
97 | /*return new Supplier<>() {
98 | @Override
99 | public T get() {
100 | try {
101 | return (T)invoker.invokeExact();
102 | } catch (Throwable e) {
103 | throw Thrower.rethrow(e);
104 | }
105 | }
106 | };*/
107 | }
108 |
109 | /**
110 | * Returns a supplier that will return the value of this constant as a constant value. The
111 | * returned supplier should be stored in a static field for performance.
112 | *
113 | * @return a supplier that will return the value of this constant as a constant value.
114 | * @throws IllegalStateException if the constant is not of type {@code int.class}.
115 | * @see MostlyConstant#getter()
116 | */
117 | public IntSupplier intGetter() {
118 | if (callSite.type().returnType() != int.class) {
119 | throw new IllegalStateException("the constant is not of type int.class");
120 | }
121 | MethodHandle invoker = this.invoker;
122 | return () -> {
123 | try {
124 | return (int) invoker.invokeExact();
125 | } catch (Throwable e) {
126 | throw Thrower.rethrow(e);
127 | }
128 | };
129 | }
130 |
131 | /**
132 | * Returns a supplier that will return the value of this constant as a constant value. The
133 | * returned supplier should be stored in a static field for performance.
134 | *
135 | * @return a supplier that will return the value of this constant as a constant value.
136 | * @throws IllegalStateException if the constant is not of type {@code long.class}.
137 | * @see MostlyConstant#getter()
138 | */
139 | public LongSupplier longGetter() {
140 | if (callSite.type().returnType() != long.class) {
141 | throw new IllegalStateException("the constant is not of type long.class");
142 | }
143 | MethodHandle invoker = this.invoker;
144 | return () -> {
145 | try {
146 | return (long) invoker.invokeExact();
147 | } catch (Throwable e) {
148 | throw Thrower.rethrow(e);
149 | }
150 | };
151 | }
152 |
153 | /**
154 | * Returns a supplier that will return the value of this constant as a constant value. The
155 | * returned supplier should be stored in a static field for performance.
156 | *
157 | * @return a supplier that will return the value of this constant as a constant value.
158 | * @throws IllegalStateException if the constant is not of type {@code double.class}.
159 | * @see MostlyConstant#getter()
160 | */
161 | public DoubleSupplier doubleGetter() {
162 | if (callSite.type().returnType() != double.class) {
163 | throw new IllegalStateException("the constant is not of type double.class");
164 | }
165 | MethodHandle invoker = this.invoker;
166 | return () -> {
167 | try {
168 | return (double) invoker.invokeExact();
169 | } catch (Throwable e) {
170 | throw Thrower.rethrow(e);
171 | }
172 | };
173 | }
174 | }
175 |
--------------------------------------------------------------------------------
/src/test/java/com.github.forax.exotic/perf/VisitorBenchMark.java:
--------------------------------------------------------------------------------
1 | package com.github.forax.exotic.perf;
2 |
3 | import java.util.HashMap;
4 | import java.util.List;
5 | import java.util.concurrent.TimeUnit;
6 | import java.util.function.BiFunction;
7 |
8 | import org.openjdk.jmh.annotations.Benchmark;
9 | import org.openjdk.jmh.annotations.BenchmarkMode;
10 | import org.openjdk.jmh.annotations.Fork;
11 | import org.openjdk.jmh.annotations.Measurement;
12 | import org.openjdk.jmh.annotations.Mode;
13 | import org.openjdk.jmh.annotations.OutputTimeUnit;
14 | import org.openjdk.jmh.annotations.Scope;
15 | import org.openjdk.jmh.annotations.State;
16 | import org.openjdk.jmh.annotations.Warmup;
17 | import org.openjdk.jmh.runner.Runner;
18 | import org.openjdk.jmh.runner.RunnerException;
19 | import org.openjdk.jmh.runner.options.Options;
20 | import org.openjdk.jmh.runner.options.OptionsBuilder;
21 |
22 | import com.github.forax.exotic.Visitor;
23 |
24 | @Warmup(iterations = 5, time = 3, timeUnit = TimeUnit.SECONDS)
25 | @Measurement(iterations = 5, time = 3, timeUnit = TimeUnit.SECONDS)
26 | @Fork(3)
27 | @BenchmarkMode(Mode.AverageTime)
28 | @OutputTimeUnit(TimeUnit.NANOSECONDS)
29 | @State(Scope.Benchmark)
30 | public class VisitorBenchMark {
31 |
32 | interface Expr {
33 | R accept(GofVisitor visitor, P parameter);
34 | }
35 | static class Value implements Expr {
36 | final int value; Value(int value) { this.value = value; }
37 | @Override
38 | public R accept(GofVisitor visitor, P parameter) {
39 | return visitor.visitValue(this, parameter);
40 | }
41 | }
42 | static class Add implements Expr {
43 | final Expr left, right; Add(Expr left, Expr right) { this.left = left; this.right = right; }
44 | @Override
45 | public R accept(GofVisitor visitor, P parameter) {
46 | return visitor.visitAdd(this, parameter);
47 | }
48 | }
49 | static class Var implements Expr {
50 | final String name; Var(String name) { this.name = name; }
51 | @Override
52 | public R accept(GofVisitor visitor, P parameter) {
53 | return visitor.visitVar(this, parameter);
54 | }
55 | }
56 | static class Assign implements Expr {
57 | final String name; final Expr expr; Assign(String name, Expr expr) { this.name = name; this.expr = expr; }
58 | @Override
59 | public R accept(GofVisitor visitor, P parameter) {
60 | return visitor.visitAssign(this, parameter);
61 | }
62 | }
63 | static class Block implements Expr {
64 | final List exprs; Block(List exprs) { this.exprs = exprs; }
65 | @Override
66 | public R accept(GofVisitor visitor, P parameter) {
67 | return visitor.visitBlock(this, parameter);
68 | }
69 | }
70 |
71 | interface GofVisitor {
72 | R visitValue(Value value, P parameter);
73 | R visitAdd(Add add, P parameter);
74 | R visitVar(Var var, P parameter);
75 | R visitAssign(Assign assign, P parameter);
76 | R visitBlock(Block block, P parameter);
77 | }
78 |
79 | static class MapVisitor {
80 | private final HashMap, BiFunction> map = new HashMap<>();
81 |
82 | @SuppressWarnings("unchecked")
83 | public MapVisitor register(Class type, BiFunction fun) {
84 | map.put(type, (BiFunction)fun);
85 | return this;
86 | }
87 |
88 | public R visit(Object expr, P parameter) {
89 | return map.getOrDefault(expr.getClass(), (_1, _2) -> { throw new IllegalStateException(); }).apply(expr, parameter);
90 | }
91 | }
92 |
93 | class Env {
94 | final HashMap vars = new HashMap<>();
95 | }
96 |
97 | private static final Expr CODE = new Block(List.of(
98 | new Assign("c", new Block(List.of(
99 | new Assign("a", new Value(20)),
100 | new Var("e"),
101 | new Assign("b", new Add(new Value(5), new Var("c"))),
102 | new Assign("d", new Var("b")),
103 | new Add(new Add(new Var("a"), new Value(11)), new Var("d"))
104 | ))
105 | ),
106 | new Add(new Value(2), new Var("b"))
107 | ));
108 |
109 | private static final Visitor EXOTIC_VISITOR = Visitor.create(Env.class, int.class, opt -> opt
110 | .register(Value.class, (v, value, env) -> value.value)
111 | .register(Add.class, (v, add, env) -> v.visit(add.left, env) + v.visit(add.right, env))
112 | .register(Var.class, (v, var, env) -> env.vars.getOrDefault(var.name, 0))
113 | .register(Assign.class, (v, assign, env) -> { int let = v.visit(assign.expr, env); env.vars.put(assign.name, let); return let; })
114 | .register(Block.class, (v, block, env) -> { int result = 0; for(Expr expr: block.exprs) { result = v.visit(expr, env); } return result; })
115 | );
116 |
117 | private static final GofVisitor GOF_VISITOR = new GofVisitor<>() {
118 | @Override
119 | public Integer visitValue(Value value, Env env) { return value.value; }
120 | @Override
121 | public Integer visitAdd(Add add, Env env) { return add.left.accept(this, env) + add.right.accept(this, env); }
122 | @Override
123 | public Integer visitVar(Var var, Env env) { return env.vars.getOrDefault(var.name, 0); }
124 | @Override
125 | public Integer visitAssign(Assign assign, Env env) { int let = assign.expr.accept(this, env); env.vars.put(assign.name, let); return let; }
126 | @Override
127 | public Integer visitBlock(Block block, Env env) { int result = 0; for(Expr expr: block.exprs) { result = expr.accept(this, env); } return result; }
128 | };
129 |
130 | private static final MapVisitor MAP_VISITOR = new MapVisitor<>();
131 | static {
132 | MAP_VISITOR.register(Value.class, (value, env) -> value.value)
133 | .register(Add.class, (add, env) -> MAP_VISITOR.visit(add.left, env) + MAP_VISITOR.visit(add.right, env))
134 | .register(Var.class, (var, env) -> env.vars.getOrDefault(var.name, 0))
135 | .register(Assign.class, (assign, env) -> { int let = MAP_VISITOR.visit(assign.expr, env); env.vars.put(assign.name, let); return let; })
136 | .register(Block.class, (block, env) -> { int result = 0; for(Expr expr: block.exprs) { result = MAP_VISITOR.visit(expr, env); } return result; });
137 | }
138 |
139 |
140 | @Benchmark
141 | public int map_visitor() {
142 | return MAP_VISITOR.visit(CODE, new Env());
143 | }
144 |
145 | @Benchmark
146 | public int exotic_visitor() {
147 | return EXOTIC_VISITOR.visit(CODE, new Env());
148 | }
149 |
150 | @Benchmark
151 | public int gof_visitor() {
152 | return CODE.accept(GOF_VISITOR, new Env());
153 | }
154 |
155 |
156 | public static void main(String[] args) throws RunnerException {
157 | Options opt = new OptionsBuilder().include(VisitorBenchMark.class.getName()).build();
158 | new Runner(opt).run();
159 | }
160 | }
161 |
--------------------------------------------------------------------------------
/src/test/java/com.github.forax.exotic/perf/StringSwitchBenchMark.java:
--------------------------------------------------------------------------------
1 | package com.github.forax.exotic.perf;
2 |
3 | import java.util.concurrent.TimeUnit;
4 | import java.util.stream.Stream;
5 |
6 | import org.openjdk.jmh.annotations.Benchmark;
7 | import org.openjdk.jmh.annotations.BenchmarkMode;
8 | import org.openjdk.jmh.annotations.Fork;
9 | import org.openjdk.jmh.annotations.Measurement;
10 | import org.openjdk.jmh.annotations.Mode;
11 | import org.openjdk.jmh.annotations.OutputTimeUnit;
12 | import org.openjdk.jmh.annotations.Scope;
13 | import org.openjdk.jmh.annotations.State;
14 | import org.openjdk.jmh.annotations.Warmup;
15 | import org.openjdk.jmh.runner.Runner;
16 | import org.openjdk.jmh.runner.RunnerException;
17 | import org.openjdk.jmh.runner.options.Options;
18 | import org.openjdk.jmh.runner.options.OptionsBuilder;
19 |
20 | import com.github.forax.exotic.StringSwitch;
21 |
22 | @SuppressWarnings("static-method")
23 | @Warmup(iterations = 5, time = 2, timeUnit = TimeUnit.SECONDS)
24 | @Measurement(iterations = 5, time = 2, timeUnit = TimeUnit.SECONDS)
25 | @Fork(3)
26 | @BenchmarkMode(Mode.AverageTime)
27 | @OutputTimeUnit(TimeUnit.NANOSECONDS)
28 | @State(Scope.Benchmark)
29 | public class StringSwitchBenchMark {
30 | private static final StringSwitch SMALL_STRING_SWITCH = StringSwitch.create(false,
31 | "elephant", "girafe", "springbok", "monkey"/*, "snake", "crocodile", "orangoutang", "opossum", "tiger", "hippopotamus", "koala" */);
32 |
33 | private static final StringSwitch BIG_STRING_SWITCH = StringSwitch.create(false,
34 | "elephant", "girafe", "springbok", "monkey", "snake", "crocodile", "orangoutang", "opossum", "tiger", "hippopotamus", "koala");
35 |
36 | private static final String[] DATA = Stream.of(
37 | "lion", "elephant", "springbok", "elephant", "girafe", "snake", "crocodile", "elephant", "monkey",
38 | "girafe", "hippopotamus", "opossum", "elephant", "girafe", "snake", "opossum", "lion", "tiger", "snake", "koala")
39 | .map(String::new)
40 | .toArray(String[]::new);
41 |
42 | @Benchmark
43 | public int small_small_string_switch() {
44 | int sum = 0;
45 | for(int i = 0; i < 4; i++) {
46 | String s = DATA[i];
47 | sum += SMALL_STRING_SWITCH.stringSwitch(s);
48 | }
49 | return sum;
50 | }
51 |
52 | @Benchmark
53 | public int small_small_ifequals_cascade() {
54 | int sum = 0;
55 | for(int i = 0; i < 4; i++) {
56 | String s = DATA[i];
57 | int value;
58 | if (s.equals("elephant")) { value = 0; }
59 | else if (s.equals("girafe")) { value = 1; }
60 | else if (s.equals("springbok")) { value = 2; }
61 | else if (s.equals("monkey")) { value = 3; }
62 | else { value = StringSwitch.NO_MATCH; }
63 | sum += value;
64 | }
65 | return sum;
66 | }
67 |
68 | @Benchmark
69 | public int small_small_oldswitch() {
70 | int sum = 0;
71 | for(int i = 0; i < 4; i++) {
72 | String s = DATA[i];
73 | int value;
74 | switch(s) {
75 | case "elephant":
76 | value = 0;
77 | break;
78 | case "girafe":
79 | value = 1;
80 | break;
81 | case "springbok":
82 | value = 2;
83 | break;
84 | case "monkey":
85 | value = 3;
86 | break;
87 | default:
88 | value = StringSwitch.NO_MATCH;
89 | }
90 | sum += value;
91 | }
92 | return sum;
93 | }
94 |
95 | /*@Benchmark
96 | public int small_big_string_switch() {
97 | int sum = 0;
98 | for(String s: DATA) {
99 | sum += SMALL_STRING_SWITCH.stringSwitch(s);
100 | }
101 | return sum;
102 | }
103 |
104 | @Benchmark
105 | public int small_big_ifequals_cascade() {
106 | int sum = 0;
107 | for(int i = 0; i < 4; i++) {
108 | String s = DATA[i];
109 | int value;
110 | if (s.equals("elephant")) { value = 0; }
111 | else if (s.equals("girafe")) { value = 1; }
112 | else if (s.equals("springbok")) { value = 2; }
113 | else if (s.equals("monkey")) { value = 3; }
114 | else { value = StringSwitch.NO_MATCH; }
115 | sum += value;
116 | }
117 | return sum;
118 | }
119 |
120 | @Benchmark
121 | public int small_big_oldswitch() {
122 | int sum = 0;
123 | for(String s: DATA) {
124 | int value;
125 | switch(s) {
126 | case "elephant":
127 | value = 0;
128 | break;
129 | case "girafe":
130 | value = 1;
131 | break;
132 | case "springbok":
133 | value = 2;
134 | break;
135 | case "monkey":
136 | value = 3;
137 | break;
138 | default:
139 | value = StringSwitch.NO_MATCH;
140 | }
141 | sum += value;
142 | }
143 | return sum;
144 | }*/
145 |
146 | @Benchmark
147 | public int big_big_string_switch() {
148 | int sum = 0;
149 | for(String s: DATA) {
150 | sum += BIG_STRING_SWITCH.stringSwitch(s);
151 | }
152 | return sum;
153 | }
154 |
155 | @Benchmark
156 | public int big_big_ifequals_cascade() {
157 | int sum = 0;
158 | for(int i = 0; i < 4; i++) {
159 | String s = DATA[i];
160 | int value;
161 | if (s.equals("elephant")) { value = 0; }
162 | else if (s.equals("girafe")) { value = 1; }
163 | else if (s.equals("springbok")) { value = 2; }
164 | else if (s.equals("monkey")) { value = 3; }
165 | else if (s.equals("snake")) { value = 4; }
166 | else if (s.equals("crocodile")) { value = 5; }
167 | else if (s.equals("orangoutang")) { value = 6; }
168 | else if (s.equals("opossum")) { value = 7; }
169 | else if (s.equals("tiger")) { value = 8; }
170 | else if (s.equals("hippopotamus")) { value = 9; }
171 | else if (s.equals("koala")) { value = 10; }
172 | else { value = StringSwitch.NO_MATCH; }
173 | sum += value;
174 | }
175 | return sum;
176 | }
177 |
178 | @Benchmark
179 | public int big_big_oldswitch() {
180 | int sum = 0;
181 | for(String s: DATA) {
182 | int value;
183 | switch(s) {
184 | case "elephant":
185 | value = 0;
186 | break;
187 | case "girafe":
188 | value = 1;
189 | break;
190 | case "springbok":
191 | value = 2;
192 | break;
193 | case "monkey":
194 | value = 3;
195 | break;
196 | case "snake":
197 | value = 4;
198 | break;
199 | case "crocodile":
200 | value = 5;
201 | break;
202 | case "orangoutang":
203 | value = 6;
204 | break;
205 | case "opossum":
206 | value = 7;
207 | break;
208 | case "tiger":
209 | value = 8;
210 | break;
211 | case "hippopotamus":
212 | value = 9;
213 | break;
214 | case "koala":
215 | value = 10;
216 | break;
217 | default:
218 | value = StringSwitch.NO_MATCH;
219 | }
220 | sum += value;
221 | }
222 | return sum;
223 | }
224 |
225 | public static void main(String[] args) throws RunnerException {
226 | Options opt = new OptionsBuilder().include(StringSwitchBenchMark.class.getName()).build();
227 | new Runner(opt).run();
228 | }
229 | }
230 |
--------------------------------------------------------------------------------
/src/main/java/com.github.forax.exotic/StructuralCallImpl.java:
--------------------------------------------------------------------------------
1 | package com.github.forax.exotic;
2 |
3 | import static java.lang.invoke.MethodHandles.dropArguments;
4 | import static java.lang.invoke.MethodHandles.guardWithTest;
5 | import static java.lang.invoke.MethodHandles.insertArguments;
6 | import static java.lang.invoke.MethodType.genericMethodType;
7 | import static java.lang.invoke.MethodType.methodType;
8 | import static java.util.Collections.nCopies;
9 |
10 | import java.lang.invoke.MethodHandle;
11 | import java.lang.invoke.MethodHandles;
12 | import java.lang.invoke.MethodHandles.Lookup;
13 | import java.lang.invoke.MethodType;
14 | import java.lang.invoke.MutableCallSite;
15 | import java.util.ArrayDeque;
16 | import java.util.Objects;
17 |
18 | interface StructuralCallImpl extends StructuralCall {
19 | @Override
20 | @SuppressWarnings("unchecked")
21 | default R invoke(Object receiver) {
22 | return (R) call(1, receiver, null, null, null, null, null, null, null, null);
23 | }
24 |
25 | @Override
26 | @SuppressWarnings("unchecked")
27 | default R invoke(Object receiver, Object arg1) {
28 | return (R) call(2, receiver, arg1, null, null, null, null, null, null, null);
29 | }
30 |
31 | @Override
32 | @SuppressWarnings("unchecked")
33 | default R invoke(Object receiver, Object arg1, Object arg2) {
34 | return (R) call(3, receiver, arg1, arg2, null, null, null, null, null, null);
35 | }
36 |
37 | @Override
38 | @SuppressWarnings("unchecked")
39 | default R invoke(Object receiver, Object arg1, Object arg2, Object arg3) {
40 | return (R) call(4, receiver, arg1, arg2, arg3, null, null, null, null, null);
41 | }
42 |
43 | @Override
44 | @SuppressWarnings("unchecked")
45 | default R invoke(Object receiver, Object arg1, Object arg2, Object arg3, Object arg4) {
46 | return (R) call(5, receiver, arg1, arg2, arg3, arg4, null, null, null, null);
47 | }
48 |
49 | @Override
50 | @SuppressWarnings("unchecked")
51 | default R invoke(
52 | Object receiver, Object arg1, Object arg2, Object arg3, Object arg4, Object arg5) {
53 | return (R) call(6, receiver, arg1, arg2, arg3, arg4, arg5, null, null, null);
54 | }
55 |
56 | @Override
57 | @SuppressWarnings("unchecked")
58 | default R invoke(
59 | Object receiver,
60 | Object arg1,
61 | Object arg2,
62 | Object arg3,
63 | Object arg4,
64 | Object arg5,
65 | Object arg6) {
66 | return (R) call(7, receiver, arg1, arg2, arg3, arg4, arg5, arg6, null, null);
67 | }
68 |
69 | @Override
70 | @SuppressWarnings("unchecked")
71 | default R invoke(
72 | Object receiver,
73 | Object arg1,
74 | Object arg2,
75 | Object arg3,
76 | Object arg4,
77 | Object arg5,
78 | Object arg6,
79 | Object arg7) {
80 | return (R) call(8, receiver, arg1, arg2, arg3, arg4, arg5, arg6, arg7, null);
81 | }
82 |
83 | @Override
84 | @SuppressWarnings("unchecked")
85 | default R invoke(
86 | Object receiver,
87 | Object arg1,
88 | Object arg2,
89 | Object arg3,
90 | Object arg4,
91 | Object arg5,
92 | Object arg6,
93 | Object arg7,
94 | Object arg8) {
95 | return (R) call(9, receiver, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
96 | }
97 |
98 | Object call(
99 | int argCount,
100 | Object receiver,
101 | Object arg1,
102 | Object arg2,
103 | Object arg3,
104 | Object arg4,
105 | Object arg5,
106 | Object arg6,
107 | Object arg7,
108 | Object arg8);
109 |
110 | static MethodHandle findMethodHandle(Lookup lookup, String name, MethodType type) {
111 | Objects.requireNonNull(lookup);
112 | Objects.requireNonNull(name);
113 | Objects.requireNonNull(type);
114 | MethodHandle mh =
115 | new InliningCacheCallSite(type.insertParameterTypes(0, Object.class), lookup, name)
116 | .dynamicInvoker();
117 | int parameterCount = mh.type().parameterCount();
118 | if (parameterCount != 9) {
119 | mh = dropArguments(mh, parameterCount, nCopies(9 - parameterCount, Object.class));
120 | }
121 | mh = mh.asType(genericMethodType(9));
122 |
123 | // check that parameterCount == argCount
124 | MethodHandle guard =
125 | guardWithTest(
126 | insertArguments(InliningCacheCallSite.COUNTCHECK, 0, parameterCount),
127 | dropArguments(mh, 0, int.class),
128 | dropArguments(InliningCacheCallSite.ERRORCOUNT, 1, mh.type().parameterList()));
129 | return guard;
130 | }
131 |
132 | class InliningCacheCallSite extends MutableCallSite {
133 | private static final MethodHandle FALLBACK, TYPECHECK;
134 | static final MethodHandle COUNTCHECK, ERRORCOUNT;
135 |
136 | static {
137 | Lookup lookup = MethodHandles.lookup();
138 | try {
139 | FALLBACK =
140 | lookup.findVirtual(
141 | InliningCacheCallSite.class,
142 | "fallback",
143 | methodType(MethodHandle.class, Object.class));
144 | TYPECHECK =
145 | lookup.findStatic(
146 | InliningCacheCallSite.class,
147 | "typecheck",
148 | methodType(boolean.class, Class.class, Object.class));
149 | COUNTCHECK =
150 | lookup.findStatic(
151 | InliningCacheCallSite.class,
152 | "countcheck",
153 | methodType(boolean.class, int.class, int.class));
154 | ERRORCOUNT =
155 | lookup.findStatic(
156 | InliningCacheCallSite.class, "errorcount", methodType(Object.class, int.class));
157 | } catch (NoSuchMethodException | IllegalAccessException e) {
158 | throw new AssertionError(e);
159 | }
160 | }
161 |
162 | private final Lookup lookup;
163 | private final String name;
164 |
165 | InliningCacheCallSite(MethodType type, Lookup lookup, String name) {
166 | super(type);
167 | this.lookup = lookup;
168 | this.name = name;
169 | setTarget(
170 | MethodHandles.foldArguments(MethodHandles.exactInvoker(type), FALLBACK.bindTo(this)));
171 | }
172 |
173 | @SuppressWarnings("unused")
174 | private MethodHandle fallback(Object receiver) {
175 | Class receiverClass = receiver.getClass();
176 | MethodHandle target;
177 | try {
178 | target = findTarget(lookup, receiverClass, name, type().dropParameterTypes(0, 1));
179 | } catch (NoSuchMethodException e) {
180 | throw (NoSuchMethodError) new NoSuchMethodError().initCause(e);
181 | } catch (IllegalAccessException e) {
182 | throw (IllegalAccessError) new IllegalAccessError().initCause(e);
183 | }
184 |
185 | target = target.asType(type());
186 | MethodHandle guard =
187 | MethodHandles.guardWithTest(
188 | TYPECHECK.bindTo(receiverClass),
189 | target,
190 | new InliningCacheCallSite(type(), lookup, name).dynamicInvoker());
191 | setTarget(guard);
192 | return target;
193 | }
194 |
195 | private static MethodHandle findTarget(
196 | Lookup lookup, Class receiverClass, String name, MethodType parameterType)
197 | throws IllegalAccessException, NoSuchMethodException {
198 | ArrayDeque> queue = new ArrayDeque<>();
199 | queue.add(receiverClass);
200 |
201 | Class type;
202 | IllegalAccessException illegalAccess = null;
203 | while ((type = queue.poll()) != null) {
204 | try {
205 | return lookup.findVirtual(type, name, parameterType);
206 | } catch (NoSuchMethodException e) {
207 | if (illegalAccess == null) {
208 | throw e;
209 | }
210 | } catch (IllegalAccessException e) {
211 | if (illegalAccess == null) {
212 | illegalAccess = e;
213 | }
214 |
215 | // try super types
216 | queue.add(type.getSuperclass());
217 | for (Class interfaze : type.getInterfaces()) {
218 | queue.add(interfaze);
219 | }
220 | }
221 | }
222 | assert illegalAccess != null;
223 | throw illegalAccess;
224 | }
225 |
226 | @SuppressWarnings("unused")
227 | private static boolean typecheck(Class type, Object o) {
228 | return o.getClass() == type;
229 | }
230 |
231 | @SuppressWarnings("unused")
232 | private static boolean countcheck(int parameterCount, int argumentCount) {
233 | return parameterCount == argumentCount;
234 | }
235 |
236 | @SuppressWarnings("unused")
237 | private static Object errorcount(int argumentCount) {
238 | throw new IllegalArgumentException("wrong number of argument " + argumentCount);
239 | }
240 | }
241 | }
242 |
--------------------------------------------------------------------------------
/src/main/java/com.github.forax.exotic/TypeSwitchCallSite.java:
--------------------------------------------------------------------------------
1 | package com.github.forax.exotic;
2 |
3 | import static java.lang.invoke.MethodHandles.constant;
4 | import static java.lang.invoke.MethodHandles.dropArguments;
5 | import static java.lang.invoke.MethodHandles.guardWithTest;
6 | import static java.lang.invoke.MethodType.methodType;
7 |
8 | import java.lang.invoke.MethodHandle;
9 | import java.lang.invoke.MethodHandles;
10 | import java.lang.invoke.MethodHandles.Lookup;
11 | import java.lang.invoke.MethodType;
12 | import java.lang.invoke.MutableCallSite;
13 | import java.lang.ref.WeakReference;
14 | import java.util.HashMap;
15 | import java.util.Objects;
16 |
17 | class TypeSwitchCallSite extends MutableCallSite {
18 | static void validatePartialOrder(Class[] typecases) {
19 | int length = typecases.length;
20 | if (length == 0 || length == 1) {
21 | return;
22 | }
23 | HashMap, Class> map = new HashMap<>(); //FIXME pre-size ??
24 | for (int i = length; --i >= 0;) {
25 | Class typecase = typecases[i];
26 | Objects.requireNonNull(typecase);
27 | validateType(map, typecase);
28 | }
29 | }
30 |
31 | private static void validateType(HashMap, Class> map, Class typecase) {
32 | Class conflictingCaseType = map.putIfAbsent(typecase, typecase);
33 | if (conflictingCaseType != null) {
34 | throw new IllegalStateException(
35 | "Case " + conflictingCaseType.getName() + " matches a subtype of what case " +
36 | typecase.getName() + " matches but is located after it");
37 | }
38 | validateSupertypes(map, typecase, typecase);
39 | }
40 |
41 | private static void validateSupertypes(HashMap, Class> map, Class type, Class typecase) {
42 | Class superclass = type.getSuperclass();
43 | if (superclass == null && type != Object.class) {
44 | superclass = Object.class; // interfaces are subtypes of Object
45 | }
46 | if (superclass != null && map.putIfAbsent(superclass, typecase) == null) {
47 | validateSupertypes(map, superclass, typecase);
48 | }
49 | for (Class superinterface : type.getInterfaces()) {
50 | if (map.putIfAbsent(superinterface, typecase) == null) {
51 | validateSupertypes(map, superinterface, typecase);
52 | }
53 | }
54 | }
55 |
56 | private interface Strategy {
57 | int index(Class receiverClass);
58 | MethodHandle target();
59 |
60 | static Strategy isInstance(Class[] typecases) {
61 | WeakReference>[] refs = createRefArray(typecases);
62 | return new Strategy() {
63 | @Override
64 | public int index(Class receiverClass) {
65 | for(int i = 0; i < refs.length; i++) {
66 | Class typecase = refs[i].get();
67 | if (typecase != null && typecase.isAssignableFrom(receiverClass)) {
68 | return i;
69 | }
70 | }
71 | return TypeSwitch.NO_MATCH;
72 | }
73 | @Override
74 | public MethodHandle target() {
75 | MethodHandle mh = dropArguments(constant(int.class, TypeSwitch.NO_MATCH), 0, Object.class);
76 | for(int i = refs.length; --i >= 0;) {
77 | Class typecase = refs[i].get();
78 | if (typecase == null) {
79 | continue;
80 | }
81 | mh = guardWithTest(IS_INSTANCE.bindTo(typecase),
82 | dropArguments(constant(int.class, i), 0, Object.class),
83 | mh);
84 | }
85 | return mh;
86 | }
87 | };
88 | }
89 |
90 | static Strategy classValue(Class[] typecases) {
91 | ClassValue classValue = createClassValue(typecases);
92 | return new Strategy() {
93 | @Override
94 | public int index(Class receiverClass) {
95 | return classValue.get(receiverClass);
96 | }
97 | @Override
98 | public MethodHandle target(/*Lookup lookup*/) {
99 | return GET.bindTo(classValue);
100 | }
101 | };
102 | }
103 | }
104 |
105 | static WeakReference>[] createRefArray(Class[] typecases) {
106 | @SuppressWarnings("unchecked")
107 | WeakReference>[] refs = (WeakReference>[])new WeakReference[typecases.length];
108 | for(int i = 0; i < typecases.length; i++) {
109 | refs[i] = new WeakReference<>(typecases[i]);
110 | }
111 | return refs;
112 | }
113 |
114 | static ClassValue createClassValue(Class[] typecases) {
115 | ThreadLocal local = new ThreadLocal<>();
116 | ClassValue classValue = new ClassValue() {
117 | @Override
118 | protected Integer computeValue(Class type) {
119 | Integer index = local.get();
120 | if (index != null) { // injection
121 | return index;
122 | }
123 | return computeFromSupertypes(type);
124 | }
125 |
126 | private Integer computeFromSupertypes(Class type) {
127 | int index = TypeSwitch.NO_MATCH;
128 | Class superclass = type.getSuperclass();
129 | if (superclass != null) {
130 | index = get(superclass);
131 | }
132 | for(Class supertype: type.getInterfaces()) {
133 | int localIndex = get(supertype);
134 | if (localIndex != TypeSwitch.NO_MATCH) {
135 | index = (index == TypeSwitch.NO_MATCH)? localIndex: Math.min(index, localIndex);
136 | }
137 | }
138 | return index;
139 | }
140 | };
141 | for(int i = 0; i < typecases.length; i++) {
142 | local.set(i); // inject value
143 | classValue.get(typecases[i]);
144 | }
145 | local.set(null); // no injection anymore
146 | return classValue;
147 | }
148 |
149 |
150 | private static final MethodType OBJECT_TO_INT = methodType(int.class, Object.class);
151 | private static final MethodHandle FALLBACK, TYPECHECK, NULLCHECK;
152 | static final MethodHandle GET, IS_INSTANCE;
153 | static {
154 | Lookup lookup = MethodHandles.lookup();
155 | try {
156 | FALLBACK = lookup.findVirtual(TypeSwitchCallSite.class, "fallback", OBJECT_TO_INT);
157 | TYPECHECK = lookup.findStatic(TypeSwitchCallSite.class, "typecheck", methodType(boolean.class, Class.class, Object.class));
158 | GET = lookup.findStatic(TypeSwitchCallSite.class, "get", methodType(int.class, ClassValue.class, Object.class));
159 | NULLCHECK = lookup.findStatic(Objects.class, "isNull", methodType(boolean.class, Object.class));
160 | IS_INSTANCE = lookup.findVirtual(Class.class, "isInstance", methodType(boolean.class, Object.class));
161 | } catch(NoSuchMethodException | IllegalAccessException e) {
162 | throw new AssertionError(e);
163 | }
164 | }
165 |
166 | private static final int MAX_DEPTH = 8;
167 | private static final int STRATEGY_CUT_OFF = 5;
168 |
169 | private final int depth;
170 | private final TypeSwitchCallSite callsite;
171 | private final Strategy strategy;
172 |
173 | private TypeSwitchCallSite(Strategy strategy) {
174 | super(OBJECT_TO_INT);
175 | this.depth = 0;
176 | this.callsite = this;
177 | this.strategy = strategy;
178 | setTarget(FALLBACK.bindTo(this));
179 | }
180 |
181 | private TypeSwitchCallSite(int depth, TypeSwitchCallSite callsite, Strategy strategy) {
182 | super(OBJECT_TO_INT);
183 | this.depth = depth;
184 | this.callsite = callsite;
185 | this.strategy = strategy;
186 | setTarget(FALLBACK.bindTo(this));
187 | }
188 |
189 | static TypeSwitchCallSite create(Class[] typecases) {
190 | for(Class typecase: typecases) {
191 | Objects.requireNonNull(typecase);
192 | }
193 |
194 | Strategy strategy = (typecases.length < STRATEGY_CUT_OFF)?
195 | Strategy.isInstance(typecases): Strategy.classValue(typecases);
196 | return new TypeSwitchCallSite(strategy);
197 | }
198 |
199 | @SuppressWarnings("unused")
200 | private int fallback(Object value) {
201 | Class receiverClass = value.getClass();
202 | int index = strategy.index(receiverClass);
203 |
204 | if (depth == MAX_DEPTH) {
205 | setTarget(strategy.target());
206 | return index;
207 | }
208 |
209 | setTarget(guardWithTest(TYPECHECK.bindTo(receiverClass),
210 | dropArguments(constant(int.class, index), 0, Object.class),
211 | new TypeSwitchCallSite(depth + 1, callsite, strategy).dynamicInvoker()));
212 | return index;
213 | }
214 |
215 | @SuppressWarnings("unused")
216 | private static boolean typecheck(Class type, Object value) {
217 | return value.getClass() == type;
218 | }
219 |
220 | @SuppressWarnings("unused")
221 | private static int get(ClassValue classValue, Object value) {
222 | return classValue.get(value.getClass());
223 | }
224 |
225 | static MethodHandle wrapNullIfNecessary(boolean nullMatch, MethodHandle mh) {
226 | if (!nullMatch) {
227 | return mh;
228 | }
229 | return guardWithTest(NULLCHECK,
230 | dropArguments(constant(int.class, TypeSwitch.NULL_MATCH), 0, Object.class),
231 | mh);
232 | }
233 | }
--------------------------------------------------------------------------------
/src/main/java/com.github.forax.exotic/StructuralCall.java:
--------------------------------------------------------------------------------
1 | package com.github.forax.exotic;
2 |
3 | import java.lang.invoke.MethodHandle;
4 | import java.lang.invoke.MethodHandles.Lookup;
5 | import java.lang.invoke.MethodType;
6 |
7 | /**
8 | * Allow to call methods from different classes with no common interface if they have the same name
9 | * and the same parameter types.
10 | *
11 | * In term of performance, those calls require boxing of arguments and return value so
12 | * performance may suffer in the case the VM is not able to eliminate the boxing (sacrificing a goat
13 | * may help).
14 | *
15 | *
16 | * private final static StructuralCall IS_EMPTY =
17 | * StructuralCall.create(MethodHandles.lookup(), "isEmpty", MethodType.methodType(boolean.class));
18 | *
19 | * static boolean isEmpty(Object o) {
20 | * return IS_EMPTY.invoke(o);
21 | * }
22 | * ...
23 | *
24 | * System.out.println(isEmpty(List.of())); // true
25 | * System.out.println(isEmpty(List.of(1))); // false
26 | * System.out.println(isEmpty(Set.of())); // true
27 | * System.out.println(isEmpty(Map.of())); // true
28 | * System.out.println(isEmpty("")); // true
29 | *
30 | */
31 | public interface StructuralCall {
32 | /**
33 | * Calls the structural method with no argument.
34 | *
35 | * @param type of the return type.
36 | * @param receiver the receiver of the call.
37 | * @return the return value of the call, null if the calls return void.
38 | * @throws NoSuchMethodError if the receiver and its super types doesn't declare a method with the
39 | * same name and the same parameter types.
40 | * @throws IllegalAccessError if the receiver is not accessible from the lookup that was pass as
41 | * parameter when creating this StructuralCall.
42 | * @throws IllegalArgumentException if the structural method was created with more or less
43 | * parameters.
44 | */
45 | R invoke(Object receiver);
46 |
47 | /**
48 | * Calls the structural method with one argument.
49 | *
50 | * @param type of the return type.
51 | * @param receiver the receiver of the call.
52 | * @param arg1 first argument.
53 | * @return the return value of the call, null if the calls return void.
54 | * @throws NoSuchMethodError if the receiver and its super types doesn't declare a method with the
55 | * same name and the same parameter types.
56 | * @throws IllegalAccessError if the receiver is not accessible from the lookup that was pass as
57 | * parameter when creating this StructuralCall.
58 | * @throws IllegalArgumentException if the structural method was created with more or less
59 | * parameters.
60 | */
61 | R invoke(Object receiver, Object arg1);
62 |
63 | /**
64 | * Calls the structural method with two arguments.
65 | *
66 | * @param type of the return type.
67 | * @param receiver the receiver of the call.
68 | * @param arg1 first argument.
69 | * @param arg2 second argument.
70 | * @return the return value of the call, null if the calls return void.
71 | * @throws NoSuchMethodError if the receiver and its super types doesn't declare a method with the
72 | * same name and the same parameter types.
73 | * @throws IllegalAccessError if the receiver is not accessible from the lookup that was pass as
74 | * parameter when creating this StructuralCall.
75 | * @throws IllegalArgumentException if the structural method was created with more or less
76 | * parameters.
77 | */
78 | R invoke(Object receiver, Object arg1, Object arg2);
79 |
80 | /**
81 | * Calls the structural method with three arguments.
82 | *
83 | * @param type of the return type.
84 | * @param receiver the receiver of the call.
85 | * @param arg1 first argument.
86 | * @param arg2 second argument.
87 | * @param arg3 third argument.
88 | * @return the return value of the call, null if the calls return void.
89 | * @throws NoSuchMethodError if the receiver and its super types doesn't declare a method with the
90 | * same name and the same parameter types.
91 | * @throws IllegalAccessError if the receiver is not accessible from the lookup that was pass as
92 | * parameter when creating this StructuralCall.
93 | * @throws IllegalArgumentException if the structural method was created with more or less
94 | * parameters.
95 | */
96 | R invoke(Object receiver, Object arg1, Object arg2, Object arg3);
97 |
98 | /**
99 | * Calls the structural method with four arguments.
100 | *
101 | * @param type of the return type.
102 | * @param receiver the receiver of the call.
103 | * @param arg1 first argument.
104 | * @param arg2 second argument.
105 | * @param arg3 third argument.
106 | * @param arg4 fourth argument.
107 | * @return the return value of the call, null if the calls return void.
108 | * @throws NoSuchMethodError if the receiver and its super types doesn't declare a method with the
109 | * same name and the same parameter types.
110 | * @throws IllegalAccessError if the receiver is not accessible from the lookup that was pass as
111 | * parameter when creating this StructuralCall.
112 | * @throws IllegalArgumentException if the structural method was created with more or less
113 | * parameters.
114 | */
115 | R invoke(Object receiver, Object arg1, Object arg2, Object arg3, Object arg4);
116 |
117 | /**
118 | * Calls the structural method with five arguments.
119 | *
120 | * @param type of the return type.
121 | * @param receiver the receiver of the call.
122 | * @param arg1 first argument.
123 | * @param arg2 second argument.
124 | * @param arg3 third argument.
125 | * @param arg4 fourth argument.
126 | * @param arg5 fifth argument.
127 | * @return the return value of the call, null if the calls return void.
128 | * @throws NoSuchMethodError if the receiver and its super types doesn't declare a method with the
129 | * same name and the same parameter types.
130 | * @throws IllegalAccessError if the receiver is not accessible from the lookup that was pass as
131 | * parameter when creating this StructuralCall.
132 | * @throws IllegalArgumentException if the structural method was created with more or less
133 | * parameters.
134 | */
135 | R invoke(Object receiver, Object arg1, Object arg2, Object arg3, Object arg4, Object arg5);
136 |
137 | /**
138 | * Calls the structural method with six arguments.
139 | *
140 | * @param type of the return type.
141 | * @param receiver the receiver of the call.
142 | * @param arg1 first argument.
143 | * @param arg2 second argument.
144 | * @param arg3 third argument.
145 | * @param arg4 fourth argument.
146 | * @param arg5 fifth argument.
147 | * @param arg6 sixth argument.
148 | * @return the return value of the call, null if the calls return void.
149 | * @throws NoSuchMethodError if the receiver and its super types doesn't declare a method with the
150 | * same name and the same parameter types.
151 | * @throws IllegalAccessError if the receiver is not accessible from the lookup that was pass as
152 | * parameter when creating this StructuralCall.
153 | * @throws IllegalArgumentException if the structural method was created with more or less
154 | * parameters.
155 | */
156 | R invoke(
157 | Object receiver,
158 | Object arg1,
159 | Object arg2,
160 | Object arg3,
161 | Object arg4,
162 | Object arg5,
163 | Object arg6);
164 |
165 | /**
166 | * Calls the structural method with seven arguments.
167 | *
168 | * @param type of the return type.
169 | * @param receiver the receiver of the call.
170 | * @param arg1 first argument.
171 | * @param arg2 second argument.
172 | * @param arg3 third argument.
173 | * @param arg4 fourth argument.
174 | * @param arg5 fifth argument.
175 | * @param arg6 sixth argument.
176 | * @param arg7 seventh argument.
177 | * @return the return value of the call, null if the calls return void.
178 | * @throws NoSuchMethodError if the receiver and its super types doesn't declare a method with the
179 | * same name and the same parameter types.
180 | * @throws IllegalAccessError if the receiver is not accessible from the lookup that was pass as
181 | * parameter when creating this StructuralCall.
182 | * @throws IllegalArgumentException if the structural method was created with more or less
183 | * parameters.
184 | */
185 | R invoke(
186 | Object receiver,
187 | Object arg1,
188 | Object arg2,
189 | Object arg3,
190 | Object arg4,
191 | Object arg5,
192 | Object arg6,
193 | Object arg7);
194 |
195 | /**
196 | * Calls the structural method with eight arguments.
197 | *
198 | * @param type of the return type.
199 | * @param receiver the receiver of the call.
200 | * @param arg1 first argument.
201 | * @param arg2 second argument.
202 | * @param arg3 third argument.
203 | * @param arg4 fourth argument.
204 | * @param arg5 fifth argument.
205 | * @param arg6 sixth argument.
206 | * @param arg7 seventh argument.
207 | * @param arg8 eighth argument.
208 | * @return the return value of the call, null if the calls return void.
209 | * @throws NoSuchMethodError if the receiver and its super types doesn't declare a method with the
210 | * same name and the same parameter types.
211 | * @throws IllegalAccessError if the receiver is not accessible from the lookup that was pass as
212 | * parameter when creating this StructuralCall.
213 | * @throws IllegalArgumentException if the structural method was created with more or less
214 | * parameters.
215 | */
216 | R invoke(
217 | Object receiver,
218 | Object arg1,
219 | Object arg2,
220 | Object arg3,
221 | Object arg4,
222 | Object arg5,
223 | Object arg6,
224 | Object arg7,
225 | Object arg8);
226 |
227 | /**
228 | * Creates a structural call that can call methods visible from the {@code lookup}, with name
229 | * {@code name} and parameter types {@code type}.
230 | *
231 | * @param lookup will be used to find the methods in the receiver classes.
232 | * @param name the name of the methods.
233 | * @param type the parameter types of the methods.
234 | * @return a new structural call that will call methods structurally.
235 | */
236 | static StructuralCall create(Lookup lookup, String name, MethodType type) {
237 | MethodHandle mh = StructuralCallImpl.findMethodHandle(lookup, name, type);
238 | return (StructuralCallImpl)
239 | (paramCount, receiver, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) -> {
240 | try {
241 | return mh.invokeExact(
242 | paramCount, receiver, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
243 | } catch (Throwable e) {
244 | throw Thrower.rethrow(e);
245 | }
246 | };
247 | }
248 | }
249 |
--------------------------------------------------------------------------------
/src/main/java/com.github.forax.exotic/ConstantMemoizer.java:
--------------------------------------------------------------------------------
1 | package com.github.forax.exotic;
2 |
3 | import static java.lang.invoke.MethodHandles.constant;
4 | import static java.lang.invoke.MethodHandles.dropArguments;
5 | import static java.lang.invoke.MethodHandles.exactInvoker;
6 | import static java.lang.invoke.MethodHandles.foldArguments;
7 | import static java.lang.invoke.MethodHandles.guardWithTest;
8 | import static java.lang.invoke.MethodHandles.lookup;
9 | import static java.lang.invoke.MethodType.methodType;
10 |
11 | import java.lang.invoke.MethodHandle;
12 | import java.lang.invoke.MethodHandles.Lookup;
13 | import java.lang.invoke.MethodType;
14 | import java.lang.invoke.MutableCallSite;
15 | import java.util.Objects;
16 | import java.util.function.Function;
17 | import java.util.function.ToDoubleFunction;
18 | import java.util.function.ToIntFunction;
19 | import java.util.function.ToLongFunction;
20 |
21 | /**
22 | * Allow to see the return value of a function as a constant in case there are few possible pairs of
23 | * key/value.
24 | *
25 | * The method {@link #memoizer(Function, Class, Class)} returns a general purpose memoizer while
26 | * the methods {@link #intMemoizer(ToIntFunction, Class)}, {@link #longMemoizer(ToLongFunction,
27 | * Class)} and {@link #doubleMemoizer(ToDoubleFunction, Class)} returns memoizers specialized if the
28 | * value is an int, a long or a double (respectively).
29 | *
30 | *
Here is an example of usage
31 | *
32 | *
33 | * enum Level {
34 | * LOW, HIGH
35 | * }
36 | * ...
37 | * private static final ToIntFunction<Level> MEMOIZER = ConstantMemoizer.intMemoizer(Level::ordinal, Level.class);
38 | * ...
39 | * int result = MEMOIZER.applyAsInt(Level.LOW)); // if this line is called several times,
40 | * // the result will be considered as constant.
41 | *
42 | */
43 | public final class ConstantMemoizer {
44 | private ConstantMemoizer() {
45 | throw new AssertionError();
46 | }
47 |
48 | /**
49 | * Return a function that returns a constant value (for the Virtual Machine) for each key taken as
50 | * argument. The value corresponding to a key is calculated by calling the {@code function} once
51 | * by key and then cached in a code similar to a cascade of {@code if equals else}.
52 | *
53 | * To find if a key was previously seen or not, {@link Object#equals(Object)} will be called to
54 | * compare the actual key with possibly all the keys already seen, so if there are a lot of
55 | * different keys, the performance in the worst case is like a linear search i.e. O(number of seen
56 | * keys).
57 | *
58 | * @param type of the keys.
59 | * @param type of the values.
60 | * @param function a function that takes a non null key as argument and return a non null value.
61 | * @param keyClass the class of the key, if it's a primitive type, the key value will be boxed
62 | * before calling the {@code function}.
63 | * @param valueClass the class of the value, if it's a primitive type, the value will be boxed at
64 | * each call.
65 | * @return a function the function getting the value for a specific key.
66 | * @throws NullPointerException if the {@code function}, the {@code keyClass} or the {@code
67 | * valueClass} is null, or if the function key or the function value is null.
68 | * @throws ClassCastException if the function key or the function value types doesn't match the
69 | * {@code keyClass} or the {@code valueClass}.
70 | */
71 | public static Function memoizer(
72 | Function function, Class keyClass, Class valueClass) {
73 | Objects.requireNonNull(function);
74 | Objects.requireNonNull(keyClass);
75 | Objects.requireNonNull(valueClass);
76 | MethodHandle mh =
77 | new InliningCacheCallSite<>(methodType(valueClass, keyClass), function)
78 | .dynamicInvoker()
79 | .asType(methodType(Object.class, Object.class)); // erase
80 | return key -> {
81 | Objects.requireNonNull(key);
82 | try {
83 | return (V) mh.invokeExact(key);
84 | } catch (Throwable e) {
85 | throw Thrower.rethrow(e);
86 | }
87 | };
88 | }
89 |
90 | /**
91 | * Return a function that returns a constant value (for the Virtual Machine) for each key taken as
92 | * argument. The value corresponding to a key is calculated by calling the {@code function} once
93 | * by key and then cached in a code similar to a cascade of {@code if equals else}.
94 | *
95 | * To find if a key was previously seen or not, {@link Object#equals(Object)} will be called to
96 | * compare the actual key with possibly all the keys already seen, so if there are a lot of
97 | * different keys, the performance in the worst case is like a linear search i.e. O(number of seen
98 | * keys).
99 | *
100 | * @param type of the keys.
101 | * @param function a function that takes a non null key as argument and return a non null value.
102 | * @param keyClass the class of the key, if it's a primitive type, the key value will be boxed
103 | * before calling the {@code function}.
104 | * @return a function the function getting the value for a specific key.
105 | * @throws NullPointerException if the {@code function}, the {@code keyClass} is null, or if the
106 | * function key.
107 | * @throws ClassCastException if the function key types doesn't match the {@code keyClass}.
108 | */
109 | public static ToIntFunction intMemoizer(
110 | ToIntFunction function, Class keyClass) {
111 | Objects.requireNonNull(function);
112 | Objects.requireNonNull(keyClass);
113 | MethodHandle mh =
114 | new InliningCacheCallSite<>(methodType(int.class, keyClass), function::applyAsInt)
115 | .dynamicInvoker()
116 | .asType(methodType(int.class, Object.class)); // erase
117 | return key -> {
118 | Objects.requireNonNull(key);
119 | try {
120 | return (int) mh.invokeExact(key);
121 | } catch (Throwable e) {
122 | throw Thrower.rethrow(e);
123 | }
124 | };
125 | }
126 |
127 | /**
128 | * Return a function that returns a constant value (for the Virtual Machine) for each key taken as
129 | * argument. The value corresponding to a key is calculated by calling the {@code function} once
130 | * by key and then cached in a code similar to a cascade of {@code if equals else}.
131 | *
132 | * To find if a key was previously seen or not, {@link Object#equals(Object)} will be called to
133 | * compare the actual key with possibly all the keys already seen, so if there are a lot of
134 | * different keys, the performance in the worst case is like a linear search i.e. O(number of seen
135 | * keys).
136 | *
137 | * @param type of the keys.
138 | * @param function a function that takes a non null key as argument and return a non null value.
139 | * @param keyClass the class of the key, if it's a primitive type, the key value will be boxed
140 | * before calling the {@code function}.
141 | * @return a function the function getting the value for a specific key.
142 | * @throws NullPointerException if the {@code function}, the {@code keyClass} is null, or if the
143 | * function key.
144 | * @throws ClassCastException if the function key types doesn't match the {@code keyClass}.
145 | */
146 | public static ToLongFunction longMemoizer(
147 | ToLongFunction function, Class keyClass) {
148 | Objects.requireNonNull(function);
149 | Objects.requireNonNull(keyClass);
150 | MethodHandle mh =
151 | new InliningCacheCallSite<>(methodType(long.class, keyClass), function::applyAsLong)
152 | .dynamicInvoker()
153 | .asType(methodType(long.class, Object.class)); // erase
154 | return key -> {
155 | Objects.requireNonNull(key);
156 | try {
157 | return (long) mh.invokeExact(key);
158 | } catch (Throwable e) {
159 | throw Thrower.rethrow(e);
160 | }
161 | };
162 | }
163 |
164 | /**
165 | * Return a function that returns a constant value (for the Virtual Machine) for each key taken as
166 | * argument. The value corresponding to a key is calculated by calling the {@code function} once
167 | * by key and then cached in a code similar to a cascade of {@code if equals else}.
168 | *
169 | * To find if a key was previously seen or not, {@link Object#equals(Object)} will be called to
170 | * compare the actual key with possibly all the keys already seen, so if there are a lot of
171 | * different keys, the performance in the worst case is like a linear search i.e. O(number of seen
172 | * keys).
173 | *
174 | * @param type of the keys.
175 | * @param function a function that takes a non null key as argument and return a non null value.
176 | * @param keyClass the class of the key, if it's a primitive type, the key value will be boxed
177 | * before calling the {@code function}.
178 | * @return a function the function getting the value for a specific key.
179 | * @throws NullPointerException if the {@code function}, the {@code keyClass} is null, or if the
180 | * function key.
181 | * @throws ClassCastException if the function key types doesn't match the {@code keyClass}.
182 | */
183 | public static ToDoubleFunction doubleMemoizer(
184 | ToDoubleFunction function, Class keyClass) {
185 | Objects.requireNonNull(function);
186 | Objects.requireNonNull(keyClass);
187 | MethodHandle mh =
188 | new InliningCacheCallSite<>(methodType(double.class, keyClass), function::applyAsDouble)
189 | .dynamicInvoker()
190 | .asType(methodType(double.class, Object.class)); // erase
191 | return key -> {
192 | Objects.requireNonNull(key);
193 | try {
194 | return (double) mh.invokeExact(key);
195 | } catch (Throwable e) {
196 | throw Thrower.rethrow(e);
197 | }
198 | };
199 | }
200 |
201 | private static class InliningCacheCallSite extends MutableCallSite {
202 | private static final MethodHandle FALLBACK, EQUALS;
203 |
204 | static {
205 | Lookup lookup = lookup();
206 | try {
207 | FALLBACK =
208 | lookup.findVirtual(
209 | InliningCacheCallSite.class,
210 | "fallback",
211 | methodType(MethodHandle.class, Object.class));
212 | EQUALS =
213 | lookup.findVirtual(Object.class, "equals", methodType(boolean.class, Object.class));
214 | } catch (NoSuchMethodException | IllegalAccessException e) {
215 | throw new AssertionError(e);
216 | }
217 | }
218 |
219 | private final Function function;
220 |
221 | InliningCacheCallSite(MethodType type, Function function) {
222 | super(type);
223 | this.function = function;
224 | setTarget(
225 | foldArguments(
226 | exactInvoker(type),
227 | FALLBACK.bindTo(this).asType(methodType(MethodHandle.class, type.parameterType(0)))));
228 | }
229 |
230 | @SuppressWarnings("unused")
231 | private MethodHandle fallback(K key) {
232 | V value = Objects.requireNonNull(function.apply(key));
233 | MethodType type = type();
234 | Class keyClass = type.parameterType(0);
235 | Class valueClass = type.returnType();
236 | MethodHandle target = dropArguments(constant(valueClass, value), 0, keyClass);
237 | setTarget(
238 | guardWithTest(
239 | EQUALS.bindTo(key).asType(methodType(boolean.class, keyClass)),
240 | target,
241 | new InliningCacheCallSite<>(type, function).dynamicInvoker()));
242 | return target;
243 | }
244 | }
245 | }
246 |
--------------------------------------------------------------------------------
/src/test/java/com.github.forax.exotic/StableFieldTests.java:
--------------------------------------------------------------------------------
1 | package com.github.forax.exotic;
2 |
3 | import static java.lang.invoke.MethodHandles.lookup;
4 | import static java.lang.invoke.MethodHandles.publicLookup;
5 | import static org.junit.jupiter.api.Assertions.assertEquals;
6 | import static org.junit.jupiter.api.Assertions.assertFalse;
7 | import static org.junit.jupiter.api.Assertions.assertNull;
8 | import static org.junit.jupiter.api.Assertions.assertThrows;
9 | import static org.junit.jupiter.api.Assertions.assertTrue;
10 |
11 | import java.util.function.Function;
12 | import java.util.function.ToDoubleFunction;
13 | import java.util.function.ToIntFunction;
14 | import java.util.function.ToLongFunction;
15 |
16 | import org.junit.jupiter.api.Test;
17 |
18 | @SuppressWarnings("static-method")
19 | public class StableFieldTests {
20 | static class A {
21 | String x;
22 | }
23 |
24 | @Test
25 | public void testObjectFieldUninitialized() {
26 | Function xField = StableField.getter(lookup(), A.class, "x", String.class);
27 | A a = new A();
28 | assertNull(xField.apply(a));
29 | assertNull(xField.apply(a));
30 | }
31 |
32 | @Test
33 | public void testObjectFieldStable() {
34 | Function xField = StableField.getter(lookup(), A.class, "x", String.class);
35 | A a = new A();
36 | assertNull(xField.apply(a));
37 | a.x = "hello";
38 | assertEquals("hello", xField.apply(a));
39 | assertEquals("hello", xField.apply(a));
40 | }
41 |
42 | @Test
43 | public void testObjectFieldStableStill() {
44 | Function xField = StableField.getter(lookup(), A.class, "x", String.class);
45 | A a = new A();
46 | assertNull(xField.apply(a));
47 | a.x = "hello";
48 | assertEquals("hello", xField.apply(a));
49 | a.x = "banzai";
50 | assertEquals("hello", xField.apply(a));
51 | }
52 |
53 | @Test
54 | public void testObjectFieldNonConstant() {
55 | Function xField = StableField.getter(lookup(), A.class, "x", String.class);
56 | A a1 = new A();
57 | a1.x = "foo";
58 | assertEquals("foo", xField.apply(a1));
59 | A a2 = new A();
60 | assertThrows(IllegalStateException.class, () -> xField.apply(a2));
61 | }
62 |
63 | static class B {
64 | int y;
65 | }
66 |
67 | @Test
68 | public void testIntFieldUninitialized() {
69 | ToIntFunction yField = StableField.intGetter(lookup(), B.class, "y");
70 | B b = new B();
71 | assertEquals(0, yField.applyAsInt(b));
72 | assertEquals(0, yField.applyAsInt(b));
73 | }
74 |
75 | @Test
76 | public void testIntFieldStable() {
77 | ToIntFunction yField = StableField.intGetter(lookup(), B.class, "y");
78 | B b = new B();
79 | assertEquals(0, yField.applyAsInt(b));
80 | b.y = 42;
81 | assertEquals(42, yField.applyAsInt(b));
82 | assertEquals(42, yField.applyAsInt(b));
83 | }
84 |
85 | @Test
86 | public void testIntFieldStableStill() {
87 | ToIntFunction yField = StableField.intGetter(lookup(), B.class, "y");
88 | B b = new B();
89 | assertEquals(0, yField.applyAsInt(b));
90 | b.y = 42;
91 | assertEquals(42, yField.applyAsInt(b));
92 | b.y = 777;
93 | assertEquals(42, yField.applyAsInt(b));
94 | }
95 |
96 | @Test
97 | public void testIntFieldNonConstant() {
98 | ToIntFunction yField = StableField.intGetter(lookup(), B.class, "y");
99 | B b1 = new B();
100 | b1.y = 666;
101 | assertEquals(666, yField.applyAsInt(b1));
102 | B b2 = new B();
103 | assertThrows(IllegalStateException.class, () -> yField.applyAsInt(b2));
104 | }
105 |
106 | static class C {
107 | long z;
108 | }
109 |
110 | @Test
111 | public void testLongFieldUninitialized() {
112 | ToLongFunction zField = StableField.longGetter(lookup(), C.class, "z");
113 | C c = new C();
114 | assertEquals(0, zField.applyAsLong(c));
115 | assertEquals(0, zField.applyAsLong(c));
116 | }
117 |
118 | @Test
119 | public void testLongFieldStable() {
120 | ToLongFunction zField = StableField.longGetter(lookup(), C.class, "z");
121 | C c = new C();
122 | assertEquals(0L, zField.applyAsLong(c));
123 | c.z = 42L;
124 | assertEquals(42L, zField.applyAsLong(c));
125 | assertEquals(42L, zField.applyAsLong(c));
126 | }
127 |
128 | @Test
129 | public void testLongFieldStableStill() {
130 | ToLongFunction zField = StableField.longGetter(lookup(), C.class, "z");
131 | C c = new C();
132 | assertEquals(0, zField.applyAsLong(c));
133 | c.z = 42L;
134 | assertEquals(42L, zField.applyAsLong(c));
135 | c.z = 777L;
136 | assertEquals(42L, zField.applyAsLong(c));
137 | }
138 |
139 | @Test
140 | public void tesLongFieldNonConstant() {
141 | ToLongFunction zField = StableField.longGetter(lookup(), C.class, "z");
142 | C c1 = new C();
143 | c1.z = 666;
144 | assertEquals(666, zField.applyAsLong(c1));
145 | C c2 = new C();
146 | assertThrows(IllegalStateException.class, () -> zField.applyAsLong(c2));
147 | }
148 |
149 | static class D {
150 | double z;
151 | }
152 |
153 | @Test
154 | public void testDoubleFieldUninitialized() {
155 | ToDoubleFunction zField = StableField.doubleGetter(lookup(), D.class, "z");
156 | D d = new D();
157 | assertEquals(0.0, zField.applyAsDouble(d));
158 | assertEquals(0.0, zField.applyAsDouble(d));
159 | }
160 |
161 | @Test
162 | public void testDoubleFieldStable() {
163 | ToDoubleFunction zField = StableField.doubleGetter(lookup(), D.class, "z");
164 | D d = new D();
165 | assertEquals(0.0, zField.applyAsDouble(d));
166 | d.z = 42.0;
167 | assertEquals(42.0, zField.applyAsDouble(d));
168 | assertEquals(42.0, zField.applyAsDouble(d));
169 | }
170 |
171 | @Test
172 | public void testDoubleFieldStableStill() {
173 | ToDoubleFunction zField = StableField.doubleGetter(lookup(), D.class, "z");
174 | D d = new D();
175 | assertEquals(0.0, zField.applyAsDouble(d));
176 | d.z = 42;
177 | assertEquals(42.0, zField.applyAsDouble(d));
178 | d.z = 777;
179 | assertEquals(42.0, zField.applyAsDouble(d));
180 | }
181 |
182 | @Test
183 | public void testDoubleFieldNonConstant() {
184 | ToDoubleFunction zField = StableField.doubleGetter(lookup(), D.class, "z");
185 | D d1 = new D();
186 | d1.z = 666.0;
187 | assertEquals(666.0, zField.applyAsDouble(d1));
188 | D d2 = new D();
189 | assertThrows(IllegalStateException.class, () -> zField.applyAsDouble(d2));
190 | }
191 |
192 | static class Boxed {
193 | int i;
194 | long j;
195 | double d;
196 | }
197 |
198 | @Test
199 | public void testBoxedIntField() {
200 | Function iField = StableField.getter(lookup(), Boxed.class, "i", int.class);
201 | Boxed boxed = new Boxed();
202 | assertEquals(0, (int) iField.apply(boxed));
203 | boxed.i = 3;
204 | assertEquals(3, (int) iField.apply(boxed));
205 | boxed.i = 5;
206 | assertEquals(3, (int) iField.apply(boxed));
207 | assertThrows(IllegalStateException.class, () -> iField.apply(new Boxed()));
208 | }
209 |
210 | @Test
211 | public void testBoxedLongField() {
212 | Function jField = StableField.getter(lookup(), Boxed.class, "j", long.class);
213 | Boxed boxed = new Boxed();
214 | assertEquals(0L, (long) jField.apply(boxed));
215 | boxed.j = 3L;
216 | assertEquals(3L, (long) jField.apply(boxed));
217 | boxed.j = 5L;
218 | assertEquals(3L, (long) jField.apply(boxed));
219 | assertThrows(IllegalStateException.class, () -> jField.apply(new Boxed()));
220 | }
221 |
222 | @Test
223 | public void testBoxedDoubleField() {
224 | Function dField = StableField.getter(lookup(), Boxed.class, "d", double.class);
225 | Boxed boxed = new Boxed();
226 | assertEquals(0.0, (double) dField.apply(boxed));
227 | boxed.d = 3.0;
228 | assertEquals(3.0, (double) dField.apply(boxed));
229 | boxed.d = 5.0;
230 | assertEquals(3.0, (double) dField.apply(boxed));
231 | assertThrows(IllegalStateException.class, () -> dField.apply(new Boxed()));
232 | }
233 |
234 | static class Prim {
235 | boolean z;
236 | byte b;
237 | char c;
238 | short s;
239 | float f;
240 | }
241 |
242 | @Test
243 | public void testPrimBooleanField() {
244 | Function zField = StableField.getter(lookup(), Prim.class, "z", boolean.class);
245 | Prim prim = new Prim();
246 | assertFalse(zField.apply(prim));
247 | prim.z = true;
248 | assertTrue(zField.apply(prim));
249 | prim.z = false;
250 | assertTrue(zField.apply(prim));
251 | assertThrows(IllegalStateException.class, () -> zField.apply(new Prim()));
252 | }
253 |
254 | @Test
255 | public void testPrimByteField() {
256 | Function bField = StableField.getter(lookup(), Prim.class, "b", byte.class);
257 | Prim prim = new Prim();
258 | assertEquals((byte) 0, (byte) bField.apply(prim));
259 | prim.b = 10;
260 | assertEquals((byte) 10, (byte) bField.apply(prim));
261 | prim.b = 5;
262 | assertEquals((byte) 10, (byte) bField.apply(prim));
263 | assertThrows(IllegalStateException.class, () -> bField.apply(new Prim()));
264 | }
265 |
266 | @Test
267 | public void testPrimCharField() {
268 | Function cField = StableField.getter(lookup(), Prim.class, "c", char.class);
269 | Prim prim = new Prim();
270 | assertEquals((char) 0, (char) cField.apply(prim));
271 | prim.c = 'A';
272 | assertEquals('A', (char) cField.apply(prim));
273 | prim.c = 'B';
274 | assertEquals('A', (char) cField.apply(prim));
275 | assertThrows(IllegalStateException.class, () -> cField.apply(new Prim()));
276 | }
277 |
278 | @Test
279 | public void testPrimShortField() {
280 | Function sField = StableField.getter(lookup(), Prim.class, "s", short.class);
281 | Prim prim = new Prim();
282 | assertEquals((short) 0, (short) sField.apply(prim));
283 | prim.s = 1_000;
284 | assertEquals((short) 1_000, (short) sField.apply(prim));
285 | prim.s = 2_000;
286 | assertEquals((short) 1_000, (short) sField.apply(prim));
287 | assertThrows(IllegalStateException.class, () -> sField.apply(new Prim()));
288 | }
289 |
290 | @Test
291 | public void testPrimFloatField() {
292 | Function fField = StableField.getter(lookup(), Prim.class, "f", float.class);
293 | Prim prim = new Prim();
294 | assertEquals(0.0f, (float) fField.apply(prim));
295 | prim.f = 0.2f;
296 | assertEquals(0.2f, (float) fField.apply(prim));
297 | prim.f = 0.4f;
298 | assertEquals(0.2f, (float) fField.apply(prim));
299 | assertThrows(IllegalStateException.class, () -> fField.apply(new Prim()));
300 | }
301 |
302 | @Test
303 | public void testNoSuchField() {
304 | assertThrows(
305 | NoSuchFieldError.class,
306 | () -> StableField.getter(lookup(), Object.class, "foo", String.class));
307 | assertThrows(
308 | NoSuchFieldError.class, () -> StableField.intGetter(lookup(), Object.class, "foo"));
309 | assertThrows(
310 | NoSuchFieldError.class, () -> StableField.longGetter(lookup(), Object.class, "foo"));
311 | assertThrows(
312 | NoSuchFieldError.class, () -> StableField.doubleGetter(lookup(), Object.class, "foo"));
313 | }
314 |
315 | private static class Foo {
316 | private @SuppressWarnings("unused") Object a;
317 | private @SuppressWarnings("unused") int b;
318 | private @SuppressWarnings("unused") long c;
319 | private @SuppressWarnings("unused") double d;
320 | }
321 |
322 | @Test
323 | public void testNoAccess() {
324 | assertThrows(
325 | IllegalAccessError.class,
326 | () -> StableField.getter(publicLookup(), Foo.class, "a", Object.class));
327 | assertThrows(
328 | IllegalAccessError.class, () -> StableField.intGetter(publicLookup(), Foo.class, "b"));
329 | assertThrows(
330 | IllegalAccessError.class, () -> StableField.longGetter(publicLookup(), Foo.class, "c"));
331 | assertThrows(
332 | IllegalAccessError.class, () -> StableField.doubleGetter(publicLookup(), Foo.class, "d"));
333 | }
334 | }
335 |
--------------------------------------------------------------------------------
/src/main/java/com.github.forax.exotic/ObjectSupportLambdas.java:
--------------------------------------------------------------------------------
1 | package com.github.forax.exotic;
2 |
3 | import static java.lang.invoke.MethodHandles.publicLookup;
4 | import static java.lang.invoke.MethodType.methodType;
5 | import static java.util.stream.Collectors.groupingBy;
6 | import static java.util.stream.Collectors.toMap;
7 | import static java.util.stream.IntStream.range;
8 |
9 | import java.io.IOException;
10 | import java.io.InputStream;
11 | import java.lang.invoke.MethodHandle;
12 | import java.lang.invoke.MethodHandles;
13 | import java.lang.invoke.MethodHandles.Lookup;
14 | import java.lang.invoke.MethodType;
15 | import java.lang.invoke.SerializedLambda;
16 | import java.lang.reflect.Method;
17 | import java.util.Arrays;
18 | import java.util.Map;
19 | import java.util.Set;
20 | import java.util.function.BiConsumer;
21 |
22 | class ObjectSupportLambdas {
23 | private static MethodHandle PRIVATE_LOOKUP_IN;
24 | static {
25 | Lookup lookup = publicLookup();
26 | MethodHandle privateLookupIn;
27 | try {
28 | privateLookupIn = lookup.findStatic(MethodHandles.class, "privateLookupIn", methodType(Lookup.class, Class.class, Lookup.class));
29 | } catch(IllegalAccessException e) {
30 | throw new AssertionError(e);
31 | } catch (@SuppressWarnings("unused") NoSuchMethodException e) {
32 | // JDK 8
33 | privateLookupIn = null;
34 | }
35 | PRIVATE_LOOKUP_IN = privateLookupIn;
36 | }
37 |
38 | private static SerializedLambda extractSerializedLambda(Object projectionFunction, Lookup lookup) {
39 | Class lambdaClass = projectionFunction.getClass();
40 | MethodHandle writeReplace = (PRIVATE_LOOKUP_IN == null)?
41 | findWriteReplaceJava8(lambdaClass, lookup):
42 | findWriteReplaceJava9(lambdaClass, lookup);
43 |
44 | try {
45 | return (SerializedLambda)writeReplace.invoke(projectionFunction);
46 | } catch (Throwable e) {
47 | throw Thrower.rethrow(e);
48 | }
49 | }
50 |
51 | private static MethodHandle findWriteReplaceJava8(Class lambdaClass, Lookup lookup) {
52 | Method writeReplace;
53 | try {
54 | writeReplace = lambdaClass.getDeclaredMethod("writeReplace");
55 | } catch (NoSuchMethodException e) {
56 | throw new IllegalArgumentException("the writeReplace method is not found, perhaps it's not a serializable lambad ?", e);
57 | }
58 | writeReplace.setAccessible(true);
59 |
60 | try {
61 | return lookup.unreflect(writeReplace);
62 | } catch (IllegalAccessException e) {
63 | throw new IllegalArgumentException("the lookup can not access to the method writeReplace", e);
64 | }
65 | }
66 |
67 | private static MethodHandle findWriteReplaceJava9(Class lambdaClass, Lookup lookup) {
68 | Lookup teleport;
69 | try {
70 | teleport = (Lookup)PRIVATE_LOOKUP_IN.invoke(lambdaClass, lookup);
71 | } catch (IllegalAccessException e) {
72 | throw new IllegalArgumentException("the lookup can not access to the lambda proxy class", e);
73 | } catch(Throwable e) {
74 | throw Thrower.rethrow(e);
75 | }
76 |
77 | try {
78 | return teleport.findVirtual(lambdaClass, "writeReplace", MethodType.methodType(Object.class));
79 | } catch (NoSuchMethodException | IllegalAccessException e) {
80 | throw new IllegalArgumentException("the writeReplace method is not accessible, perhaps it's not a serializable lambad ?", e);
81 | }
82 | }
83 |
84 |
85 | static String[] extractFieldNames(Lookup lookup, Object[] projections) {
86 | SerializedLambda[] serializedLambdas = new SerializedLambda[projections.length];
87 | for(int i = 0; i < serializedLambdas.length; i++) {
88 | try {
89 | serializedLambdas[i] = extractSerializedLambda(projections[i], lookup);
90 | } catch(IllegalArgumentException e) {
91 | throw new IllegalArgumentException("can not extract information from lambda at index " + i, e);
92 | }
93 | }
94 |
95 | return extractFieldNames(lookup.lookupClass(), serializedLambdas);
96 | }
97 |
98 | private static String methodDesc(SerializedLambda serializedLambda) {
99 | return serializedLambda.getImplMethodName() + serializedLambda.getImplMethodSignature();
100 | }
101 |
102 | private static String[] extractFieldNames(Class lookupClass, SerializedLambda[] serializedLambdas) {
103 | Map> implMap =
104 | range(0, serializedLambdas.length).boxed().collect(groupingBy(
105 | index -> serializedLambdas[index].getImplClass(),
106 | toMap(index -> methodDesc(serializedLambdas[index]), index -> index)));
107 | String[] fieldNames = new String[serializedLambdas.length];
108 |
109 | // find all lambda implementations and scan them
110 | implMap.forEach((implClassName, methodDescSlotMap) -> {
111 | byte[] data ;
112 | try(InputStream input = lookupClass.getResourceAsStream("/" + implClassName.replace('.', '/') + ".class")) {
113 | if (input == null) {
114 | throw new IllegalArgumentException("can not access to the bytecode of " + implClassName + " using lookup " + lookupClass.getName());
115 | }
116 |
117 | data = readAllBytes(input);
118 | } catch(IOException e) {
119 | throw new AssertionError(e);
120 | }
121 |
122 | scanClassFile(data, methodDescSlotMap.keySet(), (methodDesc, fieldName) -> fieldNames[methodDescSlotMap.get(methodDesc)] = fieldName);
123 | });
124 |
125 | // verify that all field names have been extracted
126 | for(int i = 0; i < fieldNames.length; i++) {
127 | if (fieldNames[i] == null) {
128 | throw new IllegalArgumentException("lambda " + i + " doesn't acces to a field name");
129 | }
130 | }
131 |
132 | return fieldNames;
133 | }
134 |
135 | private static byte[] readAllBytes(InputStream input) throws IOException {
136 | byte[] buffer = new byte[8192];
137 | int read;
138 | int total = 0;
139 | while((read = input.read(buffer, total, buffer.length - total)) != -1) {
140 | total += read;
141 | if (read == 0) {
142 | buffer = Arrays.copyOf(buffer, buffer.length + 8192);
143 | }
144 | }
145 | return Arrays.copyOf(buffer, total);
146 | }
147 |
148 |
149 | private static final int UTF8_TAG = 1;
150 |
151 | // size of the constant pool item depending on its tag
152 | private static int[] CONSTANT_SIZE = new int[] {
153 | 0,
154 | 0, // UTF8
155 | 0,
156 | 5, // INTEGER
157 | 5, // FLOAT
158 | 9, // LONG
159 | 9, // DOUBLE
160 | 3, // CLASS
161 | 3, // STRING
162 | 5, // FIEDREF
163 | 5, // METHODREF
164 | 5, // ITF_METHODREF
165 | 5, // NAME_AND_TYPE
166 | 0,
167 | 0,
168 | 4, // METHODHANDLE
169 | 3, // METHODTYPE
170 | 5, // CONDY
171 | 5, // INDY
172 | 3, // MODULE
173 | 3, // PACKAGE
174 | };
175 |
176 | private static final int ALOAD_0 = 42;
177 | private static final int GETFIELD = 180;
178 | private static final int INVOKESTATIC = 184;
179 | private static final int ARETURN = 176;
180 |
181 | private static int readU2(byte[] data, int offset) {
182 | return ((data[offset] & 0xFF) << 8) | (data[offset + 1] & 0xFF);
183 | }
184 |
185 | private static int readU4(byte[] data, int offset) {
186 | return ((data[offset] & 0xFF) << 24)
187 | | ((data[offset + 1] & 0xFF) << 16)
188 | | ((data[offset + 2] & 0xFF) << 8)
189 | | (data[offset + 3] & 0xFF);
190 | }
191 |
192 | private static String string(byte[] data, int[] offsets, String[] cache, int offset) {
193 | int index = readU2(data, offset);
194 |
195 | String s = cache[index];
196 | if (s != null) {
197 | return s;
198 | }
199 | // read String item
200 | int itemOffset = offsets[index];
201 | return cache[index] = readUTF8(data, itemOffset + 2, readU2(data, itemOffset));
202 | }
203 |
204 | private static String readUTF8(byte[] data, int utfOffset, int utfLength) {
205 | int offset = utfOffset;
206 | int end = offset + utfLength;
207 | int stringIndex = 0;
208 |
209 | char[] buffer = new char[utfLength]; // may be bigger than necessary
210 | while (offset < end) {
211 | int b = data[offset++];
212 | if ((b & 0x80) == 0) {
213 | buffer[stringIndex++] = (char) (b & 0x7F);
214 | } else if ((b & 0xE0) == 0xC0) {
215 | buffer[stringIndex++] = (char) (((b & 0x1F) << 6) | (data[offset++] & 0x3F));
216 | } else {
217 | buffer[stringIndex++] = (char) (((b & 0xF) << 12) | ((data[offset++] & 0x3F) << 6) | (data[offset++] & 0x3F));
218 | }
219 | }
220 | return new String(buffer, 0, stringIndex);
221 | }
222 |
223 |
224 | private static void scanClassFile(byte[] data, Set methodDescSet, BiConsumer consumer) {
225 | int constantsCount = readU2(data, 8);
226 | int[] offsets = new int[constantsCount];
227 |
228 | // scan the constant pool items, find their offsets
229 | int offset = 10;
230 | for (int i = 1; i < constantsCount; i++) {
231 | offsets[i] = offset + 1;
232 |
233 | int constant = data[offset];
234 | offset += CONSTANT_SIZE[constant];
235 | if (constant == UTF8_TAG) {
236 | offset += 3 + readU2(data, offset + 1);
237 | }
238 | }
239 |
240 | // skip header
241 | int interfacesCount = readU2(data, offset + 6);
242 | offset += 8 + 2 * interfacesCount;
243 |
244 | // skip fields
245 | int fieldsCount = readU2(data, offset);
246 | offset += 2;
247 | for (int i = 0; i < fieldsCount; i++) {
248 | int attributesCount = readU2(data, offset + 6);
249 | offset += 8;
250 | // Skip field attributes
251 | for(int j = 0; j < attributesCount; j++) {
252 | offset += 6 + readU4(data, offset + 2);
253 | }
254 | }
255 |
256 | String[] cache = new String[constantsCount];
257 |
258 | // scan methods
259 | int methodCount = readU2(data, offset);
260 | offset += 2;
261 | for (int i = 0; i < methodCount; i++) {
262 |
263 | String methodDesc = string(data, offsets, cache, offset + 2) + string(data, offsets, cache, offset + 4);
264 |
265 | int attributesCount = readU2(data, offset + 6);
266 | offset += 8;
267 |
268 | if (methodDescSet.contains(methodDesc)) {
269 | // scan to find the "Code" attribute
270 | for(int j = 0; j < attributesCount; j++) {
271 | String attributeName = string(data, offsets, cache, offset);
272 | if (attributeName.equals("Code")) {
273 |
274 | int codeOffset = offset + 6;
275 | int codeLength = readU4(data, codeOffset + 4);
276 | codeOffset += 8;
277 | int codeEnd = codeOffset + codeLength;
278 |
279 | String fieldName = null;
280 |
281 | loop: while(codeOffset < codeEnd) {
282 | int opcode = data[codeOffset] & 0xFF;
283 | switch(opcode) {
284 | case ALOAD_0:
285 | codeOffset++;
286 | break;
287 | case GETFIELD: {
288 | int fieldRefOffset = offsets[readU2(data, codeOffset + 1)];
289 | int nameAndTypeOffset = offsets[readU2(data, fieldRefOffset + 2)];
290 | fieldName = string(data, offsets, cache, nameAndTypeOffset);
291 | codeOffset += 3;
292 | break;
293 | }
294 | case INVOKESTATIC:
295 | codeOffset += 3;
296 | break;
297 | case ARETURN:
298 | codeOffset++;
299 | break;
300 | default:
301 | fieldName = null; // mark unrecognized
302 | break loop;
303 | }
304 | }
305 |
306 | if (fieldName != null) {
307 | // pattern fully recognized !!
308 | consumer.accept(methodDesc, fieldName);
309 | }
310 | }
311 |
312 | offset += 6 + readU4(data, offset + 2);
313 | }
314 |
315 | } else {
316 | // Skip method attributes
317 | for(int j = 0; j < attributesCount; j++) {
318 | offset += 6 + readU4(data, offset + 2);
319 | }
320 | }
321 | }
322 | }
323 | }
324 |
--------------------------------------------------------------------------------
/src/test/java/com.github.forax.exotic/ObjectSupportTests.java:
--------------------------------------------------------------------------------
1 | package com.github.forax.exotic;
2 |
3 | import static java.lang.invoke.MethodHandles.lookup;
4 | import static org.junit.jupiter.api.Assertions.assertAll;
5 | import static org.junit.jupiter.api.Assertions.assertEquals;
6 | import static org.junit.jupiter.api.Assertions.assertNotEquals;
7 | import static org.junit.jupiter.api.Assertions.assertThrows;
8 |
9 | import java.lang.annotation.ElementType;
10 | import java.lang.annotation.Retention;
11 | import java.lang.annotation.RetentionPolicy;
12 | import java.lang.annotation.Target;
13 | import java.lang.reflect.Field;
14 | import java.util.Arrays;
15 |
16 | import org.junit.jupiter.api.Test;
17 |
18 |
19 | @SuppressWarnings("static-method")
20 | public class ObjectSupportTests {
21 | static final class Hello {
22 | private static final ObjectSupport SUPPORT = ObjectSupport.of(lookup(), Hello.class, "name");
23 |
24 | @SuppressWarnings("unused")
25 | private final String name;
26 |
27 | public Hello(String name) {
28 | this.name = name;
29 | }
30 |
31 | @Override
32 | public boolean equals(Object other) {
33 | return SUPPORT.equals(this, other);
34 | }
35 |
36 | @Override
37 | public int hashCode() {
38 | return SUPPORT.hashCode(this);
39 | }
40 | }
41 |
42 | @Test
43 | public void testEqualsHello() {
44 | Hello hello1 = new Hello(new String("bonjour"));
45 | Hello hello2 = new Hello(new String("bonjour"));
46 | assertEquals(hello1, hello2);
47 | }
48 |
49 | @Test
50 | public void testHashCodeHello() {
51 | Hello hello = new Hello("ola");
52 | assertEquals(1 * 31 + "ola".hashCode(), hello.hashCode());
53 | }
54 |
55 |
56 |
57 | static final class Foo {
58 | private static final ObjectSupport SUPPORT = ObjectSupport.of(lookup(), Foo.class, "a", "b", "c", "d", "e", "f", "g", "h", "s", "o");
59 |
60 | boolean a;
61 | byte b;
62 | short c;
63 | char d;
64 | int e;
65 | long f;
66 | float g;
67 | double h;
68 | String s;
69 | Object o;
70 |
71 | @Override
72 | public boolean equals(Object other) {
73 | return SUPPORT.equals(this, other);
74 | }
75 |
76 | @Override
77 | public int hashCode() {
78 | return SUPPORT.hashCode(this);
79 | }
80 | }
81 |
82 | @Test
83 | public void testAllFieldsHashCode() {
84 | Foo foo1 = new Foo();
85 | Foo foo2 = new Foo();
86 | assertEquals(foo1.hashCode(), foo2.hashCode());
87 | }
88 |
89 | @Test
90 | public void testAllFieldsHashCodeBoolean() {
91 | Foo foo1 = new Foo();
92 | foo1.a = true;
93 | Foo foo2 = new Foo();
94 | assertNotEquals(foo1.hashCode(), foo2.hashCode());
95 | foo2.a = true;
96 | assertEquals(foo1.hashCode(), foo2.hashCode());
97 | }
98 | @Test
99 | public void testAllFieldsHashCodeByte() {
100 | Foo foo1 = new Foo();
101 | foo1.b = 1;
102 | Foo foo2 = new Foo();
103 | assertNotEquals(foo1.hashCode(), foo2.hashCode());
104 | foo2.b = 1;
105 | assertEquals(foo1.hashCode(), foo2.hashCode());
106 | }
107 | @Test
108 | public void testAllFieldsHashCodeShort() {
109 | Foo foo1 = new Foo();
110 | foo1.c = 1;
111 | Foo foo2 = new Foo();
112 | assertNotEquals(foo1.hashCode(), foo2.hashCode());
113 | foo2.c = 1;
114 | assertEquals(foo1.hashCode(), foo2.hashCode());
115 | }
116 | @Test
117 | public void testAllFieldsHashCodeChar() {
118 | Foo foo1 = new Foo();
119 | foo1.d = 1;
120 | Foo foo2 = new Foo();
121 | assertNotEquals(foo1.hashCode(), foo2.hashCode());
122 | foo2.d = 1;
123 | assertEquals(foo1.hashCode(), foo2.hashCode());
124 | }
125 | @Test
126 | public void testAllFieldsHashCodeInt() {
127 | Foo foo1 = new Foo();
128 | foo1.e = 1;
129 | Foo foo2 = new Foo();
130 | assertNotEquals(foo1.hashCode(), foo2.hashCode());
131 | foo2.e = 1;
132 | assertEquals(foo1.hashCode(), foo2.hashCode());
133 | }
134 | @Test
135 | public void testAllFieldsHashCodeLong() {
136 | Foo foo1 = new Foo();
137 | foo1.f = 1;
138 | Foo foo2 = new Foo();
139 | assertNotEquals(foo1.hashCode(), foo2.hashCode());
140 | foo2.f = 1;
141 | assertEquals(foo1.hashCode(), foo2.hashCode());
142 | }
143 | @Test
144 | public void testAllFieldsHashCodeFloat() {
145 | Foo foo1 = new Foo();
146 | foo1.g = 1;
147 | Foo foo2 = new Foo();
148 | assertNotEquals(foo1.hashCode(), foo2.hashCode());
149 | foo2.g = 1;
150 | assertEquals(foo1.hashCode(), foo2.hashCode());
151 | }
152 | @Test
153 | public void testAllFieldsHashCodeDouble() {
154 | Foo foo1 = new Foo();
155 | foo1.h = 1;
156 | Foo foo2 = new Foo();
157 | assertNotEquals(foo1.hashCode(), foo2.hashCode());
158 | foo2.h = 1;
159 | assertEquals(foo1.hashCode(), foo2.hashCode());
160 | }
161 | @Test
162 | public void testAllFieldsHashCodeString() {
163 | Foo foo1 = new Foo();
164 | foo1.s = new String("bar");
165 | Foo foo2 = new Foo();
166 | assertNotEquals(foo1.hashCode(), foo2.hashCode());
167 | foo2.s = new String("bar");
168 | assertEquals(foo1.hashCode(), foo2.hashCode());
169 | }
170 | @Test
171 | public void testAllFieldsHashCodeObject() {
172 | Foo foo1 = new Foo();
173 | foo1.o = Integer.valueOf(1500);
174 | Foo foo2 = new Foo();
175 | assertNotEquals(foo1.hashCode(), foo2.hashCode());
176 | foo2.o = Integer.valueOf(1500);
177 | assertEquals(foo1.hashCode(), foo2.hashCode());
178 | }
179 |
180 | @Test
181 | public void testAllFieldsEquals() {
182 | Foo foo1 = new Foo();
183 | Foo foo2 = new Foo();
184 | assertEquals(foo1, foo2);
185 | }
186 |
187 | @Test
188 | public void testAllFieldsEqualsBoolean() {
189 | Foo foo1 = new Foo();
190 | foo1.a = true;
191 | Foo foo2 = new Foo();
192 | assertNotEquals(foo1, foo2);
193 | foo2.a = true;
194 | assertEquals(foo1, foo2);
195 | }
196 | @Test
197 | public void testAllFieldsEqualsByte() {
198 | Foo foo1 = new Foo();
199 | foo1.b = 1;
200 | Foo foo2 = new Foo();
201 | assertNotEquals(foo1, foo2);
202 | foo2.b = 1;
203 | assertEquals(foo1, foo2);
204 | }
205 | @Test
206 | public void testAllFieldsEqualsShort() {
207 | Foo foo1 = new Foo();
208 | foo1.c = 1;
209 | Foo foo2 = new Foo();
210 | assertNotEquals(foo1, foo2);
211 | foo2.c = 1;
212 | assertEquals(foo1, foo2);
213 | }
214 | @Test
215 | public void testAllFieldsEqualsChar() {
216 | Foo foo1 = new Foo();
217 | foo1.d = 1;
218 | Foo foo2 = new Foo();
219 | assertNotEquals(foo1, foo2);
220 | foo2.d = 1;
221 | assertEquals(foo1, foo2);
222 | }
223 | @Test
224 | public void testAllFieldsEqualsInt() {
225 | Foo foo1 = new Foo();
226 | foo1.e = 1;
227 | Foo foo2 = new Foo();
228 | assertNotEquals(foo1, foo2);
229 | foo2.e = 1;
230 | assertEquals(foo1, foo2);
231 | }
232 | @Test
233 | public void testAllFieldsEqualsLong() {
234 | Foo foo1 = new Foo();
235 | foo1.f = 1;
236 | Foo foo2 = new Foo();
237 | assertNotEquals(foo1, foo2);
238 | foo2.f = 1;
239 | assertEquals(foo1, foo2);
240 | }
241 | @Test
242 | public void testAllFieldsEqualsFloat() {
243 | Foo foo1 = new Foo();
244 | foo1.g = 1;
245 | Foo foo2 = new Foo();
246 | assertNotEquals(foo1, foo2);
247 | foo2.g = 1;
248 | assertEquals(foo1, foo2);
249 | }
250 | @Test
251 | public void testAllFieldsEqualsDouble() {
252 | Foo foo1 = new Foo();
253 | foo1.h = 1;
254 | Foo foo2 = new Foo();
255 | assertNotEquals(foo1, foo2);
256 | foo2.h = 1;
257 | assertEquals(foo1, foo2);
258 | }
259 | @Test
260 | public void testAllFieldsEqualsString() {
261 | Foo foo1 = new Foo();
262 | foo1.s = new String("bar");
263 | Foo foo2 = new Foo();
264 | assertNotEquals(foo1, foo2);
265 | foo2.s = new String("bar");
266 | assertEquals(foo1, foo2);
267 | }
268 | @Test
269 | public void testAllFieldsEqualsObject() {
270 | Foo foo1 = new Foo();
271 | foo1.o = Integer.valueOf(1500);
272 | Foo foo2 = new Foo();
273 | assertNotEquals(foo1, foo2);
274 | foo2.o = Integer.valueOf(1500);
275 | assertEquals(foo1, foo2);
276 | }
277 |
278 | static final class Empty {
279 | @SuppressWarnings("unchecked")
280 | static final ObjectSupport