Root specialized object classloader at JRuby classloader

The classes generated here need to be visible to other classes
loaded and generated by JRuby, such as Ruby classes that implement
Java interfaces. If the specialized class and a Java interface to
implement come from different classloader hierarchies, the JVM
classloading subsystem will be unable to resolve the impl class.

The fix here makes the RubyObjectSpecializer per-runtime, so the
specialized classes live within the standard JRubyClassLoader
hierarchy, visible to other classes loaded and generated by Ruby
code at runtime.

An additional fix will pre-generate the first 50 specialized
object classes, which will also fix the same issue (they will load
into the same classloader as JRuby itself) and avoid re-generating
these classes for each runtime instance.

Fixes jruby#8412.

Author: headius

core/src/main/java/org/jruby/Ruby.java

@@ -69,6 +69,7 @@
 import org.jruby.runtime.MethodIndex;
 import org.jruby.runtime.TraceEventManager;
 import org.jruby.runtime.invokedynamic.InvokeDynamicSupport;
+import org.jruby.specialized.RubyObjectSpecializer;
 import org.jruby.util.JavaNameMangler;
 import org.jruby.util.MRIRecursionGuard;
 import org.jruby.util.StringSupport;
@@ -343,6 +344,9 @@ private Ruby(RubyInstanceConfig config) {
         objectClass.setConstant("Module", moduleClass);
         objectClass.setConstant("Refinement", refinementClass);
 
+        // specializer for RubyObject subclasses
+        objectSpecializer = new RubyObjectSpecializer(this);
+
         // Initialize Kernel and include into Object
         RubyModule kernel = kernelModule = RubyKernel.createKernelModule(this);
         objectClass.includeModule(kernelModule);
@@ -2619,6 +2623,10 @@ public JavaSupport getJavaSupport() {
         return javaSupport;
     }
 
+    public RubyObjectSpecializer getObjectSpecializer() {
+        return objectSpecializer;
+    }
+
     public static ClassLoader getClassLoader() {
         // we try to getService the classloader that loaded JRuby, falling back on System
         ClassLoader loader = Ruby.class.getClassLoader();
@@ -5547,6 +5555,9 @@ public RubyClass getData() {
     private final JavaSupport javaSupport;
     private final JRubyClassLoader jrubyClassLoader;
 
+    // Object Specializer
+    private final RubyObjectSpecializer objectSpecializer;
+
     // Management/monitoring
     private final BeanManager beanManager;
 

core/src/main/java/org/jruby/RubyObject.java

@@ -176,7 +176,7 @@ public IRubyObject allocate(Ruby runtime, RubyClass klass) {
                             System.err.println(klass + ";" + foundVariables);
                         }
 
-                        allocator = RubyObjectSpecializer.specializeForVariables(klass, foundVariables);
+                        allocator = runtime.getObjectSpecializer().specializeForVariables(klass, foundVariables);
 
                         // invalidate metaclass so new allocator is picked up for specialized .new
                         klass.metaClass.invalidateCacheDescendants();

core/src/main/java/org/jruby/specialized/RubyObjectSpecializer.java

@@ -36,17 +36,12 @@
 import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.util.ClassDefiningClassLoader;
-import org.jruby.util.OneShotClassLoader;
 import org.jruby.util.cli.Options;
 import org.jruby.util.collections.NonBlockingHashMapLong;
 import org.objectweb.asm.Label;
 import org.objectweb.asm.tree.LabelNode;
 
-import java.lang.invoke.CallSite;
-import java.lang.invoke.LambdaMetafactory;
-import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
 import java.util.Set;
 
 import static org.jruby.util.CodegenUtils.ci;
@@ -60,13 +55,17 @@ public class RubyObjectSpecializer {
 
     public static final MethodHandles.Lookup LOOKUP = MethodHandles.lookup();
 
-    private static ClassAndAllocator getClassForSize(int size) {
-        return SPECIALIZED_CLASSES.get(size);
+    private final Ruby runtime;
+
+    private ClassAndAllocator getClassForSize(int size) {
+        return specializedClasses.get(size);
     }
 
-    private static final NonBlockingHashMapLong<ClassAndAllocator> SPECIALIZED_CLASSES = new NonBlockingHashMapLong<>();
+    private final NonBlockingHashMapLong<ClassAndAllocator> specializedClasses = new NonBlockingHashMapLong<>();
 
-    private static final ClassDefiningClassLoader LOADER = new OneShotClassLoader(Ruby.getClassLoader());
+    public RubyObjectSpecializer(Ruby runtime) {
+        this.runtime = runtime;
+    }
 
     static class ClassAndAllocator {
         final Class cls;
@@ -78,7 +77,7 @@ static class ClassAndAllocator {
         }
     }
 
-    public static ObjectAllocator specializeForVariables(RubyClass klass, Set<String> foundVariables) {
+    public ObjectAllocator specializeForVariables(RubyClass klass, Set<String> foundVariables) {
         int size = foundVariables.size();
 
         // clamp to max object width (jruby/jruby#
@@ -108,11 +107,11 @@ public static ObjectAllocator specializeForVariables(RubyClass klass, Set<String
         if (className != null) {
             final String clsPath = "org/jruby/gen/" + className;
 
-            synchronized (LOADER) {
+            synchronized (this) {
                 Class specialized;
                 try {
                     // try loading class without generating
-                    specialized = LOADER.loadClass(clsPath.replace('/', '.'));
+                    specialized = runtime.getJRubyClassLoader().loadClass(clsPath.replace('/', '.'));
                 } catch (ClassNotFoundException cnfe) {
                     // generate specialized class
                     specialized = generateInternal(size, clsPath);
@@ -124,7 +123,7 @@ public static ObjectAllocator specializeForVariables(RubyClass klass, Set<String
                     cna = new ClassAndAllocator(specialized, allocator);
 
                     if (!Options.REIFY_VARIABLES_NAME.load()) {
-                        SPECIALIZED_CLASSES.put(size, cna);
+                        specializedClasses.put(size, cna);
                     }
                 } catch (Throwable t) {
                     throw new RuntimeException(t);
@@ -155,7 +154,7 @@ public static ObjectAllocator specializeForVariables(RubyClass klass, Set<String
         return cna.allocator;
     }
 
-    private static Class generateInternal(int size, final String clsPath) {
+    private Class generateInternal(int size, final String clsPath) {
         // ensure only one thread will attempt to generate and define the new class
         final String baseName = p(RubyObject.class);
 
@@ -264,8 +263,8 @@ private static void genPutSwitch(String clsPath, int size, CodeBlock block, int
         block.label(defaultError);
     }
 
-    private static Class defineClass(JiteClass jiteClass) {
-        return LOADER.defineClass(classNameFromJiteClass(jiteClass), jiteClass.toBytes(JDKVersion.V1_8));
+    private Class defineClass(JiteClass jiteClass) {
+        return runtime.getJRubyClassLoader().defineClass(classNameFromJiteClass(jiteClass), jiteClass.toBytes(JDKVersion.V1_8));
     }
 
     private static String classNameFromJiteClass(JiteClass jiteClass) {