Back out "Revert D17936166: [wip] Constexpr type ids" (#28155)

Summary:
Pull Request resolved: https://github.com/pytorch/pytorch/pull/28155

Original commit changeset: 92c63a96dedd
ghstack-source-id: 92051874

Test Plan: unit tests

Differential Revision: D17964410

fbshipit-source-id: 1d989d28b3e1de6d43c915f122f2b65a77a332eb
diff --git a/c10/test/util/ConstexprCrc_test.cpp b/c10/test/util/ConstexprCrc_test.cpp
new file mode 100644
index 0000000..b115c23
--- /dev/null
+++ b/c10/test/util/ConstexprCrc_test.cpp
@@ -0,0 +1,23 @@
+#include <c10/util/ConstexprCrc.h>
+
+using c10::util::crc64_t;
+
+namespace {
+template <size_t N>
+constexpr crc64_t crc64(const char (&input)[N]) {
+  return c10::util::crc64(input, N - 1);
+}
+} // namespace
+
+// generic tests
+static_assert(
+    crc64("MyTestString") == crc64("MyTestString"),
+    "crc64 is deterministic");
+static_assert(
+    crc64("MyTestString1") != crc64("MyTestString2"),
+    "different strings, different result");
+
+// check concrete expected values (for CRC64 with Jones coefficients and an init
+// value of 0)
+static_assert(crc64_t{0} == crc64(""), "");
+static_assert(crc64_t{0xe9c6d914c4b8d9ca} == crc64("123456789"), "");
diff --git a/c10/test/util/TypeIndex_test.cpp b/c10/test/util/TypeIndex_test.cpp
new file mode 100644
index 0000000..18c3e569
--- /dev/null
+++ b/c10/test/util/TypeIndex_test.cpp
@@ -0,0 +1,53 @@
+#include <c10/util/Metaprogramming.h>
+#include <c10/util/TypeIndex.h>
+
+using c10::util::get_type_index;
+
+namespace {
+
+static_assert(get_type_index<int>() == get_type_index<int>(), "");
+static_assert(get_type_index<float>() == get_type_index<float>(), "");
+static_assert(get_type_index<int>() != get_type_index<float>(), "");
+static_assert(
+    get_type_index<int(double, double)>() ==
+        get_type_index<int(double, double)>(),
+    "");
+static_assert(
+    get_type_index<int(double, double)>() != get_type_index<int(double)>(),
+    "");
+static_assert(
+    get_type_index<int(double, double)>() ==
+        get_type_index<int (*)(double, double)>(),
+    "");
+static_assert(
+    get_type_index<std::function<int(double, double)>>() ==
+        get_type_index<std::function<int(double, double)>>(),
+    "");
+static_assert(
+    get_type_index<std::function<int(double, double)>>() !=
+        get_type_index<std::function<int(double)>>(),
+    "");
+
+static_assert(get_type_index<int>() == get_type_index<int&>(), "");
+static_assert(get_type_index<int>() == get_type_index<int&&>(), "");
+static_assert(get_type_index<int>() == get_type_index<const int&>(), "");
+static_assert(get_type_index<int>() == get_type_index<const int>(), "");
+static_assert(get_type_index<const int>() == get_type_index<int&>(), "");
+static_assert(get_type_index<int>() != get_type_index<int*>(), "");
+static_assert(get_type_index<int*>() != get_type_index<int**>(), "");
+static_assert(
+    get_type_index<int(double&, double)>() !=
+        get_type_index<int(double, double)>(),
+    "");
+
+struct Dummy final {};
+struct Functor final {
+  int64_t operator()(uint32_t, Dummy&&, const Dummy&) const;
+};
+static_assert(
+    get_type_index<int64_t(uint32_t, Dummy&&, const Dummy&)>() ==
+        get_type_index<
+            c10::guts::infer_function_traits_t<Functor>::func_type>(),
+    "");
+
+} // namespace
diff --git a/c10/util/ConstexprCrc.h b/c10/util/ConstexprCrc.h
new file mode 100644
index 0000000..d61091d
--- /dev/null
+++ b/c10/util/ConstexprCrc.h
@@ -0,0 +1,137 @@
+#pragma once
+
+#include <c10/util/IdWrapper.h>
+#include <cstddef>
+#include <cstdint>
+
+namespace c10 {
+namespace util {
+
+namespace detail {
+constexpr uint64_t crc64_table[] = {
+    0x0000000000000000, 0x7ad870c830358979, 0xf5b0e190606b12f2,
+    0x8f689158505e9b8b, 0xc038e5739841b68f, 0xbae095bba8743ff6,
+    0x358804e3f82aa47d, 0x4f50742bc81f2d04, 0xab28ecb46814fe75,
+    0xd1f09c7c5821770c, 0x5e980d24087fec87, 0x24407dec384a65fe,
+    0x6b1009c7f05548fa, 0x11c8790fc060c183, 0x9ea0e857903e5a08,
+    0xe478989fa00bd371, 0x7d08ff3b88be6f81, 0x07d08ff3b88be6f8,
+    0x88b81eabe8d57d73, 0xf2606e63d8e0f40a, 0xbd301a4810ffd90e,
+    0xc7e86a8020ca5077, 0x4880fbd87094cbfc, 0x32588b1040a14285,
+    0xd620138fe0aa91f4, 0xacf86347d09f188d, 0x2390f21f80c18306,
+    0x594882d7b0f40a7f, 0x1618f6fc78eb277b, 0x6cc0863448deae02,
+    0xe3a8176c18803589, 0x997067a428b5bcf0, 0xfa11fe77117cdf02,
+    0x80c98ebf2149567b, 0x0fa11fe77117cdf0, 0x75796f2f41224489,
+    0x3a291b04893d698d, 0x40f16bccb908e0f4, 0xcf99fa94e9567b7f,
+    0xb5418a5cd963f206, 0x513912c379682177, 0x2be1620b495da80e,
+    0xa489f35319033385, 0xde51839b2936bafc, 0x9101f7b0e12997f8,
+    0xebd98778d11c1e81, 0x64b116208142850a, 0x1e6966e8b1770c73,
+    0x8719014c99c2b083, 0xfdc17184a9f739fa, 0x72a9e0dcf9a9a271,
+    0x08719014c99c2b08, 0x4721e43f0183060c, 0x3df994f731b68f75,
+    0xb29105af61e814fe, 0xc849756751dd9d87, 0x2c31edf8f1d64ef6,
+    0x56e99d30c1e3c78f, 0xd9810c6891bd5c04, 0xa3597ca0a188d57d,
+    0xec09088b6997f879, 0x96d1784359a27100, 0x19b9e91b09fcea8b,
+    0x636199d339c963f2, 0xdf7adabd7a6e2d6f, 0xa5a2aa754a5ba416,
+    0x2aca3b2d1a053f9d, 0x50124be52a30b6e4, 0x1f423fcee22f9be0,
+    0x659a4f06d21a1299, 0xeaf2de5e82448912, 0x902aae96b271006b,
+    0x74523609127ad31a, 0x0e8a46c1224f5a63, 0x81e2d7997211c1e8,
+    0xfb3aa75142244891, 0xb46ad37a8a3b6595, 0xceb2a3b2ba0eecec,
+    0x41da32eaea507767, 0x3b024222da65fe1e, 0xa2722586f2d042ee,
+    0xd8aa554ec2e5cb97, 0x57c2c41692bb501c, 0x2d1ab4dea28ed965,
+    0x624ac0f56a91f461, 0x1892b03d5aa47d18, 0x97fa21650afae693,
+    0xed2251ad3acf6fea, 0x095ac9329ac4bc9b, 0x7382b9faaaf135e2,
+    0xfcea28a2faafae69, 0x8632586aca9a2710, 0xc9622c4102850a14,
+    0xb3ba5c8932b0836d, 0x3cd2cdd162ee18e6, 0x460abd1952db919f,
+    0x256b24ca6b12f26d, 0x5fb354025b277b14, 0xd0dbc55a0b79e09f,
+    0xaa03b5923b4c69e6, 0xe553c1b9f35344e2, 0x9f8bb171c366cd9b,
+    0x10e3202993385610, 0x6a3b50e1a30ddf69, 0x8e43c87e03060c18,
+    0xf49bb8b633338561, 0x7bf329ee636d1eea, 0x012b592653589793,
+    0x4e7b2d0d9b47ba97, 0x34a35dc5ab7233ee, 0xbbcbcc9dfb2ca865,
+    0xc113bc55cb19211c, 0x5863dbf1e3ac9dec, 0x22bbab39d3991495,
+    0xadd33a6183c78f1e, 0xd70b4aa9b3f20667, 0x985b3e827bed2b63,
+    0xe2834e4a4bd8a21a, 0x6debdf121b863991, 0x1733afda2bb3b0e8,
+    0xf34b37458bb86399, 0x8993478dbb8deae0, 0x06fbd6d5ebd3716b,
+    0x7c23a61ddbe6f812, 0x3373d23613f9d516, 0x49aba2fe23cc5c6f,
+    0xc6c333a67392c7e4, 0xbc1b436e43a74e9d, 0x95ac9329ac4bc9b5,
+    0xef74e3e19c7e40cc, 0x601c72b9cc20db47, 0x1ac40271fc15523e,
+    0x5594765a340a7f3a, 0x2f4c0692043ff643, 0xa02497ca54616dc8,
+    0xdafce7026454e4b1, 0x3e847f9dc45f37c0, 0x445c0f55f46abeb9,
+    0xcb349e0da4342532, 0xb1eceec59401ac4b, 0xfebc9aee5c1e814f,
+    0x8464ea266c2b0836, 0x0b0c7b7e3c7593bd, 0x71d40bb60c401ac4,
+    0xe8a46c1224f5a634, 0x927c1cda14c02f4d, 0x1d148d82449eb4c6,
+    0x67ccfd4a74ab3dbf, 0x289c8961bcb410bb, 0x5244f9a98c8199c2,
+    0xdd2c68f1dcdf0249, 0xa7f41839ecea8b30, 0x438c80a64ce15841,
+    0x3954f06e7cd4d138, 0xb63c61362c8a4ab3, 0xcce411fe1cbfc3ca,
+    0x83b465d5d4a0eece, 0xf96c151de49567b7, 0x76048445b4cbfc3c,
+    0x0cdcf48d84fe7545, 0x6fbd6d5ebd3716b7, 0x15651d968d029fce,
+    0x9a0d8ccedd5c0445, 0xe0d5fc06ed698d3c, 0xaf85882d2576a038,
+    0xd55df8e515432941, 0x5a3569bd451db2ca, 0x20ed197575283bb3,
+    0xc49581ead523e8c2, 0xbe4df122e51661bb, 0x3125607ab548fa30,
+    0x4bfd10b2857d7349, 0x04ad64994d625e4d, 0x7e7514517d57d734,
+    0xf11d85092d094cbf, 0x8bc5f5c11d3cc5c6, 0x12b5926535897936,
+    0x686de2ad05bcf04f, 0xe70573f555e26bc4, 0x9ddd033d65d7e2bd,
+    0xd28d7716adc8cfb9, 0xa85507de9dfd46c0, 0x273d9686cda3dd4b,
+    0x5de5e64efd965432, 0xb99d7ed15d9d8743, 0xc3450e196da80e3a,
+    0x4c2d9f413df695b1, 0x36f5ef890dc31cc8, 0x79a59ba2c5dc31cc,
+    0x037deb6af5e9b8b5, 0x8c157a32a5b7233e, 0xf6cd0afa9582aa47,
+    0x4ad64994d625e4da, 0x300e395ce6106da3, 0xbf66a804b64ef628,
+    0xc5bed8cc867b7f51, 0x8aeeace74e645255, 0xf036dc2f7e51db2c,
+    0x7f5e4d772e0f40a7, 0x05863dbf1e3ac9de, 0xe1fea520be311aaf,
+    0x9b26d5e88e0493d6, 0x144e44b0de5a085d, 0x6e963478ee6f8124,
+    0x21c640532670ac20, 0x5b1e309b16452559, 0xd476a1c3461bbed2,
+    0xaeaed10b762e37ab, 0x37deb6af5e9b8b5b, 0x4d06c6676eae0222,
+    0xc26e573f3ef099a9, 0xb8b627f70ec510d0, 0xf7e653dcc6da3dd4,
+    0x8d3e2314f6efb4ad, 0x0256b24ca6b12f26, 0x788ec2849684a65f,
+    0x9cf65a1b368f752e, 0xe62e2ad306bafc57, 0x6946bb8b56e467dc,
+    0x139ecb4366d1eea5, 0x5ccebf68aecec3a1, 0x2616cfa09efb4ad8,
+    0xa97e5ef8cea5d153, 0xd3a62e30fe90582a, 0xb0c7b7e3c7593bd8,
+    0xca1fc72bf76cb2a1, 0x45775673a732292a, 0x3faf26bb9707a053,
+    0x70ff52905f188d57, 0x0a2722586f2d042e, 0x854fb3003f739fa5,
+    0xff97c3c80f4616dc, 0x1bef5b57af4dc5ad, 0x61372b9f9f784cd4,
+    0xee5fbac7cf26d75f, 0x9487ca0fff135e26, 0xdbd7be24370c7322,
+    0xa10fceec0739fa5b, 0x2e675fb4576761d0, 0x54bf2f7c6752e8a9,
+    0xcdcf48d84fe75459, 0xb71738107fd2dd20, 0x387fa9482f8c46ab,
+    0x42a7d9801fb9cfd2, 0x0df7adabd7a6e2d6, 0x772fdd63e7936baf,
+    0xf8474c3bb7cdf024, 0x829f3cf387f8795d, 0x66e7a46c27f3aa2c,
+    0x1c3fd4a417c62355, 0x935745fc4798b8de, 0xe98f353477ad31a7,
+    0xa6df411fbfb21ca3, 0xdc0731d78f8795da, 0x536fa08fdfd90e51,
+    0x29b7d047efec8728,
+};
+
+inline C10_HOST_CONSTEXPR uint64_t
+crc64impl(uint64_t accumulator, const char* data, size_t size) {
+#if __cpp_constexpr >= 201304
+  // if we are in C++14, just use a for loop. This compiles faster.
+  for (size_t i = 0; i < size; ++i) {
+    accumulator =
+        crc64_table[(accumulator ^ data[i]) & 0xFF] ^ (accumulator >> 8);
+  }
+  return accumulator;
+#else
+  // if we are in C++11, we need to do it recursively because of constexpr
+  // restrictions.
+  return (size == 0)
+      ? accumulator
+      : crc64impl(
+            crc64_table[(accumulator ^ *data) & 0xFF] ^ (accumulator >> 8),
+            data + 1,
+            size - 1);
+#endif
+}
+} // namespace detail
+
+struct crc64_t final : IdWrapper<crc64_t, uint64_t> {
+  constexpr crc64_t(uint64_t checksum) : IdWrapper(checksum) {}
+  constexpr uint64_t checksum() const {
+    return this->underlyingId();
+  }
+};
+
+// CRC64 with Jones coefficients and an init value of 0.
+inline C10_HOST_CONSTEXPR crc64_t crc64(const char* data, size_t size) {
+  return crc64_t{detail::crc64impl(0, data, size)};
+}
+} // namespace util
+} // namespace c10
+
+// Allow usage of crc64_t in std::unordered_set
+C10_DEFINE_HASH_FOR_IDWRAPPER(c10::util::crc64_t);
diff --git a/c10/util/IdWrapper.h b/c10/util/IdWrapper.h
index 0d8f284..dc28141 100644
--- a/c10/util/IdWrapper.h
+++ b/c10/util/IdWrapper.h
@@ -48,7 +48,7 @@
   //      Fix this once we don't need GCC 4.8 anymore.
   friend constexpr bool operator==(
       const concrete_type& lhs,
-      const concrete_type& rhs) {
+      const concrete_type& rhs) noexcept {
     return lhs.id_ == rhs.id_;
   }
 
@@ -57,7 +57,7 @@
   //      Fix this once we don't need GCC 4.8 anymore.
   friend constexpr bool operator!=(
       const concrete_type& lhs,
-      const concrete_type& rhs) {
+      const concrete_type& rhs) noexcept {
     return !(lhs == rhs);
   }
 
diff --git a/c10/util/TypeIndex.h b/c10/util/TypeIndex.h
new file mode 100644
index 0000000..b642cae
--- /dev/null
+++ b/c10/util/TypeIndex.h
@@ -0,0 +1,67 @@
+#pragma once
+
+#include <c10/util/C++17.h>
+#include <c10/util/ConstexprCrc.h>
+#include <c10/util/IdWrapper.h>
+#include <cinttypes>
+#include <functional>
+
+namespace c10 {
+namespace util {
+
+struct type_index final : IdWrapper<type_index, uint64_t> {
+  constexpr explicit type_index(uint64_t checksum) : IdWrapper(checksum) {}
+
+  // Allow usage in std::map / std::set
+  // TODO Disallow this and rather use std::unordered_map/set everywhere
+  friend constexpr bool operator<(type_index lhs, type_index rhs) noexcept {
+    return lhs.underlyingId() < rhs.underlyingId();
+  }
+
+  friend std::ostream& operator<<(std::ostream& stream, type_index typeId) {
+    return stream << typeId.underlyingId();
+  }
+};
+
+namespace detail {
+
+#if !defined(__clang__) && !defined(_MSC_VER) && defined(__GNUC__) && \
+    __GNUC__ < 5
+// Getting __PRETTY_FUNCTION__ at compile time only works with GCC >= 5
+#error "You're running a too old version of GCC. We need GCC 5 or later."
+#endif
+
+template <typename T>
+inline C10_HOST_CONSTEXPR uint64_t type_index_impl() noexcept {
+// Idea: __PRETTY_FUNCTION__ (or __FUNCSIG__ on msvc) contains a qualified name
+// of this function, including its template parameter, i.e. including the
+// type we want an id for. We use this name and run crc64 on it to get a type
+// id.
+#if defined(_MSC_VER)
+  return crc64(__FUNCSIG__, sizeof(__FUNCSIG__)).checksum();
+#else
+  return crc64(__PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__)).checksum();
+#endif
+}
+
+} // namespace detail
+
+template <typename T>
+inline C10_HOST_CONSTEXPR type_index get_type_index() noexcept {
+#if !defined(__CUDA_ARCH__)
+  // To enforce that this is really computed at compile time, we pass the crc
+  // checksum through std::integral_constant.
+  return type_index{std::integral_constant<
+      uint64_t,
+      detail::type_index_impl<guts::remove_cv_t<guts::decay_t<T>>>()>::value};
+#else
+  // nvcc unfortunately doesn't like this being constexpr in device code
+  return type_index{
+      detail::type_index_impl<guts::remove_cv_t<guts::decay_t<T>>>()};
+#endif
+}
+
+} // namespace util
+} // namespace c10
+
+C10_DEFINE_HASH_FOR_IDWRAPPER(c10::util::type_index);
diff --git a/c10/util/typeid.cpp b/c10/util/typeid.cpp
index 8a3ec64..94c2fc0 100644
--- a/c10/util/typeid.cpp
+++ b/c10/util/typeid.cpp
@@ -27,6 +27,11 @@
     TypeIdentifier::uninitialized(),
     "nullptr (uninitialized)");
 
