Optimize Class#subclasses

There were several issues with the old implementation:

* Iterating by creating a Set and an Iterator adds significant
  allocation overhead. Better to use Map#forEach.
* ConcurrentWeakHashMap is a very old implementation that has
  several inefficiencies as well as no custom implementation of
  Map#forEach (it falls back on the default impl which creates a
  Set and Iterator). Instead we use a synchronized WeakHashMap.
* The initial array was created with a default size of 4 elements.
  For many classes this will be insufficient, leading to excessive
  array allocation and copying as it grows. Instead we use the
  current class's "subclasses" size as an initial estimate.
* When no subclasses appear to be present, bail out early with
  an empty array that does minimal allocation.

Performance is significantly better for zero, small, and large
subclass lists.

1M * Object.subclasses, with 83 elements:

Before:

  2.020000   0.040000   2.060000 (  1.823539)
  1.980000   0.030000   2.010000 (  1.737808)
  1.830000   0.010000   1.840000 (  1.738772)
  1.730000   0.020000   1.750000 (  1.740675)
  1.720000   0.000000   1.720000 (  1.707344)

After:

  1.340000   0.020000   1.360000 (  1.034745)
  0.930000   0.000000   0.930000 (  0.918107)
  0.920000   0.010000   0.930000 (  0.914828)
  0.920000   0.000000   0.920000 (  0.922137)
  0.920000   0.000000   0.920000 (  0.915440)

10M * Numeric.subclasses, with 4 elements:

Before:

  0.930000   0.030000   0.960000 (  0.789997)
  0.640000   0.010000   0.650000 (  0.621404)
  0.620000   0.010000   0.630000 (  0.614404)
  0.630000   0.000000   0.630000 (  0.629492)
  0.630000   0.010000   0.640000 (  0.608538)

After:

  0.720000   0.010000   0.730000 (  0.559470)
  0.460000   0.000000   0.460000 (  0.454176)
  0.510000   0.000000   0.510000 (  0.429875)
  0.430000   0.010000   0.440000 (  0.434487)
  0.430000   0.000000   0.430000 (  0.427971)

Fixes jruby#8457

Author: headius

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

@@ -93,7 +93,7 @@
 import org.jruby.util.Loader;
 import org.jruby.util.OneShotClassLoader;
 import org.jruby.util.StringSupport;
-import org.jruby.util.collections.ConcurrentWeakHashMap;
+import org.jruby.util.WeakIdentityHashMap;
 import org.jruby.util.log.Logger;
 import org.jruby.util.log.LoggerFactory;
 import org.objectweb.asm.AnnotationVisitor;
@@ -1019,7 +1019,14 @@ protected void setModuleSuperClass(RubyClass superClass) {
 
     @JRubyMethod
     public IRubyObject subclasses(ThreadContext context) {
-        RubyArray<RubyClass> subs = RubyArray.newArray(context.runtime);
+        Map<RubyClass, Object> subclasses = this.subclasses;
+        int sizeEstimate = subclasses == null ? 0 : subclasses.size();
+
+        if (sizeEstimate == 0) {
+            return RubyArray.newEmptyArray(context.runtime);
+        }
+
+        RubyArray<RubyClass> subs = RubyArray.newArray(context.runtime, sizeEstimate);
 
         concreteSubclasses(subs);
 
@@ -1081,18 +1088,18 @@ private void subclassesInner(Collection<RubyClass> mine, boolean includeDescenda
         }
     }
 
-    private void concreteSubclasses(Collection<RubyClass> subs) {
+    private void concreteSubclasses(RubyArray<RubyClass> subs) {
         Map<RubyClass, Object> subclasses = this.subclasses;
         if (subclasses != null) {
-            Set<RubyClass> keys = subclasses.keySet();
-            for (RubyClass klass: keys) {
-                if (klass.isSingleton()) continue;
-                if (klass.isIncluded() || klass.isPrepended()) {
-                    klass.concreteSubclasses(subs);
-                    continue;
+            subclasses.forEach((klass, $) -> {
+                if (!klass.isSingleton()) {
+                    if (klass.isIncluded() || klass.isPrepended()) {
+                        klass.concreteSubclasses(subs);
+                    } else {
+                        subs.append(klass);
+                    }
                 }
-                subs.add(klass);
-            }
+            });
         }
     }
 
@@ -1112,7 +1119,7 @@ public void addSubclass(RubyClass subclass) {
             synchronized (this) {
                 subclasses = this.subclasses;
                 if (subclasses == null) {
-                    this.subclasses = subclasses = new ConcurrentWeakHashMap<>(4, 0.75f, 1);
+                    this.subclasses = subclasses = Collections.synchronizedMap(new WeakHashMap<>(4));
                 }
             }
         }