jruby · Mar 3, 2015 · Mar 3, 2015 · Mar 3, 2015 · Mar 3, 2015 · Mar 3, 2015
diff --git a/core/src/main/java/org/jruby/Ruby.java b/core/src/main/java/org/jruby/Ruby.java
@@ -1254,7 +1254,7 @@ private void init() {
         initThreadStatuses();
 
         // Create an IR manager and a top-level IR scope and bind it to the top-level static-scope object
-        irManager = new IRManager();
+        irManager = new IRManager(getInstanceConfig());
         // FIXME: This registers itself into static scope as a side-effect.  Let's make this
         // relationship handled either more directly or through a descriptice method
         // FIXME: We need a failing test case for this since removing it did not regress tests

diff --git a/core/src/main/java/org/jruby/compiler/JITCompiler.java b/core/src/main/java/org/jruby/compiler/JITCompiler.java
@@ -37,11 +37,9 @@
 import org.jruby.ast.util.SexpMaker;
 import org.jruby.internal.runtime.methods.CompiledIRMethod;
 import org.jruby.internal.runtime.methods.InterpretedIRMethod;
+import org.jruby.internal.runtime.methods.MixedModeIRMethod;
 import org.jruby.ir.IRMethod;
 import org.jruby.ir.targets.JVMVisitor;
-import org.jruby.parser.StaticScope;
-import org.jruby.runtime.Block;
-import org.jruby.runtime.Helpers;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.threading.DaemonThreadFactory;
@@ -52,10 +50,8 @@
 import org.jruby.util.log.LoggerFactory;
 import org.objectweb.asm.Opcodes;
 
-import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodType;
-import java.lang.reflect.Method;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.util.Locale;
@@ -150,8 +146,29 @@ public void tearDown() {
             }
         }
     }
+
+    public void fullBuildThresholdReached(final InterpretedIRMethod method, final RubyInstanceConfig config) {
+        // Disable any other jit tasks from entering queue
+        method.setCallCount(-1);
+
+        Runnable jitTask = new FullBuildTask(method);
+
+        // if background JIT is enabled and threshold is > 0 and we have an executor...
+        if (config.getJitBackground() && config.getJitThreshold() > 0 && executor != null) {
+            // JIT in background
+            try {
+                executor.submit(jitTask);
+            } catch (RejectedExecutionException ree) {
+                // failed to submit, just run it directly
+                jitTask.run();
+            }
+        } else {
+            // just run directly
+            jitTask.run();
+        }
+    }
 