+C10_EXPORT CollisionChecker& collisionChecker_() {
+  static CollisionChecker singleton;
+  return singleton;
+}
+
 } // namespace detail
 
 // TODO Inlineable on non-MSVC like other preallocated ids?
@@ -36,56 +41,41 @@
   return &detail::_typeMetaDataInstance_uninitialized_;
 }
 
-TypeIdentifier TypeIdentifier::createTypeId() {
-  static std::atomic<TypeIdentifier::underlying_type> counter(
-      TypeMeta::Id<_CaffeHighestPreallocatedTypeId>().underlyingId());
-  const TypeIdentifier::underlying_type new_value = ++counter;
-  if (new_value ==
-      std::numeric_limits<TypeIdentifier::underlying_type>::max()) {
-    throw std::logic_error(
-        "Ran out of available type ids. If you need more than 2^16 CAFFE_KNOWN_TYPEs, we need to increase TypeIdentifier to use more than 16 bit.");
-  }
-  return TypeIdentifier(new_value);
-}
-
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(0, uint8_t)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(1, int8_t)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(2, int16_t)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(3, int)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(4, int64_t)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(5, at::Half)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(6, float)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(7, double)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(8, at::ComplexHalf)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(9, std::complex<float>)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(10, std::complex<double>)
+CAFFE_KNOWN_TYPE(uint8_t)
+CAFFE_KNOWN_TYPE(int8_t)
+CAFFE_KNOWN_TYPE(int16_t)
+CAFFE_KNOWN_TYPE(int)
+CAFFE_KNOWN_TYPE(int64_t)
+CAFFE_KNOWN_TYPE(at::Half)
+CAFFE_KNOWN_TYPE(float)
+CAFFE_KNOWN_TYPE(double)
+CAFFE_KNOWN_TYPE(at::ComplexHalf)
+CAFFE_KNOWN_TYPE(std::complex<float>)
+CAFFE_KNOWN_TYPE(std::complex<double>)
 // 11 = undefined type id
 // 12 = Tensor (defined in tensor.cc)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(13, std::string)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(14, bool)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(15, uint16_t)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(16, char)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(17, std::unique_ptr<std::mutex>)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(18, std::unique_ptr<std::atomic<bool>>)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(19, std::vector<int32_t>)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(20, std::vector<int64_t>)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(21, std::vector<unsigned long>)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(22, bool*)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(23, char*)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(24, int*)
