Avoid prefilling subclasses array with nil until end

We know we'll fill or nearly fill the array with other references,
so pre-filling with nil is wasted effort. This change introduces
a "raw" array sequence: create raw array with default nulls, fill
with values, then replace remaining nulls with nil.

Author: headius

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

@@ -95,6 +95,7 @@
 import static org.jruby.runtime.Helpers.addBufferLength;
 import static org.jruby.runtime.Helpers.arrayOf;
 import static org.jruby.runtime.Helpers.calculateBufferLength;
+import static org.jruby.runtime.Helpers.fillNil;
 import static org.jruby.runtime.Helpers.hashEnd;
 import static org.jruby.runtime.Helpers.murmurCombine;
 import static org.jruby.runtime.Helpers.validateBufferLength;
@@ -193,6 +194,30 @@ public static final RubyArray newArrayLight(final Ruby runtime, final int len) {
         return new RubyArray(runtime, runtime.getArray(), values, 0, 0, false);
     }
 
+    /**
+     * Construct an array with the specified backing storage length. The array must be filled with non-null values
+     * before entering Rubyspace.
+     *
+     * @param context the current context
+     * @param len the length of the array buffer requested
+     * @return an array with the given buffer size, entries initialized to null
+     */
+    public static RubyArray newArrayRaw(final ThreadContext context, final int len) {
+        Ruby runtime = context.runtime;
+        return new RubyArray(runtime, runtime.getArray(), IRubyObject.array(len), 0, 0, false);
+    }
+
+    /**
+     * Fill the remaining array slots with the given value. Pair with newArrayRaw to reduce the cost of setting up a new array.
+     *
+     */
+    public void fillRestWithNil(final ThreadContext context) {
+        int realLength = this.realLength;
+        IRubyObject[] values = this.values;
+        if (realLength == values.length) return;
+        fillNil(values, realLength, values.length, context.runtime);
+    }
+
     /** rb_ary_new
      *
      */

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

@@ -1014,7 +1014,7 @@ public IRubyObject initialize_copy(IRubyObject original) {
     public IRubyObject subclasses(ThreadContext context) {
         RubyArray<RubyClass> subs = newConcreteSubclassesArray(context);
         int clearedCount = concreteSubclasses(subs);
-        finishConcreteSubclasses(subs, clearedCount);
+        finishConcreteSubclasses(context, subs, clearedCount);
 
         return subs;
     }
@@ -1059,7 +1059,7 @@ public Collection<RubyClass> subclasses(boolean includeDescendants) {
     }
 
     private RubyArray<RubyClass> newConcreteSubclassesArray(ThreadContext context) {
-        RubyArray<RubyClass> subs = RubyArray.newArray(context.runtime, this.concreteSubclassesEstimate);
+        RubyArray<RubyClass> subs = RubyArray.newArrayRaw(context, this.concreteSubclassesEstimate);
         return subs;
     }
 
@@ -1103,39 +1103,44 @@ private void finishSubclasses(Collection<RubyClass> mine, int clearedCount, bool
 
     private int concreteSubclasses(RubyArray<RubyClass> subs) {
         SubclassNode subclassNode = this.subclassNode;
+
+        // skip first entry if not concrete
+        if (!subclassNode.concrete) subclassNode = subclassNode.nextConcrete;
+
         int clearedCount = 0;
         while (subclassNode != null) {
             RubyClass klass = subclassNode.ref.get();
             subclassNode = subclassNode.nextConcrete;
 
             if (klass == null) {
                 clearedCount++;
-                continue;
+            } else {
+                processConcreteSubclass(subs, klass);
             }
 
-            processConcreteSubclass(subs, klass);
         }
         return clearedCount;
     }
 
     private static void processConcreteSubclass(RubyArray<RubyClass> subs, RubyClass klass) {
-        if (!klass.isSingleton()) {
-            if (klass.isIncluded() || klass.isPrepended()) {
-                klass.concreteSubclasses(subs);
-            } else {
-                subs.append(klass);
-            }
+        assert !klass.isSingleton();
+
+        if (klass.isIncluded() || klass.isPrepended()) {
+            klass.concreteSubclasses(subs);
+        } else {
+            subs.append(klass);
         }
     }
 
-    private void finishConcreteSubclasses(RubyArray<RubyClass> subs, int clearedCount) {
+    private void finishConcreteSubclasses(ThreadContext context, RubyArray<RubyClass> subs, int clearedCount) {
+        subs.fillRestWithNil(context);
         int newSize = subs.size();
-        concreteSubclassesEstimate = newSize + 4;
+        concreteSubclassesEstimate = newSize;
         cleanSubclasses(newSize, clearedCount);
     }
 
     private void cleanSubclasses(int size, int vacated) {
-        // tidy up if more than 25% cleared references
+        // tidy up if more than threshold of cleared references
         if ((double) vacated / size > SUBCLASSES_CLEAN_FACTOR) {
             SubclassNode subclassNode = this.subclassNode;
             SubclassNode newTop = rebuildSubclasses(subclassNode);