-    public void jitThresholdReached(final InterpretedIRMethod method, final RubyInstanceConfig config, ThreadContext context, final String className, final String methodName) {
+    public void jitThresholdReached(final MixedModeIRMethod method, final RubyInstanceConfig config, ThreadContext context, final String className, final String methodName) {
         // Disable any other jit tasks from entering queue
         method.setCallCount(-1);
 
@@ -176,12 +193,38 @@ public void jitThresholdReached(final InterpretedIRMethod method, final RubyInst
 
     private static final MethodHandles.Lookup PUBLIC_LOOKUP = MethodHandles.publicLookup().in(Ruby.class);
 
+    private class FullBuildTask implements Runnable {
+        private final InterpretedIRMethod method;
+
+        public FullBuildTask(InterpretedIRMethod method) {
+            this.method = method;
+        }
+
+        public void run() {
+            try {
+                method.switchToFullBuild(method.getIRMethod().prepareFullBuild());
+
+                if (config.isJitLogging()) {
+                    log(method.getImplementationClass(), method.getFile(), method.getLine(),  method.getName(), "done building");
+                }
+            } catch (Throwable t) {
+                if (config.isJitLogging()) {
+                    log(method.getImplementationClass(), method.getFile(), method.getLine(), method.getName(),
+                            "Could not build; passes run: " + method.getIRMethod().getExecutedPasses(), t.getMessage());
+                    if (config.isJitLoggingVerbose()) {
+                        t.printStackTrace();
+                    }
+                }
+            }
+        }
+    }
+
     private class JITTask implements Runnable {
         private final String className;
-        private final InterpretedIRMethod method;
+        private final MixedModeIRMethod method;
         private final String methodName;
 
-        public JITTask(String className, InterpretedIRMethod method, String methodName) {
+        public JITTask(String className, MixedModeIRMethod method, String methodName) {
             this.className = className;
             this.method = method;
             this.methodName = methodName;
@@ -203,7 +246,7 @@ public void run() {
                             || config.getExcludedMethods().contains(excludeModuleName + "#" + methodName)
                             || config.getExcludedMethods().contains(methodName))) {
                         method.setCallCount(-1);
-                        log(method, methodName, "skipping method: " + excludeModuleName + "#" + methodName);
+                        log(method.getImplementationClass(), method.getFile(), method.getLine(), methodName, "skipping method: " + excludeModuleName + "#" + methodName);
                         return;
                     }
                 }
@@ -235,12 +278,12 @@ public void run() {
                 // logEvery n methods based on configuration
                 if (config.getJitLogEvery() > 0) {
                     if (methodCount % config.getJitLogEvery() == 0) {
-                        log(method, methodName, "live compiled methods: " + methodCount);
+                        log(method.getImplementationClass(), method.getFile(), method.getLine(), methodName, "live compiled methods: " + methodCount);
                     }
                 }
 
                 if (config.isJitLogging()) {
-                    log(method, className + "." + methodName, "done jitting");
+                    log(method.getImplementationClass(), method.getFile(), method.getLine(), className + "." + methodName, "done jitting");
                 }
 
                 Map<Integer, MethodType> signatures = ((IRMethod)method.getIRMethod()).getNativeSignatures();
@@ -273,7 +316,7 @@ public void run() {
                 return;
             } catch (Throwable t) {
                 if (config.isJitLogging()) {
-                    log(method, className + "." + methodName, "Could not compile; passes run: " + method.getIRMethod().getExecutedPasses(), t.getMessage());
+                    log(method.getImplementationClass(), method.getFile(), method.getLine(), className + "." + methodName, "Could not compile; passes run: " + method.getIRMethod().getExecutedPasses(), t.getMessage());
                     if (config.isJitLoggingVerbose()) {
                         t.printStackTrace();
                     }
@@ -305,7 +348,7 @@ public static String getHashForBytes(byte[] bytes) {
     }
 
     public static class JITClassGenerator {
-        public JITClassGenerator(String className, String methodName, String key, Ruby ruby, InterpretedIRMethod method, JVMVisitor visitor) {
+        public JITClassGenerator(String className, String methodName, String key, Ruby ruby, MixedModeIRMethod method, JVMVisitor visitor) {
             this.packageName = JITCompiler.RUBY_JIT_PREFIX;
             if (RubyInstanceConfig.JAVA_VERSION == Opcodes.V1_7 || Options.COMPILE_INVOKEDYNAMIC.load() == true) {
                 // Some versions of Java 7 seems to have a bug that leaks definitions across cousin classloaders
@@ -378,20 +421,20 @@ public String toString() {
         private final String className;
         private final String methodName;
         private final String digestString;
-        private final InterpretedIRMethod method;
+        private final MixedModeIRMethod method;
         private final JVMVisitor visitor;
 
         private byte[] bytecode;
         private long compileTime;
         private String name;
     }
 
-    static void log(InterpretedIRMethod method, String name, String message, String... reason) {
-        String className = method.getImplementationClass().getBaseName();
+    static void log(RubyModule implementationClass, String file, int line, String name, String message, String... reason) {
+        String className = implementationClass.getBaseName();
 
         if (className == null) className = "<anon class>";
 
-        StringBuilder builder = new StringBuilder(message + ":" + className + "." + name + " at " + method.getIRMethod().getFileName() + ":" + method.getIRMethod().getLineNumber());
+        StringBuilder builder = new StringBuilder(message + ":" + className + "." + name + " at " + file + ":" + line);
 
         if (reason.length > 0) {
             builder.append(" because of: \"");

diff --git a/core/src/main/java/org/jruby/internal/runtime/methods/InterpretedIRBodyMethod.java b/core/src/main/java/org/jruby/internal/runtime/methods/InterpretedIRBodyMethod.java
@@ -18,12 +18,12 @@ public class InterpretedIRBodyMethod extends InterpretedIRMethod {
     public InterpretedIRBodyMethod(IRScope method, RubyModule implementationClass) {
         super(method, Visibility.PUBLIC, implementationClass);
 
-        this.box.callCount = -1;
+        callCount = -1;
     }
 
     @Override
     public List<String[]> getParameterList() {
-        return new ArrayList<String[]>();
+        return new ArrayList<>();
     }
 
     @Override
@@ -40,10 +40,10 @@ public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule claz
             return ic.engine.interpret(context, self, ic, getImplementationClass().getMethodLocation(), name, block, null);
         } else {
             try {
-                this.pre(ic, context, self, name, block, getImplementationClass());
+                pre(ic, context, self, name, block, getImplementationClass());
                 return ic.engine.interpret(context, self, ic, getImplementationClass().getMethodLocation(), name, block, null);
             } finally {
-                this.post(ic, context);
+                post(ic, context);
             }
         }
     }

diff --git a/core/src/main/java/org/jruby/internal/runtime/methods/InterpretedIRMetaClassBody.java b/core/src/main/java/org/jruby/internal/runtime/methods/InterpretedIRMetaClassBody.java
@@ -36,11 +36,6 @@ protected void pre(InterpreterContext ic, ThreadContext context, IRubyObject sel
 
     @Override
     public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, Block block) {
-        DynamicMethodBox box = this.box;
-        if (box.callCount >= 0) tryJit(context, box);
-        DynamicMethod actualMethod = box.actualMethod;
-        if (actualMethod != null) return actualMethod.call(context, self, clazz, name, block);
-
         InterpreterContext ic = ensureInstrsReady();
 
         if (IRRuntimeHelpers.isDebug()) doDebug();
@@ -57,12 +52,4 @@ public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule claz
             }
         }
     }
-
-    @Override
-    public DynamicMethod dup() {
-        InterpretedIRMetaClassBody x = new InterpretedIRMetaClassBody(method, implementationClass);
-        x.dupBox(this);
-
-        return x;
-    }
 }