+CAFFE_KNOWN_TYPE(std::string)
+CAFFE_KNOWN_TYPE(bool)
+CAFFE_KNOWN_TYPE(uint16_t)
+CAFFE_KNOWN_TYPE(char)
+CAFFE_KNOWN_TYPE(std::unique_ptr<std::mutex>)
+CAFFE_KNOWN_TYPE(std::unique_ptr<std::atomic<bool>>)
+CAFFE_KNOWN_TYPE(std::vector<int32_t>)
+CAFFE_KNOWN_TYPE(std::vector<int64_t>)
+CAFFE_KNOWN_TYPE(std::vector<unsigned long>)
+CAFFE_KNOWN_TYPE(bool*)
+CAFFE_KNOWN_TYPE(char*)
+CAFFE_KNOWN_TYPE(int*)
 
 // see typeid.h for details.
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(25, detail::_guard_long_unique<long>);
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(
-    26,
-    detail::_guard_long_unique<std::vector<long>>)
+CAFFE_KNOWN_TYPE(detail::_guard_long_unique<long>);
+CAFFE_KNOWN_TYPE(detail::_guard_long_unique<std::vector<long>>)
 
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(27, float*)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(28, at::Half*)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(29, c10::qint8)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(30, c10::quint8)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(31, c10::qint32)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(32, at::BFloat16)
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(33, _CaffeHighestPreallocatedTypeId)
+CAFFE_KNOWN_TYPE(float*)
+CAFFE_KNOWN_TYPE(at::Half*)
+CAFFE_KNOWN_TYPE(c10::qint8)
+CAFFE_KNOWN_TYPE(c10::quint8)
+CAFFE_KNOWN_TYPE(c10::qint32)
+CAFFE_KNOWN_TYPE(at::BFloat16)
 
 } // namespace caffe2
