Make reflection fast as direct calls.

Most programmers are aware of reflection , which (it’s a reflection) makes it easy to add dynamic capabilities to static languages ​​such as Java / C #. However, reflection is blamed for the fact that calls work very slowly - up to 500 times slower. Nevertheless, this can be easily corrected - we will show in this article how to make a reflection-call as fast as a direct call.


Measure the speed of the next class:

Copy Source | Copy HTML class A { public int value = 0 ; public void add( int x) { value += x; } }

1. Copy Source | Copy HTML class A { public int value = 0 ; public void add( int x) { value += x; } }
2. Copy Source | Copy HTML class A { public int value = 0 ; public void add( int x) { value += x; } }
4. Copy Source | Copy HTML class A { public int value = 0 ; public void add( int x) { value += x; } }
5. Copy Source | Copy HTML class A { public int value = 0 ; public void add( int x) { value += x; } }
6. Copy Source | Copy HTML class A { public int value = 0 ; public void add( int x) { value += x; } }
7. Copy Source | Copy HTML class A { public int value = 0 ; public void add( int x) { value += x; } }

')
I measured the speed on a Core 2 Duo E6300, Windows Vista, JRE 1.6.0_16. The Timer class is an auxiliary class for measuring time. For the measurement we will make 5 million calls of each method. Let's start with direct access to the class field:

Copy Source | Copy HTML

1. t.start ( "Direct field access" );
2. for ( int i = 0 ; i <LOOPS_IN_STEP_COUNT; ++ i) {
3. a. value + = i;
4. }
5. t.stop ();

5000000 iterations performed in 44ms. Time may vary from call to call, but in general, the result is this. Let's do the same with the use of reflection:

Copy Source | Copy HTML

1. t.start ( "Preparing for reflective field access" );
2. Field f = A. class .getField ( "value" );
3. t.stop ();
5. t.start ( "Reflective field access" );
6. for ( int i = 0 ; i <LOOPS_IN_STEP_COUNT; ++ i) {
7. f. set (a, ((Integer) f. get (a)) + i);
8. }
9. t.stop ();

Run for 11233ms - more than 250 times slower! Repeat the same thing, replacing direct work with fields on method calls.

Copy Source | Copy HTML

1. t.start ( "Direct method access" );
2. for ( int i = 0 ; i <LOOPS_IN_STEP_COUNT; ++ i) {
3. a.add (i);
4. }
5. t.stop ();
7. t.start ( "Preparing for reflective method access" );
8. Method m = A. class. GetDeclaredMethod ( "add" , int . Class );
9. t.stop ();
11. t.start ( "Reflective method access" );
12. for ( int i = 0 ; i <LOOPS_IN_STEP_COUNT; ++ i) {
13. m.invoke (a, i);
14. }
15. t.stop ();

A direct method call is slightly slower than direct access to the field and is performed in 51 ms. At the same time, the reflection-access to the method is slightly faster - 4177 ms - about 100 slower than direct access.

How to optimize it?

Reflection by means of JVM is implemented using slow JNI calls. CGLIB provides the FastMethod class, which provides the same functionality without using JNI, making calls much, much faster:

Copy Source | Copy HTML

1. t.start ( "Preparing for fast reflective method access" );
2. FastClass fc = FastClass.create (A. Class );
3. FastMethod fm = fc.getMethod (m);
4. t.stop ();
6. t.start ( "Fast reflective method access" );
7. for ( int i = 0 ; i <LOOPS_IN_STEP_COUNT; ++ i) {
8. fm.invoke (a, new Object [] {i});
9. }
10. t.stop ();

The result is 353 ms, which is only 7 times slower than the usual method call. If CGLIB had an analogue FastMethod for fields, we could compare and access fields.

Let's think about how you can achieve better results in the previous snippet. We have several costly operations: the first is to create an array in a loop, we can do with one array for all iterations of the loop. The other is boxing (auto-boxing) numbers. Suppose that a number is not a number, but an ordinary object and does not require boxing:

Copy Source | Copy HTML

