Move Scalar and ScalarType to c10/core

Summary: Pull Request resolved: pytorch#14022

Reviewed By: ezyang

Differential Revision: D13015236

fbshipit-source-id: 92aac4e342d85f75a31837b2943fa5b80f0c35c9

Author: smessmer

aten/src/ATen/ScalarOps.h

@@ -3,16 +3,17 @@
 #include "ATen/core/Scalar.h"
 #include "ATen/Tensor.h"
 
-namespace at {
+// This is in the c10 namespace because we use ADL to find the functions in it.
+namespace c10 {
 
 // FIXME: this should be (and was) Scalar::toTensor, but there is currently no way
 // to implement this without going through Derived Types (which are not part of core).
-inline Tensor scalar_to_tensor(Scalar s) {
+inline at::Tensor scalar_to_tensor(Scalar s) {
   if (s.isFloatingPoint()) {
-    return CPU(kDouble).scalarTensor(s);
+    return at::CPU(kDouble).scalarTensor(s);
   } else {
     AT_ASSERT(s.isIntegral());
-    return CPU(kLong).scalarTensor(s);
+    return at::CPU(kLong).scalarTensor(s);
   }
 }
 

aten/src/ATen/core/Backend.h

@@ -165,4 +165,4 @@ static inline const char* toString(Backend b) {
   }
 }
 
-} // namespace at
+} // namespace c10

aten/src/ATen/core/Scalar.h

