Integrate from upstream

CMakeLists.txt

@@ -5,11 +5,10 @@ cmake_minimum_required(VERSION 3.5 FATAL_ERROR)
 # ---[ Project and semantic versioning.
 project(Caffe2 CXX C)
 
-set(CAFFE2_VERSION_MAJOR 0)
-set(CAFFE2_VERSION_MINOR 8)
-set(CAFFE2_VERSION_PATCH 2)
-set(CAFFE2_VERSION
-    "${CAFFE2_VERSION_MAJOR}.${CAFFE2_VERSION_MINOR}.${CAFFE2_VERSION_PATCH}")
+set(CMAKE_CXX_STANDARD 11)
+if (NOT MSVC)
+  set(CMAKE_C_STANDARD 11)
+endif()
 
 # One variable that determines whether the current cmake process is being run
 # with the main Caffe2 library. This is useful for building modules - if
@@ -134,6 +133,22 @@ if (ANDROID OR IOS)
   set(BUILD_ATEN_MOBILE ON)
 endif()
 
+# ---[ Utils
+# TODO: merge the following 3 files into cmake/public/utils.cmake.
+include(cmake/Utils.cmake)
+include(cmake/public/utils.cmake)
+
+# ---[ Version numbers for generated libraries
+set(TORCH_DEFAULT_VERSION "1.0.0")
+set(TORCH_BUILD_VERSION "${TORCH_DEFAULT_VERSION}" CACHE STRING "Torch build version")
+if (NOT TORCH_BUILD_VERSION)
+  # An empty string was specified so force version to the default
+  set(TORCH_BUILD_VERSION "${TORCH_DEFAULT_VERSION}"
+    CACHE STRING "Torch build version" FORCE)
+endif()
+caffe2_parse_version_str(TORCH ${TORCH_BUILD_VERSION})
+caffe2_parse_version_str(CAFFE2 ${TORCH_BUILD_VERSION})
+
 # ---[ CMake scripts + modules
 list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/Modules)
 
@@ -160,11 +175,6 @@ include(cmake/MiscCheck.cmake)
 # External projects
 include(ExternalProject)
 
-# ---[ Utils
-# TODO: merge the following 3 files into cmake/public/utils.cmake.
-include(cmake/Utils.cmake)
-include(cmake/public/utils.cmake)
-
 # ---[ Dependencies
 include(cmake/Dependencies.cmake)
 
@@ -294,6 +304,7 @@ include_directories(BEFORE ${PROJECT_BINARY_DIR})
 include_directories(BEFORE ${PROJECT_SOURCE_DIR}/aten/src/)
 
 # ---[ Main build
+add_subdirectory(c10)
 add_subdirectory(caffe2)
 
 # --[ Documentation

CONTRIBUTING.md

@@ -262,9 +262,9 @@ than Linux, which are worth keeping in mind when fixing these problems.
 1. Symbols are NOT exported by default on Windows; instead, you have to explicitly
    mark a symbol as exported/imported in a header file with `__declspec(dllexport)` /
    `__declspec(dllimport)`.  We have codified this pattern into a set of macros
-   which follow the convention `*_API`, e.g., `AT_API` inside ATen. (Every separate
-   shared library needs a unique macro name, because symbol visibility is on a per
-   shared library basis.)
+   which follow the convention `*_API`, e.g., `CAFFE2_API` inside Caffe2 and ATen.
+   (Every separate shared library needs a unique macro name, because symbol visibility
+   is on a per shared library basis. See c10/macros/Macros.h for more details.)
 
    The upshot is if you see an "unresolved external" error in your Windows build, this
    is probably because you forgot to mark a function with `*_API`.  However, there is

README.md

@@ -163,7 +163,7 @@ conda install numpy pyyaml mkl mkl-include setuptools cmake cffi typing
 conda install -c mingfeima mkldnn
 
 # Add LAPACK support for the GPU