1. class Ref {
2. int value ;
3. }
5. class A {
6. public int value = 0 ;
8. public void add ( Ref ref ) {
9. value + = ref . value ;
10. }
11. }
13. ...
15. t.start ( "Preparing for fast reflective method access (2)" );
16. FastClass fc2 = FastClass.create ( A. Class );
17. FastMethod fm2 = fc2.getMethod ( "add" , new Class [] { Ref . Class });
18. Ref ref = new Ref ();
19. Object [] arguments = new Object [] { ref };
20. t.stop ();
22. t.start ( "Fast reflective method access (2)" );
23. for ( int i = 0 ; i <LOOPS_IN_STEP_COUNT; ++ i) {
24. ref . value = i;
25. fm2.invoke (a, arguments);
26. }
27. t.stop ();

The result is 112ms. Only 2 times slower than the usual method call! However, why slower? The fact is that FastMethod is implemented using the Decorator design pattern . Let's try to decorate our class A and evaluate the result:

Copy Source | Copy HTML

1. interface AIf {
2. public void add ( int x);
3. }
5. class A implements AIf {
6. public int value = 0 ;
8. public void add ( int x) {
9. value + = x;
10. }
11. }
13. class ADecorator implements AIf {
14. private AIf a;
16. public ADecorator ( AIf a) {
17. this .a = a;
18. }
20. public void add ( int x) {
21. a.add (x);
22. }
23. }
24. ...
25. t.start ( "Preparing decorator method access" );
26. AIf d = new ADecorator (a);
27. t.stop ();
29. t.start ( "Decorator method access" );
30. for ( int i = 0 ; i <LOOPS_IN_STEP_COUNT; ++ i) {
31. d.add (i);
32. }
33. t.stop ();

Run for 124 ms - it turned out even slower than FastMethod. And since every good programmer uses design patterns, we can say that with some optimization, reflection can be as fast as direct calls without reflection.

Full listing:

Copy Source | Copy HTML