@@ -1,103 +1 @@
-#pragma once
-
-#include <assert.h>
-#include <stdint.h>
-#include <stdexcept>
-#include <string>
-#include <utility>
-
-#include "ATen/core/ATenGeneral.h"
-#include "ATen/core/ScalarType.h"
-#include "ATen/core/Half.h"
-
-namespace at {
-
-class Tensor;
-
-class CAFFE2_API Scalar {
- public:
-  Scalar() : Scalar(int64_t(0)) {}
-
-#define DEFINE_IMPLICIT_CTOR(type,name,member) \
-  Scalar(type vv) \
-  : tag(Tag::HAS_##member) { \
-    v . member = convert<decltype(v.member),type>(vv); \
-  }
-  // We can't set v in the initializer list using the
-  // syntax v{ .member = ... } because it doesn't work on MSVC
-
-  AT_FORALL_SCALAR_TYPES(DEFINE_IMPLICIT_CTOR)
-
-#undef DEFINE_IMPLICIT_CTOR
-
-#define DEFINE_IMPLICIT_COMPLEX_CTOR(type, name, member) \
-  Scalar(type vv) : tag(Tag::HAS_##member) {             \
-    v.member[0] = c10::convert<double>(vv.real());       \
-    v.member[1] = c10::convert<double>(vv.imag());       \
-  }
-
-  DEFINE_IMPLICIT_COMPLEX_CTOR(at::ComplexHalf,ComplexHalf,z)
-  DEFINE_IMPLICIT_COMPLEX_CTOR(std::complex<float>,ComplexFloat,z)
-  DEFINE_IMPLICIT_COMPLEX_CTOR(std::complex<double>,ComplexDouble,z)
-
-#undef DEFINE_IMPLICIT_COMPLEX_CTOR
-
-#define DEFINE_ACCESSOR(type,name,member) \
-  type to##name () const { \
-    if (Tag::HAS_d == tag) { \
-      return checked_convert<type, double>(v.d, #type); \
-    } else if (Tag::HAS_z == tag) { \
-      return checked_convert<type, std::complex<double>>({v.z[0], v.z[1]}, #type); \
-    } else { \
-      return checked_convert<type, int64_t>(v.i, #type); \
-    } \
-  }
-
-  // TODO: Support ComplexHalf accessor
-  AT_FORALL_SCALAR_TYPES_WITH_COMPLEX_EXCEPT_COMPLEX_HALF(DEFINE_ACCESSOR)
-
-  //also support scalar.to<int64_t>();
-  template<typename T>
-  T to();
-
-#undef DEFINE_ACCESSOR
-  bool isFloatingPoint() const {
-    return Tag::HAS_d == tag;
-  }
-  bool isIntegral() const {
-    return Tag::HAS_i == tag;
-  }
-  bool isComplex() const {
-    return Tag::HAS_z == tag;
-  }
-
-  Scalar operator-() const;
-
-private:
-  enum class Tag { HAS_d, HAS_i, HAS_z };
-  Tag tag;
-  union {
-    double d;
-    int64_t i;
-    // Can't do put std::complex in the union, because it triggers
-    // an nvcc bug:
-    //    error: designator may not specify a non-POD subobject
-    double z[2];
-  } v;
-  friend struct Type;
-};
-
-// define the scalar.to<int64_t>() specializations
-template<typename T>
-inline T Scalar::to() {
-  throw std::runtime_error("to() cast to unexpected type.");
-}
-
-#define DEFINE_TO(T,name,_) \
-template<> \
-inline T Scalar::to<T>() { \
-  return to##name(); \
-}
-AT_FORALL_SCALAR_TYPES_WITH_COMPLEX_EXCEPT_COMPLEX_HALF(DEFINE_TO)
-#undef DEFINE_TO
-}
+#include <c10/core/Scalar.h>

aten/src/ATen/core/ScalarType.h

@@ -1,209 +1 @@
-#pragma once
-
-#include <c10/util/ArrayRef.h>
-#include "ATen/core/Half.h"
-#include <c10/util/typeid.h>
-
-#include <cstdint>
-#include <iostream>
-#include <complex>
-
-namespace at {
-
-// NB: Order matters for this macro; it is relied upon in
-// _promoteTypesLookup and the serialization format.
-#define AT_FORALL_SCALAR_TYPES_WITH_COMPLEX(_) \
-_(uint8_t,Byte,i)  /* 0 */ \
-_(int8_t,Char,i)   /* 1 */ \
-_(int16_t,Short,i) /* 2 */ \
-_(int,Int,i)       /* 3 */ \
-_(int64_t,Long,i)  /* 4 */ \
-_(at::Half,Half,d) /* 5 */ \
-_(float,Float,d)   /* 6 */ \
-_(double,Double,d) /* 7 */ \
-_(at::ComplexHalf,ComplexHalf,z)        /* 8 */ \
-_(std::complex<float>,ComplexFloat,z)   /* 9 */ \
-_(std::complex<double>,ComplexDouble,z) /* 10 */
-
-// If you want to support ComplexHalf for real, replace occurrences
-// of this macro with AT_FORALL_SCALAR_TYPES_WITH_COMPLEX.  But
-// beware: convert() doesn't work for all the conversions you need...
-#define AT_FORALL_SCALAR_TYPES_WITH_COMPLEX_EXCEPT_COMPLEX_HALF(_) \
-_(uint8_t,Byte,i)  \
-_(int8_t,Char,i)   \
-_(int16_t,Short,i) \
-_(int,Int,i)       \
-_(int64_t,Long,i)  \
-_(at::Half,Half,d) \
-_(float,Float,d)   \
-_(double,Double,d) \
-_(std::complex<float>,ComplexFloat,z) \
-_(std::complex<double>,ComplexDouble,z)
-
-#define AT_FORALL_SCALAR_TYPES(_) \
-_(uint8_t,Byte,i)  \
-_(int8_t,Char,i)   \
-_(int16_t,Short,i) \
-_(int,Int,i)       \
-_(int64_t,Long,i)  \
-_(at::Half,Half,d) \
-_(float,Float,d)   \
-_(double,Double,d)
-
-#define AT_FORALL_SCALAR_TYPES_EXCEPT_HALF(_) \
-_(uint8_t,Byte,i) \
-_(int8_t,Char,i) \
-_(int16_t,Short,i) \
-_(int,Int,i) \
-_(int64_t,Long,i) \
-_(float,Float,d) \
-_(double,Double,d)
-
-enum class ScalarType : int8_t {
-#define DEFINE_ENUM(_1,n,_2) \
-  n,
-  AT_FORALL_SCALAR_TYPES_WITH_COMPLEX(DEFINE_ENUM)
-#undef DEFINE_ENUM
-  Undefined,
-  NumOptions
-};
-
-static inline DataType scalarTypeToDataType(ScalarType scalar_type) {
-#define DEFINE_CASE(ctype, name, _) \
-  case ScalarType::name:            \
-    return caffe2::TypeIdentifier::Get<ctype>();
-
-  switch(scalar_type) {
-    AT_FORALL_SCALAR_TYPES_WITH_COMPLEX(DEFINE_CASE)
-    case ScalarType::Undefined: return DataType::uninitialized();
-    default: AT_ERROR("Unrecognized Scalartype ", scalar_type, " (please report this error)");
-  }
-#undef DEFINE_CASE
-}
-
-static inline caffe2::TypeMeta scalarTypeToTypeMeta(ScalarType scalar_type) {
-#define DEFINE_CASE(ctype,name,_) \
-  case ScalarType:: name : return caffe2::TypeMeta::Make<ctype>();
-
-  switch(scalar_type) {
-    AT_FORALL_SCALAR_TYPES_WITH_COMPLEX(DEFINE_CASE)
-    case ScalarType::Undefined: return caffe2::TypeMeta();
-    default: AT_ERROR("Unrecognized Scalartype ", scalar_type, " (please report this error)");
-  }
-#undef DEFINE_CASE
-}
-
-static inline ScalarType typeMetaToScalarType(caffe2::TypeMeta dtype) {
-#define DEFINE_IF(ctype, name, _)                      \
-  if (dtype == caffe2::TypeMeta::Make<ctype>()) { \
-    return ScalarType::name;                           \
-  }
-  AT_FORALL_SCALAR_TYPES_WITH_COMPLEX(DEFINE_IF)
-#undef DEFINE_IF
-  if (dtype == caffe2::TypeMeta()) {
-    return ScalarType::Undefined;
-  }
-  AT_ERROR("Unsupported TypeMeta in ATen: ", dtype, " (please report this error)");
-}
-
-static inline bool operator==(ScalarType t, caffe2::TypeMeta m) {
-  return typeMetaToScalarType(m) == t;
-}
-
-static inline bool operator==(caffe2::TypeMeta m, ScalarType t) {
-  return typeMetaToScalarType(m) == t;
-}
-
-#define DEFINE_CONSTANT(_,name,_2) \
-constexpr ScalarType k##name = ScalarType::name;
-
-AT_FORALL_SCALAR_TYPES_WITH_COMPLEX(DEFINE_CONSTANT)
-#undef DEFINE_CONSTANT
-
-static inline const char * toString(ScalarType t) {
-#define DEFINE_CASE(_,name,_2) \
-  case ScalarType:: name : return #name;
-
-  switch(t) {
-    AT_FORALL_SCALAR_TYPES_WITH_COMPLEX(DEFINE_CASE)
-    default:
-      return "UNKNOWN_SCALAR";
-  }
-#undef DEFINE_CASE
-}
-
-static inline size_t elementSize(ScalarType t) {
-#define CASE_ELEMENTSIZE_CASE(ctype,name,_2) \
-  case ScalarType:: name : return sizeof(ctype);
-
-  switch(t) {
-    AT_FORALL_SCALAR_TYPES_WITH_COMPLEX(CASE_ELEMENTSIZE_CASE)
-    default:
-      AT_ERROR("Unknown ScalarType");
-  }
-#undef CASE_ELEMENTSIZE_CASE
-}
-
-static inline bool isIntegralType(ScalarType t) {
-  return (t == ScalarType::Byte ||
-          t == ScalarType::Char ||
-          t == ScalarType::Int ||
-          t == ScalarType::Long ||
-          t == ScalarType::Short);
-}
-
-static inline bool isFloatingType(ScalarType t) {
-  return (t == ScalarType::Double ||
-          t == ScalarType::Float ||
-          t == ScalarType::Half);
-}
-
-static inline bool isComplexType(ScalarType t) {
-  return (t == ScalarType::ComplexHalf ||
-          t == ScalarType::ComplexFloat ||
-          t == ScalarType::ComplexDouble);
-}
-
-static inline ScalarType promoteTypes(ScalarType a, ScalarType b) {
-  // This is generated according to NumPy's promote_types
-  constexpr auto u1 = ScalarType::Byte;
-  constexpr auto i1 = ScalarType::Char;
-  constexpr auto i2 = ScalarType::Short;
-  constexpr auto i4 = ScalarType::Int;
-  constexpr auto i8 = ScalarType::Long;
-  constexpr auto f2 = ScalarType::Half;
-  constexpr auto f4 = ScalarType::Float;
-  constexpr auto f8 = ScalarType::Double;
-  constexpr auto ud = ScalarType::Undefined;
-  if (a == ud || b == ud) {
-    return ScalarType::Undefined;
-  }
-  if (isComplexType(a) || isComplexType(b)) {
-    AT_ERROR("promoteTypes with complex numbers is not handled yet; figure out what the correct rules should be");
-  }
-  static constexpr ScalarType _promoteTypesLookup
-      [static_cast<int>(ScalarType::NumOptions)]
-      [static_cast<int>(ScalarType::NumOptions)] = {
-            /* u1  i1  i2  i4  i8  f2  f4  f8 */
-    /* u1 */ { u1, i2, i2, i4, i8, f2, f4, f8 },
-    /* i1 */ { i2, i1, i2, i4, i8, f2, f4, f8 },
-    /* i2 */ { i2, i2, i2, i4, i8, f2, f4, f8 },
-    /* i4 */ { i4, i4, i4, i4, i8, f2, f4, f8 },
-    /* i8 */ { i8, i8, i8, i8, i8, f2, f4, f8 },
-    /* f2 */ { f2, f2, f2, f2, f2, f2, f4, f8 },
-    /* f4 */ { f4, f4, f4, f4, f4, f4, f4, f8 },
-    /* f8 */ { f8, f8, f8, f8, f8, f8, f8, f8 },
-  };
-  return _promoteTypesLookup[static_cast<int>(a)][static_cast<int>(b)];
-}
-
-class Tensor;
-typedef ArrayRef<Tensor> TensorList;
-
-inline std::ostream& operator<<(
-    std::ostream& stream,
-    at::ScalarType scalar_type) {
-  return stream << toString(scalar_type);
-}
-
-} // namespace at
+#include <c10/core/ScalarType.h>

aten/src/ATen/core/TensorImpl.h

@@ -42,8 +42,10 @@ class DeviceOption;
 
 }
 
-namespace at {
+namespace c10 {
 class Scalar;
+}
+namespace at {
 struct Type;
 struct Storage;
 class Tensor;

aten/src/ATen/core/TensorMethods.h

@@ -1293,7 +1293,7 @@ inline bool is_sparse(Tensor self) {
         "expected scalar type ",                 \
         #name,                                   \
         " but found ",                           \
-        at::toString(type().scalarType()));      \
+        c10::toString(type().scalarType()));     \
     return static_cast<T*>(this->data_ptr());    \
   }
 

aten/src/ATen/templates/NativeFunctions.h

@@ -13,9 +13,11 @@
 #include <tuple>
 #include <vector>
 
+namespace c10 {
+class Scalar;
+}
 namespace at {
 struct Generator;
-class Scalar;
 class Tensor;
 struct Type;
 } // namespace at

aten/src/ATen/templates/TensorMethods.h

@@ -106,7 +106,7 @@ inline bool is_sparse(Tensor self) {
         "expected scalar type ",                 \
         #name,                                   \
         " but found ",                           \
-        at::toString(type().scalarType()));      \
+        c10::toString(type().scalarType()));     \
     return static_cast<T*>(this->data_ptr());    \
   }