tighten up the indy code to try and get it to perform

Sam Pullara · Sam Pullara · commit de6fb8db3445 · 2012-03-05T21:38:22.000-08:00
diff --git a/indy/src/main/java/com/github/mustachejava/indy/IndyWrapper.java b/indy/src/main/java/com/github/mustachejava/indy/IndyWrapper.java
@@ -5,6 +5,7 @@
 import com.github.mustachejava.util.GuardException;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Handle;
+import org.objectweb.asm.Label;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
 import org.objectweb.asm.commons.GeneratorAdapter;
@@ -54,15 +55,11 @@ protected IndyWrapper(ReflectionWrapper rw) {
     super(rw);
   }
 
-  @Override
-  public Object call(Object[] scopes) throws GuardException {
-    guardCall(scopes);
-    Object scope = unwrap(scopes);
-    if (scope == null) return null;
-    return indy(scope);
-  }
-
-  public abstract Object indy(Object scope);
+  public abstract Object call(Object[] scopes) throws GuardException; // {
+//    guardCall(scopes);
+//    Object scope = unwrap(scopes);
+//    if (scope == null) return null;
+//    return indy(scope);
 
   public static IndyWrapper create(ReflectionWrapper rw) {
     String name;
@@ -92,10 +89,26 @@ public static IndyWrapper create(ReflectionWrapper rw) {
         ga.endMethod();
       }
       {
-        GeneratorAdapter ga = new GeneratorAdapter(ACC_PROTECTED,
-                org.objectweb.asm.commons.Method.getMethod("Object indy(Object)"), null, null, cw);
-        ga.loadThis();
-        ga.loadArg(0);
+        GeneratorAdapter ga = new GeneratorAdapter(ACC_PUBLIC,
+                org.objectweb.asm.commons.Method.getMethod("Object call(Object[])"), null,
+                new Type[] { Type.getType(GuardException.class)}, cw);
+        ga.visitVarInsn(ALOAD, 0);
+        ga.visitVarInsn(ALOAD, 1);
+        ga.invokeVirtual(Type.getType(IndyWrapper.class),
+                org.objectweb.asm.commons.Method.getMethod("void guardCall(Object[])"));
+        ga.visitVarInsn(ALOAD, 0);
+        ga.visitVarInsn(ALOAD, 1);
+        ga.invokeVirtual(Type.getType(IndyWrapper.class),
+                org.objectweb.asm.commons.Method.getMethod("Object unwrap(Object[])"));
+        ga.visitVarInsn(ASTORE, 2);
+        ga.visitVarInsn(ALOAD, 2);
+        Label l0 = new Label();
+        ga.ifNonNull(l0);
+        ga.visitInsn(ACONST_NULL);
+        ga.returnValue();
+        ga.visitLabel(l0);
+        ga.visitVarInsn(ALOAD, 0);
+        ga.visitVarInsn(ALOAD, 2);
         ga.invokeDynamic("bootstrap", METHOD_SIGNATURE, BOOTSTRAP_METHOD);
         ga.returnValue();
         ga.endMethod();
diff --git a/indy/src/main/java/com/github/mustachejava/mh/MHObjectHandler.java b/indy/src/main/java/com/github/mustachejava/mh/MHObjectHandler.java
@@ -0,0 +1,25 @@
+package com.github.mustachejava.mh;
+
+import com.github.mustachejava.indy.IndyWrapper;
+import com.github.mustachejava.reflect.ReflectionObjectHandler;
+import com.github.mustachejava.reflect.ReflectionWrapper;
+import com.github.mustachejava.util.Wrapper;
+import org.objectweb.asm.Opcodes;
+
+/**
+ * Creates custom classes instead of using reflection for handling objects. Leverages
+ * the ReflectionObjectHandler to create the original wrappers and converts them to
+ * new versions.
+ */
+public class MHObjectHandler extends ReflectionObjectHandler implements Opcodes {
+
+  @Override
+  public Wrapper find(String name, Object[] scopes) {
+    ReflectionWrapper rw = (ReflectionWrapper) super.find(name, scopes);
+    try {
+      return rw == null ? null : new MHWrapper(rw);
+    } catch (IllegalAccessException e) {
+      throw new RuntimeException(e);
+    }
+  }
+}
diff --git a/indy/src/main/java/com/github/mustachejava/mh/MHWrapper.java b/indy/src/main/java/com/github/mustachejava/mh/MHWrapper.java
@@ -0,0 +1,42 @@
+package com.github.mustachejava.mh;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+import com.github.mustachejava.MustacheException;
+import com.github.mustachejava.reflect.ReflectionWrapper;
+import com.github.mustachejava.util.GuardException;
+
+public class MHWrapper extends ReflectionWrapper {
+
+  private MethodHandle mh;
+
+  MHWrapper(ReflectionWrapper rw) throws IllegalAccessException {
+    super(rw);
+    Method method = rw.getMethod();
+    if (method == null) {
+      Field field = rw.getField();
+      mh = MethodHandles.lookup().unreflectGetter(field);
+    } else {
+      mh = MethodHandles.lookup().unreflect(method);
+    }
+  }
+
+  @Override
+  public Object call(Object[] scopes) throws GuardException {
+    try {
+      guardCall(scopes);
+      Object scope = unwrap(scopes);
+      if (scope == null) return null;
+      if (arguments == null) {
+        return mh.bindTo(scope).invokeWithArguments();
+      } else {
+        return mh.bindTo(scope).invokeExact(arguments);
+      }
+    } catch (Throwable e) {
+      throw new MustacheException("Failed to execute method: " + method, e);
+    }
+  }
+}
diff --git a/indy/src/test/java/IndyDemo.java b/indy/src/test/java/IndyDemo.java
@@ -0,0 +1,59 @@
+import java.lang.invoke.*;
+import java.lang.reflect.*;
+
+public class IndyDemo {
+  public static void main(String[] args) throws Throwable {
+    for (int i = 0; i < 10; i++) {
+      timeReflection();
+      timeIndy();
+    }
+  }
+
+  private static final String[] strings;
+
+  static {
+    strings = new String[100];
+    for (int i = 0; i < 100; i++) {
+      strings[i] = "string" + i;
+    }
+  }
+
+  public static void timeReflection() throws Throwable {
+    long start = System.currentTimeMillis();
+    for (int i = 0; i < 100000000; i++) {
+      REFLECTED.invoke(null, strings[i % 100]);
+    }
+    System.out.println("reflected: " + (System.currentTimeMillis() - start));
+  }
+
+  public static void timeIndy() throws Throwable {
+    long start = System.currentTimeMillis();
+    for (int i = 0; i < 100000000; i++) {
+      HANDLE.invokeExact(strings[i % 100]);
+    }
+    System.out.println("indy: " + (System.currentTimeMillis() - start));
+  }
+
+  private static final Method REFLECTED;
+  private static final MethodHandle HANDLE;
+
+  static {
+    Method method = null;
+    try {
+      method = IndyDemo.class.getMethod("someMethod", String.class);
+    } catch (Exception e) {}
+    REFLECTED = method;
+
+    MethodHandle handle = null;
+    try {
+      handle = MethodHandles.lookup().unreflect(REFLECTED);
+    } catch (Exception e) {}
+    HANDLE = handle;
+  }
+
+  public static int length = 0;
+
+  public static void someMethod(String a) {
+    length = a.length();
+  }
+}
diff --git a/indy/src/test/java/com/github/mustachejava/BenchmarkTest.java b/indy/src/test/java/com/github/mustachejava/BenchmarkTest.java
@@ -6,6 +6,7 @@
 import java.util.concurrent.Executors;
 
 import com.github.mustachejava.indy.IndyObjectHandler;
+import com.github.mustachejava.mh.MHObjectHandler;
 import junit.framework.TestCase;
 
 /**
@@ -99,21 +100,26 @@ private Writer complextest(Mustache m, Object complexObject) throws MustacheExce
   }
 
   private boolean indy = true;
-
   public static void main(String[] args) throws Exception {
     BenchmarkTest benchmarkTest = new BenchmarkTest();
     benchmarkTest.setUp();
+
+    benchmarkTest.indy = true;
     System.out.println("Indy");
     benchmarkTest.testComplex();
+
     benchmarkTest.indy = false;
     System.out.println("Reflection");
     benchmarkTest.testComplex();
+
     benchmarkTest.indy = true;
     System.out.println("Indy");
     benchmarkTest.testComplex();
+
     benchmarkTest.indy = false;
     System.out.println("Reflection");
     benchmarkTest.testComplex();
+
     System.exit(0);
   }
 }
