[GR-26713] Optimize #is_a?(Class) like Java's instanceof

PullRequest: truffleruby/2104

Author: eregon

src/main/java/org/truffleruby/core/klass/RubyClass.java

@@ -9,6 +9,7 @@
  */
 package org.truffleruby.core.klass;
 
+import java.util.Arrays;
 import java.util.Set;
 
 import com.oracle.truffle.api.source.SourceSection;
@@ -28,13 +29,19 @@
 @ExportLibrary(InteropLibrary.class)
 public final class RubyClass extends RubyModule implements ObjectGraphNode {
 
+    private static final RubyClass[] EMPTY_CLASS_ARRAY = new RubyClass[0];
+
     public final boolean isSingleton;
     /** If this is an object's metaclass, then nonSingletonClass is the logical class of the object. */
     public final RubyClass nonSingletonClass;
     public final RubyDynamicObject attached;
     public Shape instanceShape;
     /* a RubyClass, or nil for BasicObject, or null when not yet initialized */
     public Object superclass;
+    public RubyClass[] ancestorClasses;
+
+    /** Depth from BasicObject (= 0) in the inheritance hierarchy. */
+    public int depth;
 
     public RubyClass(
             RubyClass classClass,
@@ -50,20 +57,27 @@ public RubyClass(
         assert isSingleton == (instanceShape == null);
         this.isSingleton = isSingleton;
         this.attached = attached;
-        this.superclass = superclass;
         this.instanceShape = instanceShape;
 
+        if (superclass instanceof RubyClass) {
+            updateSuperclass((RubyClass) superclass);
+        } else { // BasicObject (nil superclass) or uninitialized class (null)
+            this.depth = 0;
+            this.superclass = superclass;
+            this.ancestorClasses = EMPTY_CLASS_ARRAY;
+        }
+
         this.nonSingletonClass = computeNonSingletonClass(isSingleton, superclass);
     }
 
-    /** Special constructor to build the 'Class' RubyClass itself */
+
+    /** Special constructor to build the 'Class' RubyClass itself. The superclass is set later. */
     RubyClass(RubyContext context, Shape classShape) {
         super(context, classShape, "constructor only for the class Class");
         this.isSingleton = false;
         this.attached = null;
         this.superclass = null;
         this.instanceShape = classShape;
-
         this.nonSingletonClass = this;
     }
 
@@ -86,10 +100,19 @@ public boolean isInitialized() {
 
     public void setSuperClass(RubyClass superclass) {
         assert this.superclass == null || this.superclass == superclass;
-        this.superclass = superclass;
+        updateSuperclass(superclass);
         fields.setSuperClass(superclass);
     }
 
+    private void updateSuperclass(RubyClass superclass) {
+        final RubyClass[] superAncestors = superclass.ancestorClasses;
+        final RubyClass[] ancestors = Arrays.copyOf(superAncestors, superAncestors.length + 1);
+        ancestors[superAncestors.length] = superclass;
+        this.superclass = superclass;
+        this.depth = superclass.depth + 1;
+        this.ancestorClasses = ancestors;
+    }
+
     @Override
     public void getAdjacentObjects(Set<Object> reachable) {
         super.getAdjacentObjects(reachable);

src/main/java/org/truffleruby/language/objects/IsANode.java

@@ -9,6 +9,7 @@
  */
 package org.truffleruby.language.objects;
 
+import com.oracle.truffle.api.profiles.ConditionProfile;
 import org.truffleruby.RubyLanguage;
 import org.truffleruby.core.klass.RubyClass;
 import org.truffleruby.core.module.ModuleOperations;
@@ -40,7 +41,7 @@ public static IsANode getUncached() {
                     "module == cachedModule" },
             assumptions = "getHierarchyUnmodifiedAssumption(cachedModule)",
             limit = "getCacheLimit()")
-    protected boolean isACached(Object self, RubyModule module,
+    protected boolean isAMetaClassCached(Object self, RubyModule module,
             @Cached MetaClassNode metaClassNode,
             @Cached("metaClassNode.execute(self)") RubyClass cachedMetaClass,
             @Cached("module") RubyModule cachedModule,
@@ -52,7 +53,38 @@ public Assumption getHierarchyUnmodifiedAssumption(RubyModule module) {
         return module.fields.getHierarchyUnmodifiedAssumption();
     }
 
-    @Specialization(replaces = "isACached")
+    @Specialization(
+            guards = "klass == cachedClass",
+            replaces = "isAMetaClassCached",
+            limit = "getCacheLimit()")
+    protected boolean isAClassCached(Object self, RubyClass klass,
+            @Cached MetaClassNode metaClassNode,
+            @Cached ConditionProfile isMetaClass,
+            @Cached("klass") RubyClass cachedClass) {
+        return isAClassUncached(self, klass, metaClassNode, isMetaClass);
+    }
+
+    @Specialization(replaces = "isAClassCached")
+    protected boolean isAClassUncached(Object self, RubyClass klass,
+            @Cached MetaClassNode metaClassNode,
+            @Cached ConditionProfile isMetaClass) {
+        final RubyClass metaclass = metaClassNode.execute(self);
+
+        if (isMetaClass.profile(metaclass == klass)) {
+            return true;
+        }
+
+        assert metaclass.ancestorClasses != null;
+
+        final int depth = klass.depth;
+        if (depth < metaclass.depth) { // < and not <= as we checked for equality above
+            return metaclass.ancestorClasses[depth] == klass;
+        }
+
+        return false;
+    }
+
+    @Specialization(guards = "!isRubyClass(module)", replaces = "isAMetaClassCached")
     protected boolean isAUncached(Object self, RubyModule module,
             @Cached MetaClassNode metaClassNode) {
         return isA(metaClassNode.execute(self), module);