diff --git a/c10/util/typeid.h b/c10/util/typeid.h
index df750d8..b721a6b 100644
--- a/c10/util/typeid.h
+++ b/c10/util/typeid.h
@@ -24,10 +24,12 @@
 #include <c10/util/Half.h>
 #include <c10/util/IdWrapper.h>
 #include <c10/util/Type.h>
+#include <c10/util/TypeIndex.h>
 #include <c10/util/qint32.h>
 #include <c10/util/qint8.h>
 #include <c10/util/quint8.h>
 #include <c10/util/BFloat16.h>
+#include <c10/util/flat_hash_map.h>
 
 /*
  * TypeIdentifier is a small type containing an id.
@@ -60,18 +62,11 @@
  * dtype of tensors.
  */
 class C10_API TypeIdentifier final
-    : public at::IdWrapper<TypeIdentifier, uint16_t> {
+    : public at::IdWrapper<TypeIdentifier, c10::util::type_index> {
  public:
-  static TypeIdentifier createTypeId();
-
   friend std::ostream& operator<<(std::ostream& stream, TypeIdentifier typeId);
   friend bool operator<(TypeIdentifier lhs, TypeIdentifier rhs);
 
-  // 0 is uint8_t (due to ScalarType BC constraint)
-  static constexpr TypeIdentifier uninitialized() {
-    return TypeIdentifier(11);
-  }
-
   /**
    * Returns the unique id for the given type T. The id is unique for the type T
    * in the sense that for any two different types, their ids are different; for
@@ -80,11 +75,18 @@
    * is generated during run-time. Do NOT serialize the id for storage.
    */
   template <typename T>
-  C10_API static TypeIdentifier Get();
+  static C10_HOST_CONSTEXPR TypeIdentifier Get() noexcept {
+    return TypeIdentifier(c10::util::get_type_index<T>());
+  }
+
+  static constexpr TypeIdentifier uninitialized() {
+    return TypeIdentifier(
+        c10::util::type_index{11}); // 11 is Undefined from ScalarType
+  }
 
  private:
-  constexpr explicit TypeIdentifier(uint16_t id) : IdWrapper(id) {}
-  friend class TypeMeta;
+  constexpr explicit TypeIdentifier(c10::util::type_index id) : IdWrapper(id) {}
+  friend class TypeMeta; // TODO Is this friend an issue?
 };
 
 // Allow usage in std::map / std::set
@@ -303,15 +305,39 @@
 }
 #endif
 
