Merge pull request jruby#8433 from headius/specialized_object_classloader

headius · web-flow · commit c5fb69e61c00 · 2024-11-20T08:15:06.000-06:00
Root specialized object classloader at JRuby classloader
diff --git a/core/pom.rb b/core/pom.rb
@@ -166,6 +166,16 @@
                                       '${project.build.outputDirectory}' ],
                      'executable' =>  'java',
                      'classpathScope' =>  'compile' )
+
+      execute_goals( 'exec',
+                     :id => 'specialized-object-generator',
+                     'arguments' => [ '-Djruby.bytecode.version=${base.java.version}',
+                                      '-classpath',
+                                      xml( '<classpath/>' ),
+                                      'org.jruby.specialized.RubyObjectSpecializer',
+                                      '${project.build.outputDirectory}' ],
+                     'executable' =>  'java',
+                     'classpathScope' =>  'compile' )
     end
   end
 
diff --git a/core/pom.xml b/core/pom.xml
@@ -417,6 +417,24 @@ DO NOT MODIFY - GENERATED CODE
               <classpathScope>compile</classpathScope>
             </configuration>
           </execution>
+          <execution>
+            <id>specialized-object-generator</id>
+            <phase>process-classes</phase>
+            <goals>
+              <goal>exec</goal>
+            </goals>
+            <configuration>
+              <arguments>
+                <argument>-Djruby.bytecode.version=${base.java.version}</argument>
+                <argument>-classpath</argument>
+                <classpath />
+                <argument>org.jruby.specialized.RubyObjectSpecializer</argument>
+                <argument>${project.build.outputDirectory}</argument>
+              </arguments>
+              <executable>java</executable>
+              <classpathScope>compile</classpathScope>
+            </configuration>
+          </execution>
         </executions>
       </plugin>
       <plugin>
diff --git a/core/src/main/java/org/jruby/Ruby.java b/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;
 
diff --git a/core/src/main/java/org/jruby/RubyObject.java b/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();
diff --git a/core/src/main/java/org/jruby/specialized/RubyObjectSpecializer.java b/core/src/main/java/org/jruby/specialized/RubyObjectSpecializer.java
@@ -35,18 +35,14 @@
 import org.jruby.runtime.Helpers;
 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.nio.file.Files;
+import java.nio.file.Paths;
 import java.util.Set;
 
 import static org.jruby.util.CodegenUtils.ci;
@@ -59,14 +55,19 @@
 public class RubyObjectSpecializer {
 
     public static final MethodHandles.Lookup LOOKUP = MethodHandles.lookup();
+    private static final String GENERATED_PACKAGE = "org/jruby/gen/";
 
-    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,57 +79,21 @@ static class ClassAndAllocator {
         }
     }
 