1. package reflection;
3. import net.sf.cglib.reflect.FastClass;
4. import net.sf.cglib.reflect.FastMethod;
6. import java.lang.reflect.Field;
7. import java.lang.reflect.InvocationTargetException;
8. import java.lang.reflect.Method;
9. import java.util. LinkedHashMap ;
10. import java.util.Map;
12. class Timer {
13. private long startTime = 0 ;
15. private String msg = null ;
17. private Map < String , Long > map = new LinkedHashMap < String , Long > ();
19. public void start ( String msg) {
20. if (startTime! = 0 ) {
21. throw new IllegalStateException ( "Already started" );
22. }
23. startTime = System.currentTimeMillis ();
24. this .msg = msg;
25. }
27. public void stop () {
28. if (startTime == 0 ) {
29. throw new IllegalStateException ( "Not started" );
30. }
31. long now = System.currentTimeMillis ();
32. Long n = map. get (msg);
33. if (n == null ) {
34. n = 0l;
35. }
36. n + = (now - startTime);
37. map.put (msg, n);
38. startTime = 0 ;
39. msg = null ;
40. }
42. public void output () {
43. for ( String msg: map.keySet ()) {
44. System. out .println (msg + ":" + map. get (msg));
45. }
46. }
47. }
49. class Ref {
50. int value ;
51. }
53. interface AIf {
54. public void add ( int x);
55. }
57. class A implements AIf {
58. public int value = 0 ;
60. public void add ( int x) {
61. value + = x;
62. }
64. public void add ( Ref ref ) {
65. value + = ref . value ;
66. }
67. }
69. class ADecorator implements AIf {
70. private AIf a;
72. public ADecorator ( AIf a) {
73. this .a = a;
74. }
76. public void add ( int x) {
77. a.add (x);
78. }
79. }
81. public class Reflect {
82. private static final int TOTAL_LOOP_COUNT = 5000000 ;
84. / ** <br/> * How many loops to do in one step. <br/> * /
85. private static final int LOOPS_IN_STEP_COUNT = 100 ;
87. / ** <br/> * How many steps to do in each step there will be <br/> * {@link #LOOPS_IN_STEP_COUNT} loops. <br/> * /
88. private static final int STEP_COUNT = TOTAL_LOOP_COUNT / LOOPS_IN_STEP_COUNT;
90. public static void main ( String [] args) throws SecurityException,
91. NoSuchFieldException, IllegalArgumentException,
92. IllegalAccessException, NoSuchMethodException,
93. InvocationTargetException {
95. Timer t = new Timer ();
96. A a = new A ();
98. for ( int j = 0 ; j <STEP_COUNT; ++ j) {
100. t.start ( "Direct field access" );
101. for ( int i = 0 ; i <LOOPS_IN_STEP_COUNT; ++ i) {
102. a. value + = i;
103. }
104. t.stop ();
106. t.start ( "Preparing for reflective field access" );
107. Field f = A. class .getField ( "value" );
108. t.stop ();
110. t.start ( "Reflective field access" );
111. for ( int i = 0 ; i <LOOPS_IN_STEP_COUNT; ++ i) {
112. f. set (a, ((Integer) f. get (a)) + i);
113. }
114. t.stop ();
116. t.start ( "Direct method access" );
117. for ( int i = 0 ; i <LOOPS_IN_STEP_COUNT; ++ i) {
118. a.add (i);
119. }
120. t.stop ();
122. t.start ( "Preparing for reflective method access" );
123. Method m = A. class .getDeclaredMethod ( "add" , int . class );
124. t.stop ();
126. t.start ( "Reflective method access" );
127. for ( int i = 0 ; i <LOOPS_IN_STEP_COUNT; ++ i) {
128. m.invoke (a, i);
129. }
130. t.stop ();
132. t.start ( "Preparing for fast reflective method access" );
133. FastClass fc = FastClass.create ( A. Class );
134. FastMethod fm = fc.getMethod (m);
135. t.stop ();
137. t.start ( "Fast reflective method access" );
138. for ( int i = 0 ; i <LOOPS_IN_STEP_COUNT; ++ i) {
139. fm.invoke (a, new Object [] {i});
140. }
141. t.stop ();
143. t.start ( "Preparing for fast reflective method access (2)" );
144. FastClass fc2 = FastClass.create ( A. Class );
145. FastMethod fm2 = fc2.getMethod ( "add" , new Class [] {
146. Ref . class
147. });
148. Ref ref = new Ref ();
149. Object [] arguments = new Object [] { ref };
150. t.stop ();
152. t.start ( "Fast reflective method access (2)" );
153. for ( int i = 0 ; i <LOOPS_IN_STEP_COUNT; ++ i) {
154. ref . value = i;
155. fm2.invoke (a, arguments);
156. }
157. t.stop ();
159. t.start ( "Preparing decorator method access" );
160. AIf d = new ADecorator (a);
161. t.stop ();
163. t.start ( "Decorator method access" );
164. for ( int i = 0 ; i <LOOPS_IN_STEP_COUNT; ++ i) {
165. d.add (i);
166. }
167. t.stop ();
169. }
171. t.output ();
172. }
173. }

And the result:

Direct field access: 44
Preparing for reflective field access: 765
Reflective field access: 11233
Direct method access: 51
Preparing for reflective method access: 1020
Reflective method access: 4177
Preparing for fast reflective method access: 1400
Fast reflective method access: 353
Preparing for fast reflective method access (2): 2164
Fast reflective method access (2): 112
Preparing decorator method access: 52
Decorator method access: 124

You may notice that the “preparation” takes some time, but this operation can be performed only once. “Preparation” of standard methods of reflection takes less than 1 ms, methods of CGLIB - about 100 ms. The point is that the generated class must be compiled and loaded by the class loader . However, such generation can be performed only once.

So, reflection in Java is not a bottleneck when using FastMethod from the CGLIB library. And after some optimizations, calls can be as fast as immediate calls. Now you can not be afraid to use these features in your code. However, it is important to remember that premature optimization leads to problems, and you need to optimize only the code that really is the bottleneck of your application.

Translator's note: I increased the number of iterations 10 times and ran (Intel Q6600, Vista x64, JRE 1.6.0_16 x64) the test cited in the article, obtained several other results - “decoration” had practically no effect on the time of 120 vs 168, and the final result turned out to be 6 times slower than a direct call, not 2 as in the article:

Direct field access: 170
Preparing for reflective field access: 1370
Reflective field access: 33928
Direct method access: 120
Preparing for reflective method access: 3382
Reflective method access: 21208
Preparing for fast reflective method access: 3043
Fast reflective method access: 1247
Preparing for fast reflective method access (2): 13174
Fast reflective method access (2): 741
Preparing decorator method access: 128
Decorator method access: 168