+// CollisionChecker is a safeguard to make sure none of our types generate
+// the same type id. Since we use crc64 of the string type name, there's a
+// (very) slight possibility of collisions and we want to be sure that doesn't
+// happen.
+class CollisionChecker final {
+public:
+  // Check that there is no type registered with this id and a different name
+  void check(TypeIdentifier id, const std::string& name) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    auto find = typeids_.find(id);
+    if (find != typeids_.end()) {
+      AT_ASSERT(find->second == name, "Typeid collision detected for ", find->second, " and ", name, ".");
+    } else {
+      typeids_.emplace(id, name);
+    }
+  }
+private:
+  std::mutex mutex_;
+  ska::flat_hash_map<TypeIdentifier, std::string> typeids_;
+};
+C10_API CollisionChecker& collisionChecker_();
+
 template <class T>
 inline TypeMetaData _makeTypeMetaDataInstance(const char* typeName) {
+  C10_HOST_CONSTEXPR_VAR auto typeId = TypeIdentifier::Get<T>();
+  collisionChecker_().check(typeId, typeName);
   return {sizeof(T),
           _PickNew<T>(),
           _PickPlacementNew<T>(),
           _PickCopy<T>(),
           _PickPlacementDelete<T>(),
           _PickDelete<T>(),
-          TypeIdentifier::Get<T>(),
+          typeId,
           typeName};
 }
 