-conda install -c pytorch magma-cuda80 # or magma-cuda90 if CUDA 9
+conda install -c pytorch magma-cuda92 # or [magma-cuda80 | magma-cuda91] depending on your cuda version
 ```
 
 On macOS

aten/src/ATen/CPUGeneral.h

@@ -1,12 +1,12 @@
 #pragma once
 
-// Using AT_API is crucial as otherwise you'll see
+// Using CAFFE2_API is crucial as otherwise you'll see
 // linking errors using MSVC
 // See https://msdn.microsoft.com/en-us/library/a90k134d.aspx
-// This header adds this if using AT_API
+// This header adds this if using CAFFE2_API
 #include "ATen/core/ATenGeneral.h"
 
 namespace at {
-AT_API void set_num_threads(int);
-AT_API int get_num_threads();
+CAFFE2_API void set_num_threads(int);
+CAFFE2_API int get_num_threads();
 }

aten/src/ATen/CPUTypeDefault.h

@@ -3,7 +3,7 @@
 
 namespace at {
 
-struct AT_API CPUTypeDefault : public TypeDefault {
+struct CAFFE2_API CPUTypeDefault : public TypeDefault {
   CPUTypeDefault(TensorTypeId type_id, bool is_variable, bool is_undefined)
       : TypeDefault(type_id, is_variable, is_undefined) {}
   Allocator* allocator() const override;

aten/src/ATen/Context.h

@@ -22,10 +22,10 @@
 
 namespace at {
 
-struct Tensor;
+class Tensor;
 
-class AT_API Context {
-public:
+class CAFFE2_API Context {
+ public:
   Context();
   TypeExtendedInterface* getNonVariableTypeRaw(Backend p, ScalarType s) {
     return static_cast<TypeExtendedInterface*>(globalLegacyTypeDispatch().getNonVariableTypeRaw(p, s));
@@ -133,7 +133,7 @@ class AT_API Context {
   friend struct Type;
 };
 
-AT_API Context & globalContext();
+CAFFE2_API Context& globalContext();
 
 static inline void init() {
   globalContext();
@@ -153,11 +153,11 @@ static inline TypeExtendedInterface& getNonVariableType(DeviceType p, ScalarType
   return globalContext().getNonVariableType(deviceTypeToBackend(p), s);
 }
 
-AT_API TypeExtendedInterface& getType(TensorOptions options);
-AT_API TypeExtendedInterface& getType(const TensorImpl*);
-AT_API TypeExtendedInterface& getType(const Tensor&);
+CAFFE2_API TypeExtendedInterface& getType(TensorOptions options);
+CAFFE2_API TypeExtendedInterface& getType(const TensorImpl*);
+CAFFE2_API TypeExtendedInterface& getType(const Tensor&);
 
-AT_API Allocator* getCPUAllocator();
+CAFFE2_API Allocator* getCPUAllocator();
 
 static inline TypeExtendedInterface& CPU(ScalarType s) {
   return getNonVariableType(Backend::CPU, s);

aten/src/ATen/DLConvertor.h

@@ -10,8 +10,8 @@
 
 namespace at {
 
-AT_API ScalarType toScalarType(const DLDataType& dtype);
-AT_API DLManagedTensor * toDLPack(const Tensor& src);
-AT_API Tensor fromDLPack(const DLManagedTensor* src);
+CAFFE2_API ScalarType toScalarType(const DLDataType& dtype);
+CAFFE2_API DLManagedTensor* toDLPack(const Tensor& src);
+CAFFE2_API Tensor fromDLPack(const DLManagedTensor* src);
 
 } //namespace at

aten/src/ATen/ExpandUtils.h

@@ -9,9 +9,12 @@
 
 namespace at {
 
-AT_API std::vector<int64_t> infer_size(IntList a, IntList b);
-AT_API std::tuple<std::vector<int64_t>, std::vector<int64_t> > inferExpandGeometry(
-    IntList tensor_sizes, IntList tensor_strides, IntList sizes);
+CAFFE2_API std::vector<int64_t> infer_size(IntList a, IntList b);
+CAFFE2_API std::tuple<std::vector<int64_t>, std::vector<int64_t>>
+inferExpandGeometry(
+    IntList tensor_sizes,
+    IntList tensor_strides,
+    IntList sizes);
 
 // avoid copy-construction of Tensor by using a reference_wrapper.
 inline void check_defined(std::initializer_list<std::reference_wrapper<const Tensor>> tensors, const char *api_name) {

aten/src/ATen/SparseTensorImpl.h

@@ -5,7 +5,7 @@
 #include "ATen/core/Error.h"
 
 namespace at {
-struct AT_API SparseTensorImpl : public TensorImpl {
+struct CAFFE2_API SparseTensorImpl : public TensorImpl {
   // Stored in COO format, indices + values.
 
   // INVARIANTS:
@@ -157,11 +157,11 @@ struct AT_API SparseTensorImpl : public TensorImpl {
     sparseDims_ = sparseDims;
     denseDims_ = denseDims;
 
-    auto empty_indices = indices().type().tensor({sparseDims, 0});
+    auto empty_indices = at::empty({sparseDims, 0}, indices().options());
     std::vector<int64_t> values_size = {0};
     auto dense_size = sizes().slice(sparseDims);
     values_size.insert(values_size.end(), dense_size.begin(), dense_size.end());
-    auto empty_values = values().type().tensor(values_size);
+    auto empty_values = at::empty(values_size, values().options());
     set_indices_and_values_unsafe(empty_indices, empty_values);
     refresh_numel();
   }

aten/src/ATen/TensorGeometry.cpp

@@ -12,8 +12,4 @@ bool TensorGeometry::is_contiguous() const {
   return at::geometry_is_contiguous(sizes_, strides_);
 }
 
-Tensor TensorGeometry::zeros_with_stride(const Type& type) const {
-  return type.tensor(sizes_, strides_).zero_();
-}
-
 } // namespace at

aten/src/ATen/TensorGeometry.h

@@ -5,7 +5,7 @@
 
 namespace at {
 
-struct AT_API TensorGeometry {
+struct CAFFE2_API TensorGeometry {
   TensorGeometry() : storage_offset_(0) {}
 
   explicit TensorGeometry(IntList sizes)
@@ -30,9 +30,6 @@ struct AT_API TensorGeometry {
   // true if the tensor is contiguous
   bool is_contiguous() const;
 
-  // creates a new tensor with the sizes and strides of the source
-  Tensor zeros_with_stride(const Type& type) const;
-
   int64_t dim() const { return sizes_.size(); }
   int64_t size(int64_t dim) const {
     dim = maybe_wrap_dim(dim, this->dim());

aten/src/ATen/TensorOperators.h

@@ -68,9 +68,9 @@ inline Tensor Tensor::operator[](int64_t index) const {
 #define AT_FORALL_BINARY_OPS(_) \
 _(+,x.add(y), y.add(x)) \
 _(*,x.mul(y), y.mul(x)) \
-_(-,x.sub(y), y.type().tensor().resize_(y.sizes()).fill_(x).sub_(y)) \
-_(/,x.div(y), y.type().tensor().resize_(y.sizes()).fill_(x).div_(y)) \
-_(%,x.remainder(y), y.type().tensor().resize_(y.sizes()).fill_(x).remainder_(y)) \
+_(-,x.sub(y), ::at::empty(y.sizes(), y.options()).fill_(x).sub_(y)) \
+_(/,x.div(y), ::at::empty(y.sizes(), y.options()).fill_(x).div_(y)) \
+_(%,x.remainder(y), ::at::empty(y.sizes(), y.options()).fill_(x).remainder_(y)) \
 _(<,x.lt(y), y.gt(x)) \
 _(<=,x.le(y), y.ge(x)) \
 _(>,x.gt(y),y.lt(x)) \

aten/src/ATen/TensorUtils.h

@@ -12,7 +12,7 @@ namespace at {
 // make sense.  These are particularly useful for native functions,
 // which do NO argument checking by default.
 
-struct AT_API TensorArg {
+struct CAFFE2_API TensorArg {
   Tensor tensor;
   const char* name;
   int pos; // 1-indexed
@@ -22,7 +22,7 @@ struct AT_API TensorArg {
   const Tensor& operator*() const { return tensor; }
 };
 
-struct AT_API TensorGeometryArg {
+struct CAFFE2_API TensorGeometryArg {
   TensorGeometry tensor;
   const char* name;
   int pos; // 1-indexed
@@ -49,40 +49,80 @@ using CheckedFrom = const char*;
 // not TensorGeometryArg, because the Tensor to TensorGeometry
 // conversion will blow up if you have undefined tensors.
 
-AT_API std::ostream& operator<<(std::ostream & out, TensorGeometryArg t);
-AT_API void checkDim(CheckedFrom c, const TensorGeometryArg& t, int64_t dim);
+CAFFE2_API std::ostream& operator<<(std::ostream& out, TensorGeometryArg t);
+CAFFE2_API void checkDim(
+    CheckedFrom c,
+    const TensorGeometryArg& t,
+    int64_t dim);
 // NB: this is an inclusive-exclusive range
-AT_API void checkDimRange(CheckedFrom c, const TensorGeometryArg& t, int64_t dim_start, int64_t dim_end);
-AT_API void checkSameDim(CheckedFrom c, const TensorGeometryArg& t1, const TensorGeometryArg& t2);
-AT_API void checkContiguous(CheckedFrom c, const TensorGeometryArg& t);
-AT_API void checkAllContiguous(CheckedFrom c, at::ArrayRef<TensorArg> ts);
-AT_API void checkSize(CheckedFrom c, const TensorGeometryArg& t, IntList sizes);
-AT_API void checkSize(CheckedFrom c, const TensorGeometryArg& t, int64_t dim, int64_t size);
-AT_API void checkNumel(CheckedFrom c, const TensorGeometryArg& t, int64_t numel);
-AT_API void checkSameNumel(CheckedFrom c, const TensorGeometryArg& t1, const TensorGeometryArg& t2);
-AT_API void checkAllSameNumel(CheckedFrom c, ArrayRef<TensorArg> tensors);
-AT_API void checkScalarType(CheckedFrom c, const TensorArg& t, ScalarType s);
-AT_API void checkScalarTypes(CheckedFrom c, const TensorArg& t, at::ArrayRef<ScalarType> l);
-AT_API void checkSameGPU(CheckedFrom c, const TensorArg& t1, const TensorArg& t2);
-AT_API void checkAllSameGPU(CheckedFrom c, ArrayRef<TensorArg> tensors);
-AT_API void checkSameType(CheckedFrom c, const TensorArg& t1, const TensorArg& t2);
-AT_API void checkAllSameType(CheckedFrom c, ArrayRef<TensorArg> tensors);
-AT_API void checkSameSize(CheckedFrom c, const TensorArg& t1, const TensorArg& t2);
-AT_API void checkDefined(CheckedFrom c, const TensorArg& t);
-AT_API void checkAllDefined(CheckedFrom c, at::ArrayRef<TensorArg> t);
+CAFFE2_API void checkDimRange(
+    CheckedFrom c,
+    const TensorGeometryArg& t,
+    int64_t dim_start,
+    int64_t dim_end);
+CAFFE2_API void checkSameDim(
+    CheckedFrom c,
+    const TensorGeometryArg& t1,
+    const TensorGeometryArg& t2);
+CAFFE2_API void checkContiguous(CheckedFrom c, const TensorGeometryArg& t);
+CAFFE2_API void checkAllContiguous(CheckedFrom c, at::ArrayRef<TensorArg> ts);
+CAFFE2_API void checkSize(
+    CheckedFrom c,
+    const TensorGeometryArg& t,
+    IntList sizes);
+CAFFE2_API void checkSize(
+    CheckedFrom c,
+    const TensorGeometryArg& t,
+    int64_t dim,
+    int64_t size);
+CAFFE2_API void checkNumel(
+    CheckedFrom c,
+    const TensorGeometryArg& t,
+    int64_t numel);
+CAFFE2_API void checkSameNumel(
+    CheckedFrom c,
+    const TensorGeometryArg& t1,
+    const TensorGeometryArg& t2);
+CAFFE2_API void checkAllSameNumel(CheckedFrom c, ArrayRef<TensorArg> tensors);
+CAFFE2_API void checkScalarType(
+    CheckedFrom c,
+    const TensorArg& t,
+    ScalarType s);
+CAFFE2_API void checkScalarTypes(
+    CheckedFrom c,
+    const TensorArg& t,
+    at::ArrayRef<ScalarType> l);
+CAFFE2_API void checkSameGPU(
+    CheckedFrom c,
+    const TensorArg& t1,
+    const TensorArg& t2);
+CAFFE2_API void checkAllSameGPU(CheckedFrom c, ArrayRef<TensorArg> tensors);
+CAFFE2_API void checkSameType(
+    CheckedFrom c,
+    const TensorArg& t1,
+    const TensorArg& t2);
+CAFFE2_API void checkAllSameType(CheckedFrom c, ArrayRef<TensorArg> tensors);
+CAFFE2_API void checkSameSize(
+    CheckedFrom c,
+    const TensorArg& t1,
+    const TensorArg& t2);
+CAFFE2_API void checkDefined(CheckedFrom c, const TensorArg& t);
+CAFFE2_API void checkAllDefined(CheckedFrom c, at::ArrayRef<TensorArg> t);
 
 // FixMe: does TensorArg slow things down?
-AT_API void checkBackend(CheckedFrom c, at::ArrayRef<Tensor> t, at::Backend backend);
+CAFFE2_API void checkBackend(
+    CheckedFrom c,
+    at::ArrayRef<Tensor> t,
+    at::Backend backend);
 
 // Methods for getting data_ptr if tensor is defined
-AT_API void * maybe_data_ptr(const Tensor& tensor);
-AT_API void * maybe_data_ptr(const TensorArg& tensor);
+CAFFE2_API void* maybe_data_ptr(const Tensor& tensor);
+CAFFE2_API void* maybe_data_ptr(const TensorArg& tensor);
 
 // Return if the tensor geometry represented by `sizes` and `strides` is contiguous
 // Although we cache is_contiguous in tensor now, this is till useful because it
 // allows checking if a particular geometry is contiguous without explicitly
 // constructing a tensor, e.g., when you want to choose a kernel strategy based
 // on whether a subgeometry is contiguous.
-AT_API bool geometry_is_contiguous(IntList sizes, IntList strides);
-
+CAFFE2_API bool geometry_is_contiguous(IntList sizes, IntList strides);
 }

aten/src/ATen/Utils.h

@@ -24,7 +24,7 @@
 
 namespace at {
 
-AT_API int _crash_if_asan(int);
+CAFFE2_API int _crash_if_asan(int);
 
 static inline const Storage& checked_storage(
     const Storage& expr,

aten/src/ATen/core/ATenCoreTest.h

@@ -4,5 +4,5 @@
 
 namespace at {
 
-AT_CORE_API int CoreTest();
+CAFFE2_API int CoreTest();
 }

aten/src/ATen/core/ATenGeneral.h

@@ -1,8 +1,3 @@
 #pragma once
 
 #include "ATen/core/Macros.h"
-
-// TODO: Merge the *_API macros.
-#define AT_API AT_CORE_API
-#define AT_EXPORT AT_CORE_EXPORT
-#define AT_IMPORT AT_CORE_IMPORT

aten/src/ATen/core/Allocator.h

@@ -115,7 +115,7 @@ struct Allocator {
   }
 };
 
-struct AT_CORE_API InefficientStdFunctionContext {
+struct CAFFE2_API InefficientStdFunctionContext {
   std::unique_ptr<void, std::function<void(void*)>> ptr_;
   InefficientStdFunctionContext(
       std::unique_ptr<void, std::function<void(void*)>>&& ptr)