[NFC] Use a SmallVector for HeapType children (#7565)

This was one of danleh's top findings in the mimalloc investigation,
where this method accounted for 25% (!) of all allocations.

I measured various sizes of SmallVectors and indeed it is possible to
get noticeably faster here: this PR is a 5% speedup for -O3 as a whole,
tested on a large Java testcase and a large Kotlin testcase.

The change to MinimizeRecGroups is NFC (the order is reversed, but it
doesn't matters). This is needed to compile, as our current SmallVector
doesn't have reverse iteration support (I looked into that for a few minutes
but it was not trivial to add; anyhow, the new code is idiomatic in the
codebase, I think).

Author: kripken

src/passes/MinimizeRecGroups.cpp

@@ -748,7 +748,9 @@ struct MinimizeRecGroups : Pass {
         if (seen.insert(curr).second) {
           dfsOrders[i].push_back(curr);
           auto children = curr.getReferencedHeapTypes();
-          workList.insert(workList.end(), children.rbegin(), children.rend());
+          for (auto child : children) {
+            workList.push_back(child);
+          }
         }
       }
       assert(dfsOrders[i].size() == types.size());

src/wasm-type.h

@@ -28,6 +28,7 @@
 #include "support/index.h"
 #include "support/name.h"
 #include "support/parent_index_iterator.h"
+#include "support/small_vector.h"
 #include "wasm-features.h"
 
 // TODO: At various code locations we were assuming that single types are basic
@@ -79,6 +80,10 @@ using HeapTypeNameGenerator = std::function<TypeNames(HeapType)>;
 // HeapType.
 using TypeID = uint64_t;
 
+// The number of HeapType children is typically small (1 for an array, and for
+// a struct, in practice <=4 is common).
+using HeapTypeChildren = SmallVector<HeapType, 4>;
+
 enum Shareability { Shared, Unshared };
 
 enum class HeapTypeKind {
@@ -242,11 +247,12 @@ class HeapType {
   std::vector<Type> getTypeChildren() const;
 
   // Return the ordered HeapType children, looking through child Types.
-  std::vector<HeapType> getHeapTypeChildren() const;
+  HeapTypeChildren getHeapTypeChildren() const;
 
-  // Similar to `getHeapTypeChildren`, but also includes the supertype if it
-  // exists.
-  std::vector<HeapType> getReferencedHeapTypes() const;
+  // Similar to `getHeapTypeChildren`, but also includes references types that
+  // are not children (i.e. that are not in fields of a struct, etc.; such
+  // referenced types include the super, and descriptor/described types).
+  HeapTypeChildren getReferencedHeapTypes() const;
 
   // Return the LUB of two HeapTypes, which may or may not exist.
   static std::optional<HeapType> getLeastUpperBound(HeapType a, HeapType b);
@@ -489,7 +495,7 @@ class Type {
   static bool isSubType(Type left, Type right);
 
   // Return the ordered HeapType children, looking through child Types.
-  std::vector<HeapType> getHeapTypeChildren();
+  HeapTypeChildren getHeapTypeChildren();
 
   // Computes the least upper bound from the type lattice.
   // If one of the type is unreachable, the other type becomes the result. If

src/wasm/wasm-type.cpp

@@ -361,7 +361,7 @@ template<typename Self> struct HeapTypeChildWalker : TypeGraphWalkerBase<Self> {
 };
 
 struct HeapTypeChildCollector : HeapTypeChildWalker<HeapTypeChildCollector> {
-  std::vector<HeapType> children;
+  HeapTypeChildren children;
   void noteChild(HeapType type) { children.push_back(type); }
 };
 
@@ -753,7 +753,7 @@ bool Type::isSubType(Type left, Type right) {
   return SubTyper().isSubType(left, right);
 }
 
-std::vector<HeapType> Type::getHeapTypeChildren() {
+HeapTypeChildren Type::getHeapTypeChildren() {
   HeapTypeChildCollector collector;
   collector.walkRoot(this);
   return collector.children;
@@ -1175,13 +1175,13 @@ std::vector<Type> HeapType::getTypeChildren() const {
   WASM_UNREACHABLE("unexpected kind");
 }
 
-std::vector<HeapType> HeapType::getHeapTypeChildren() const {
+HeapTypeChildren HeapType::getHeapTypeChildren() const {
   HeapTypeChildCollector collector;
   collector.walkRoot(const_cast<HeapType*>(this));
   return collector.children;
 }
 
-std::vector<HeapType> HeapType::getReferencedHeapTypes() const {
+HeapTypeChildren HeapType::getReferencedHeapTypes() const {
   auto types = getHeapTypeChildren();
   if (auto super = getDeclaredSuperType()) {
     types.push_back(*super);