Use direct pointers as Type IDs

Instead of using indices into the global interned type table. This
means that a lock is *never* needed to access an expanded Type. The
Type lock is now only acquired when a complex Type is created. On a
real-world wasm2js workload this improves wall clock time by 23% on my
machine with 72 cores and makes traffic on the Type lock entirely
insignificant.

**Before**

72 cores
real    0m6.914s
user    184.014s
sys     0m3.995s

1 core
real    0m25.903s
user    0m25.658s
sys     0m0.253s

**After**

72 cores
real    5.349s
user    70.309s
sys     9.691s

1 core
real    25.859s
user    25.615s
sys     0.253s

Author: tlively

src/binaryen-c.h

@@ -90,7 +90,7 @@ typedef uint32_t BinaryenIndex;
 // Core types (call to get the value of each; you can cache them, they
 // never change)
 
-typedef uint32_t BinaryenType;
+typedef uintptr_t BinaryenType;
 
 BINARYEN_API BinaryenType BinaryenTypeNone(void);
 BINARYEN_API BinaryenType BinaryenTypeInt32(void);

src/passes/LocalCSE.cpp

@@ -63,7 +63,7 @@ struct LocalCSE : public WalkerPass<LinearExecutionWalker<LocalCSE>> {
 
   struct UsableHasher {
     HashType operator()(const Usable value) const {
-      return rehash(value.hashed.hash, value.localType.getID());
+      return rehash(uint64_t(value.hashed.hash), value.localType.getID());
     }
   };
 

src/wasm-type.h

@@ -24,11 +24,7 @@
 namespace wasm {
 
 class Type {
-  // enough for the limit of 1000 function arguments
-  static constexpr unsigned SIZE_BITS = 10;
-  static constexpr unsigned ID_BITS = 32 - SIZE_BITS;
-  unsigned id : ID_BITS;
-  unsigned _size : SIZE_BITS;
+  uintptr_t id;
   void init(const std::vector<Type>&);
 
 public:
@@ -44,20 +40,16 @@ class Type {
     anyref,
     nullref,
     exnref,
+    _last_value_type = exnref
   };
 
-private:
-  // Not in the enum because we don't want to have to have a case for it
-  static constexpr uint32_t last_value_type = exnref;
-
-public:
   Type() = default;
 
   // ValueType can be implicitly upgraded to Type
-  constexpr Type(ValueType id) : id(id), _size(id == none ? 0 : 1){};
+  constexpr Type(ValueType id) : id(id){};
 
   // But converting raw uint32_t is more dangerous, so make it explicit
-  explicit Type(uint32_t id);
+  explicit Type(uint64_t id) : id(id){};
 
   // Construct from lists of elementary types
   Type(std::initializer_list<Type> types);
@@ -68,8 +60,10 @@ class Type {
   const std::vector<Type>& expand() const;
 
   // Predicates
-  constexpr bool isSingle() const { return id >= i32 && id <= last_value_type; }
-  constexpr bool isMulti() const { return id > last_value_type; }
+  constexpr bool isSingle() const {
+    return id >= i32 && id <= _last_value_type;
+  }
+  constexpr bool isMulti() const { return id > _last_value_type; }
   constexpr bool isConcrete() const { return id >= i32; }
   constexpr bool isInteger() const { return id == i32 || id == i64; }
   constexpr bool isFloat() const { return id == f32 || id == f64; }
@@ -91,7 +85,7 @@ class Type {
   bool hasVector() { return hasPredicate<&Type::isVector>(); }
   bool hasRef() { return hasPredicate<&Type::isRef>(); }
 
-  constexpr uint32_t getID() const { return id; }
+  constexpr uint64_t getID() const { return id; }
   constexpr ValueType getSingle() const {
     assert(!isMulti() && "Unexpected multivalue type");
     return static_cast<ValueType>(id);

src/wasm/wasm-type.cpp

@@ -27,7 +27,7 @@
 template<> class std::hash<std::vector<wasm::Type>> {
 public:
   size_t operator()(const std::vector<wasm::Type>& types) const {
-    uint32_t res = wasm::rehash(0, uint32_t(types.size()));
+    uint64_t res = wasm::rehash(0, uint32_t(types.size()));
     for (auto t : types) {
       res = wasm::rehash(res, t.getID());
     }
@@ -36,13 +36,13 @@ template<> class std::hash<std::vector<wasm::Type>> {
 };
 
 size_t std::hash<wasm::Type>::operator()(const wasm::Type& type) const {
-  return std::hash<uint32_t>{}(type.getID());
+  return std::hash<uint64_t>{}(type.getID());
 }
 
 size_t std::hash<wasm::Signature>::
 operator()(const wasm::Signature& sig) const {
-  return std::hash<uint64_t>{}(uint64_t(sig.params.getID()) << 32 |
-                               uint64_t(sig.results.getID()));
+  return wasm::rehash(std::hash<uint64_t>{}(sig.params.getID()),
+                      std::hash<uint64_t>{}(sig.results.getID()));
 }
 
 namespace wasm {
@@ -52,28 +52,20 @@ namespace {
 // TODO: switch to std::shared_mutex in C++17
 std::shared_timed_mutex mutex;
 
-std::vector<std::unique_ptr<std::vector<Type>>> typeLists = [] {
-  std::vector<std::unique_ptr<std::vector<Type>>> lists;
-
-  auto add = [&](std::initializer_list<Type> types) {
-    return lists.push_back(std::make_unique<std::vector<Type>>(types));
-  };
-
-  add({});
-  add({Type::unreachable});
-  add({Type::i32});
-  add({Type::i64});
-  add({Type::f32});
-  add({Type::f64});
-  add({Type::v128});
-  add({Type::funcref});
-  add({Type::anyref});
-  add({Type::nullref});
-  add({Type::exnref});
-  return lists;
-}();
-
-std::unordered_map<std::vector<Type>, uint32_t> indices = {
+std::array<std::vector<Type>, Type::_last_value_type + 1> typeLists = {
+  std::vector<Type>{},
+  {Type::unreachable},
+  {Type::i32},
+  {Type::i64},
+  {Type::f32},
+  {Type::f64},
+  {Type::v128},
+  {Type::funcref},
+  {Type::anyref},
+  {Type::nullref},
+  {Type::exnref}};
+
+std::unordered_map<std::vector<Type>, uintptr_t> indices = {
   {{}, Type::none},
   {{Type::unreachable}, Type::unreachable},
   {{Type::i32}, Type::i32},
@@ -96,10 +88,14 @@ void Type::init(const std::vector<Type>& types) {
   }
 #endif
 
-  if (types.size() >= (1 << SIZE_BITS)) {
-    WASM_UNREACHABLE("Type too large");
+  if (types.size() == 0) {
+    id = none;
+    return;
+  }
+  if (types.size() == 1) {
+    *this = types[0];
+    return;
   }
-  _size = types.size();
 
   auto lookup = [&]() {
     auto indexIt = indices.find(types);
@@ -124,11 +120,9 @@ void Type::init(const std::vector<Type>& types) {
     if (lookup()) {
       return;
     }
-    if (typeLists.size() >= (1 << ID_BITS)) {
-      WASM_UNREACHABLE("Too many types!");
-    }
-    id = typeLists.size();
-    typeLists.push_back(std::make_unique<std::vector<Type>>(types));
+    auto* vec = new std::vector<Type>(types);
+    id = uintptr_t(vec);
+    assert(id > _last_value_type);
     indices[types] = id;
   }
 }
@@ -137,23 +131,14 @@ Type::Type(std::initializer_list<Type> types) { init(types); }
 
 Type::Type(const std::vector<Type>& types) { init(types); }
 
-Type::Type(uint32_t _id) {
-  if (_id <= last_value_type) {
-    *this = Type(static_cast<ValueType>(_id));
-  } else {
-    id = _id;
-    // Unknown complex type; look up the size
-    std::shared_lock<std::shared_timed_mutex> lock(mutex);
-    _size = typeLists[id]->size();
-  }
-}
-
-size_t Type::size() const { return _size; }
+size_t Type::size() const { return expand().size(); }
 
 const std::vector<Type>& Type::expand() const {
-  std::shared_lock<std::shared_timed_mutex> lock(mutex);
-  assert(id < typeLists.size());
-  return *typeLists[id].get();
+  if (id <= _last_value_type) {
+    return typeLists[id];
+  } else {
+    return *(std::vector<Type>*)id;
+  }
 }
 
 bool Type::operator<(const Type& other) const {