@@ -325,7 +351,7 @@
  * stores some additional data such as the item size and the name of the type
  * for run-time inspection.
  */
-class C10_API TypeMeta {
+class C10_API TypeMeta final {
  public:
   using New = detail::TypeMetaData::New;
   using PlacementNew = detail::TypeMetaData::PlacementNew;
@@ -341,77 +367,77 @@
   /**
    * Copy constructor.
    */
-  constexpr TypeMeta(const TypeMeta& src) noexcept = default;
+  TypeMeta(const TypeMeta& src) noexcept = default;
 
   /**
    * Assignment operator.
    */
-  AT_CPP14_CONSTEXPR TypeMeta& operator=(const TypeMeta& src) noexcept =
-      default;
+  TypeMeta& operator=(const TypeMeta& src) noexcept = default;
 
-  constexpr TypeMeta(TypeMeta&& rhs) noexcept = default;
+  TypeMeta(TypeMeta&& rhs) noexcept = default;
 
  private:
   // TypeMeta can only be created by Make, making sure that we do not
   // create incorrectly mixed up TypeMeta objects.
-  explicit constexpr TypeMeta(const detail::TypeMetaData* data) noexcept
-      : data_(data) {}
+  explicit TypeMeta(const detail::TypeMetaData* data) noexcept
+  : data_(data) {
+  }
 
  public:
   /**
    * Returns the type id.
    */
-  constexpr TypeIdentifier id() const noexcept {
+  TypeIdentifier id() const noexcept {
     return data_->id_;
   }
   /**
    * Returns the size of the item.
    */
-  constexpr size_t itemsize() const noexcept {
+  size_t itemsize() const noexcept {
     return data_->itemsize_;
   }
-  constexpr New* newFn() const noexcept {
+  New* newFn() const noexcept {
     return data_->new_;
   }
   /**
    * Returns the placement new function pointer for individual items.
    */
-  constexpr PlacementNew* placementNew() const noexcept {
+  PlacementNew* placementNew() const noexcept {
     return data_->placementNew_;
   }
   /**
    * Returns the typed copy function pointer for individual iterms.
    */
-  constexpr Copy* copy() const noexcept {
+  Copy* copy() const noexcept {
     return data_->copy_;
   }
   /**
    * Returns the destructor function pointer for individual items.
    */
-  constexpr PlacementDelete* placementDelete() const noexcept {
+  PlacementDelete* placementDelete() const noexcept {
     return data_->placementDelete_;
   }
-  constexpr Delete* deleteFn() const noexcept {
+  Delete* deleteFn() const noexcept {
     return data_->delete_;
   }
   /**
    * Returns a printable name for the type.
    */
-  constexpr const char* name() const noexcept {
+  const char* name() const noexcept {
     return data_->name_;
   }
 
   friend bool operator==(const TypeMeta& lhs, const TypeMeta& rhs) noexcept;
 
   template <typename T>
-  constexpr bool Match() const noexcept {
+  bool Match() const noexcept {
     return (*this == Make<T>());
   }
 
   // Below are static functions that can be called by passing a specific type.
 
   template <class T>
-  static TypeIdentifier Id() noexcept {
+  static C10_HOST_CONSTEXPR TypeIdentifier Id() noexcept {
     return TypeIdentifier::Get<T>();
   }
 
@@ -459,7 +485,8 @@
     detail::_Uninitialized>() noexcept;
 
 inline TypeMeta::TypeMeta() noexcept
-    : data_(_typeMetaDataInstance<detail::_Uninitialized>()) {}
+    : data_(_typeMetaDataInstance<detail::_Uninitialized>()) {
+}
 
 inline bool operator==(const TypeMeta& lhs, const TypeMeta& rhs) noexcept {
   return (lhs.data_ == rhs.data_);
@@ -509,73 +536,21 @@
   TypeMeta::_typeMetaDataInstance<T>() noexcept {                       \
     return &C10_CONCATENATE(detail::_typeMetaDataInstance_, Counter);   \
   }
-#define CAFFE_KNOWN_TYPE(T)                                               \
-  template <>                                                             \
-  EXPORT_IF_NOT_GCC TypeIdentifier TypeIdentifier::Get<T>() {             \
-    static const TypeIdentifier type_id = TypeIdentifier::createTypeId(); \
-    return type_id;                                                       \
-  }                                                                       \
+#define CAFFE_KNOWN_TYPE(T) \
   _CAFFE_KNOWN_TYPE_DEFINE_TYPEMETADATA_INSTANCE(T, __COUNTER__)
 
 /**
  * CAFFE_DECLARE_PREALLOCATED_KNOWN_TYPE is used
- * to preallocate ids for types that are queried very often so that they
- * can be resolved at compile time. Please use CAFFE_KNOWN_TYPE() instead
- * for your own types to allocate dynamic ids for them.
+ * to preallocate numbers so they line up exactly
+ * with at::ScalarType's numbering.  All other numbers do not matter.
+ * Please use CAFFE_KNOWN_TYPE instead for your own types.
  */
-#ifdef _MSC_VER
-#define CAFFE_DECLARE_PREALLOCATED_KNOWN_TYPE(PreallocatedId, T) \
-  template <>                                                    \
-  inline C10_EXPORT TypeIdentifier TypeIdentifier::Get<T>() {    \
-    return TypeIdentifier(PreallocatedId);                       \
-  }                                                              \
-  namespace detail {                                             \
-  C10_API extern const TypeMetaData C10_CONCATENATE(             \
-      _typeMetaDataInstance_preallocated_,                       \
-      PreallocatedId);                                           \
-  }
-#define CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(PreallocatedId, T)         \
-  namespace detail {                                                    \
-  C10_EXPORT const TypeMetaData C10_CONCATENATE(                        \
-      _typeMetaDataInstance_preallocated_,                              \
-      PreallocatedId) = _makeTypeMetaDataInstance<T>(_typeName<T>(#T)); \
-  }                                                                     \
-  template <>                                                           \
-  C10_EXPORT const detail::TypeMetaData*                                \
-  TypeMeta::_typeMetaDataInstance<T>() noexcept {                       \
-    return &C10_CONCATENATE(                                            \
-        detail::_typeMetaDataInstance_preallocated_, PreallocatedId);   \
-  }
-#else // _MSC_VER
 #define CAFFE_DECLARE_PREALLOCATED_KNOWN_TYPE(PreallocatedId, T)      \
   template <>                                                         \
-  inline C10_EXPORT TypeIdentifier TypeIdentifier::Get<T>() {         \
-    return TypeIdentifier(PreallocatedId);                            \
-  }                                                                   \
-  namespace detail {                                                  \
-  C10_EXPORT extern const TypeMetaData C10_CONCATENATE(               \
-      _typeMetaDataInstance_preallocated_,                            \
-      PreallocatedId);                                                \
-  }                                                                   \
-  template <>                                                         \
-  inline const detail::TypeMetaData*                                  \
-  TypeMeta::_typeMetaDataInstance<T>() noexcept {                     \
-    return &C10_CONCATENATE(                                          \
-        detail::_typeMetaDataInstance_preallocated_, PreallocatedId); \
+  constexpr inline TypeIdentifier TypeIdentifier::Get<T>() noexcept { \
+    return TypeIdentifier(c10::util::type_index{PreallocatedId});     \
   }
-#define CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(PreallocatedId, T)         \
-  namespace detail {                                                    \
-  const TypeMetaData C10_CONCATENATE(                                   \
-      _typeMetaDataInstance_preallocated_,                              \
-      PreallocatedId) = _makeTypeMetaDataInstance<T>(_typeName<T>(#T)); \
-  }
-#endif
 
-// Note: we have preallocated the numbers so they line up exactly
-// with at::ScalarType's numbering.  All other numbers do not matter.
-
-struct _CaffeHighestPreallocatedTypeId final {};
-// TODO static_assert number of declare/define align
 CAFFE_DECLARE_PREALLOCATED_KNOWN_TYPE(0, uint8_t)
 CAFFE_DECLARE_PREALLOCATED_KNOWN_TYPE(1, int8_t)
 CAFFE_DECLARE_PREALLOCATED_KNOWN_TYPE(2, int16_t)
@@ -631,6 +606,5 @@
 CAFFE_DECLARE_PREALLOCATED_KNOWN_TYPE(30, c10::quint8)
 CAFFE_DECLARE_PREALLOCATED_KNOWN_TYPE(31, c10::qint32)
 CAFFE_DECLARE_PREALLOCATED_KNOWN_TYPE(32, at::BFloat16)
-CAFFE_DECLARE_PREALLOCATED_KNOWN_TYPE(33, _CaffeHighestPreallocatedTypeId)
 
 } // namespace caffe2
diff --git a/caffe2/core/tensor.cc b/caffe2/core/tensor.cc
index 9fe8102..ef70af2 100644
--- a/caffe2/core/tensor.cc
+++ b/caffe2/core/tensor.cc
@@ -5,7 +5,7 @@
 
 namespace caffe2 {
 
-CAFFE_DEFINE_PREALLOCATED_KNOWN_TYPE(12, Tensor);
+CAFFE_KNOWN_TYPE(Tensor);
 
 TensorPrinter::TensorPrinter(
     const std::string& tensor_name,
diff --git a/caffe2/opt/optimize_ideep.cc b/caffe2/opt/optimize_ideep.cc
index 223f684..2f1196d 100644
--- a/caffe2/opt/optimize_ideep.cc
+++ b/caffe2/opt/optimize_ideep.cc
@@ -459,14 +459,14 @@
     auto newOutputName = repr::nn::get<repr::Tensor>(sumInputX)->getName() +
         "_fusion_fix_" + std::to_string(i);
 
-    auto newInputTensor = util::make_unique<repr::Tensor>(newOutputName);
+    auto newInputTensor = c10::guts::make_unique<repr::Tensor>(newOutputName);
     auto newInput = nn->dataFlow.createNode(
         unique_dyn_cast<repr::NeuralNetData>(newInputTensor));
 
     nn->dataFlow.replaceNode(sumInputX, newInput);
     nn->dataFlow.deleteNode(sumInputX);
 
-    auto newOutputTensor = util::make_unique<repr::Tensor>(newOutputName);
+    auto newOutputTensor = c10::guts::make_unique<repr::Tensor>(newOutputName);
     auto newOutput = nn->dataFlow.createNode(
         unique_dyn_cast<repr::NeuralNetData>(newOutputTensor));
 
@@ -627,7 +627,7 @@
       return false;
     }
 
-    auto newOutputTensor = util::make_unique<repr::Tensor>(inputName);
+    auto newOutputTensor = c10::guts::make_unique<repr::Tensor>(inputName);
     auto newOutput = nn->dataFlow.createNode(
         unique_dyn_cast<repr::NeuralNetData>(newOutputTensor));
     nn->dataFlow.replaceNode(convOutput, newOutput);