-    public static ObjectAllocator specializeForVariables(RubyClass klass, Set<String> foundVariables) {
-        int size = foundVariables.size();
-
-        // clamp to max object width (jruby/jruby#
-        size = Math.min(size, Options.REIFY_VARIABLES_MAX.load());
+    public ObjectAllocator specializeForVariables(RubyClass klass, Set<String> foundVariables) {
+        // clamp to max object width
+        int size = Math.min(foundVariables.size(), Options.REIFY_VARIABLES_MAX.load());
 
-        ClassAndAllocator cna = null;
-        String className = null;
+        ClassAndAllocator cna;
 
         if (Options.REIFY_VARIABLES_NAME.load()) {
-            className = klass.getName();
-
-            if (className.startsWith("#")) {
-                className = "Anonymous" + Integer.toHexString(System.identityHashCode(klass));
-            } else {
-                className = className.replace("::", "/");
-            }
+            // use Ruby class name for debugging, profiling
+            cna = generateSpecializedRubyObject(uniqueClassName(klass), size, false);
         } else {
-            // Generate class for specified size
+            // Generic class for specified size
             cna = getClassForSize(size);
 
             if (cna == null) {
-                className = "RubyObject" + size;
-            }
-        }
-
-        // if we have a className, proceed to generate
-        if (className != null) {
-            final String clsPath = "org/jruby/gen/" + className;
-
-            synchronized (LOADER) {
-                Class specialized;
-                try {
-                    // try loading class without generating
-                    specialized = LOADER.loadClass(clsPath.replace('/', '.'));
-                } catch (ClassNotFoundException cnfe) {
-                    // generate specialized class
-                    specialized = generateInternal(size, clsPath);
-                }
-
-                try {
-                    ObjectAllocator allocator = (ObjectAllocator) specialized.getDeclaredClasses()[0].getConstructor().newInstance();
-
-                    cna = new ClassAndAllocator(specialized, allocator);
-
-                    if (!Options.REIFY_VARIABLES_NAME.load()) {
-                        SPECIALIZED_CLASSES.put(size, cna);
-                    }
-                } catch (Throwable t) {
-                    throw new RuntimeException(t);
-                }
+                cna = generateSpecializedRubyObject(genericClassName(size), size, true);
             }
         }
 
@@ -155,7 +120,78 @@ public static ObjectAllocator specializeForVariables(RubyClass klass, Set<String
         return cna.allocator;
     }
 
-    private static Class generateInternal(int size, final String clsPath) {
+    private ClassAndAllocator generateSpecializedRubyObject(String className, int size, boolean cache) {
+        ClassAndAllocator cna;
+
+        synchronized (this) {
+            Class specialized;
+            try {
+                // try loading class without generating
+                specialized = runtime.getJRubyClassLoader().loadClass(className.replace('/', '.'));
+            } catch (ClassNotFoundException cnfe) {
+                // generate specialized class
+                specialized = generateInternal(className, size);
+            }
+
+            try {
+                ObjectAllocator allocator = (ObjectAllocator) specialized.getDeclaredClasses()[0].getConstructor().newInstance();
+
+                cna = new ClassAndAllocator(specialized, allocator);
+            } catch (Throwable t) {
+                throw new RuntimeException(t);
+            }
+        }
+
+        if (cache) {
+            specializedClasses.put(size, cna);
+        }
+
+        return cna;
+    }
+
+    private static String genericClassName(int size) {
+        return GENERATED_PACKAGE + "RubyObject" + size;
+    }
+
+    private static String uniqueClassName(RubyClass klass) {
+        String className = klass.getName();
+
+        if (className.startsWith("#")) {
+            className = "Anonymous" + Integer.toHexString(System.identityHashCode(klass));
+        } else {
+            className = className.replace("::", "/");
+        }
+
+        return GENERATED_PACKAGE + className;
+    }
+
+    /**
+     * Emit all generic RubyObject specializations to disk, so they do not need to generate at runtime.
+     */
+    public static void main(String[] args) throws Throwable {
+        String targetPath = args[0];
+
+        Files.createDirectories(Paths.get(targetPath, GENERATED_PACKAGE));
+
+        int maxVars = Options.REIFY_VARIABLES_MAX.load();
+        for (int i = 0; i <= maxVars; i++) {
+            String clsPath = genericClassName(i);
+            JiteClass jcls = generateJiteClass(clsPath, i);
+            Files.write(Paths.get(targetPath, clsPath + ".class"), jcls.toBytes(JDKVersion.V1_8));
+            Files.write(Paths.get(targetPath, clsPath + "Allocator.class"), jcls.getChildClasses().get(0).toBytes(JDKVersion.V1_8));
+        }
+    }
+
+    private Class generateInternal(final String clsPath, int size) {
+        final JiteClass jiteClass = generateJiteClass(clsPath, size);
+
+        Class specializedClass = defineClass(jiteClass);
+        defineClass(jiteClass.getChildClasses().get(0));
+
+        return specializedClass;
+    }
+
+    private static JiteClass generateJiteClass(String clsPath, int size) {
         // ensure only one thread will attempt to generate and define the new class
         final String baseName = p(RubyObject.class);
 
@@ -222,11 +258,7 @@ private static Class generateInternal(int size, final String clsPath) {
                 }});
             }});
         }};
-
-        Class specializedClass = defineClass(jiteClass);
-        defineClass(jiteClass.getChildClasses().get(0));
-
-        return specializedClass;
+        return jiteClass;
     }
 
     private static void genGetSwitch(String clsPath, int size, CodeBlock block, int offsetVar) {
@@ -264,8 +296,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) {
diff --git a/spec/java_integration/interfaces/implementation_spec.rb b/spec/java_integration/interfaces/implementation_spec.rb
@@ -827,6 +827,25 @@ def bar
 
     expect(java_cls.interfaces).to include(java.lang.Runnable.java_class)
   end
+
+
+  describe "that extends a specializable RubyObject" do
+    class C1
+    end
+
+    it "produces a Java class that extends that specialized type" do
+      # construct C1 first to use specialized class
+      c1obj = C1.new
+
+      c2 = Class.new(C1) do
+        include ReturnsInterface
+      end
+
+      c2obj = c2.new
+
+      expect(JRuby.ref(c2obj).getClass.getSuperclass).to eq(JRuby.ref(c1obj).getClass)
+    end
+  end
 end
 
 describe "A class that extends a DelegateClass" do

Original file line number	Diff line number	Diff line change
`@@ -176,7 +176,7 @@ public IRubyObject allocate(Ruby runtime, RubyClass klass) {`
`176`	`176`	`System.err.println(klass + ";" + foundVariables);`
`177`	`177`	`}`
`178`	`178`
`179`		`- allocator = RubyObjectSpecializer.specializeForVariables(klass, foundVariables);`
	`179`	`+ allocator = runtime.getObjectSpecializer().specializeForVariables(klass, foundVariables);`
`180`	`180`
`181`	`181`	`// invalidate metaclass so new allocator is picked up for specialized .new`
`182`	`182`	`klass.metaClass.invalidateCacheDescendants();`