Merge pull request #157 from iotamudelta/ifu

Merge from upstream

Author: iotamudelta

.jenkins/pytorch/build.sh

@@ -6,8 +6,8 @@ fi
 
 # TODO: move this to Docker
 # TODO: add both NCCL and MPI in CI test by fixing these test first
-# sudo apt-get update
-# sudo apt-get install libnccl-dev libnccl2
+sudo apt-get update
+sudo apt-get install libnccl-dev libnccl2
 # sudo apt-get install openmpi-bin libopenmpi-dev
 
 # Required environment variable: $BUILD_ENVIRONMENT

CMakeLists.txt

@@ -144,7 +144,7 @@ option(USE_DISTRIBUTED "Use THD (distributed)" OFF)
 # Used when building Caffe2 through setup.py
 option(BUILDING_WITH_TORCH_LIBS "Tell cmake if Caffe2 is being built alongside torch libs" OFF)
 
-if (ANDROID OR IOS) 
+if (ANDROID OR IOS)
   set(BUILD_ATEN_MOBILE ON)
 endif()
 
@@ -213,7 +213,9 @@ if(NOT MSVC)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-strict-overflow")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-strict-aliasing")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error=deprecated-declarations")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-stringop-overflow")
+  if (CMAKE_COMPILER_IS_GNUCXX AND NOT (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.0.0))
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-stringop-overflow")
+  endif()
   # These flags are not available in GCC-4.8.5. Set only when using clang.
   # Compared against https://gcc.gnu.org/onlinedocs/gcc-4.8.5/gcc/Option-Summary.html
   if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")

CONTRIBUTING.md

@@ -23,7 +23,7 @@ If you are not familiar with creating a Pull Request, here are some guides:
 
 To develop PyTorch on your machine, here are some tips:
 
-1. Uninstall all existing pytorch installs
+1. Uninstall all existing PyTorch installs:
 ```
 conda uninstall pytorch
 pip uninstall torch

README.md

@@ -105,8 +105,7 @@ We hope you never spend hours debugging your code because of bad stack traces or
 PyTorch has minimal framework overhead. We integrate acceleration libraries
 such as Intel MKL and NVIDIA (cuDNN, NCCL) to maximize speed.
 At the core, its CPU and GPU Tensor and neural network backends
-(TH, THC, THNN, THCUNN) are written as independent libraries with a C99 API.
-They are mature and have been tested for years.
+(TH, THC, THNN, THCUNN) are mature and have been tested for years.
 
 Hence, PyTorch is quite fast – whether you run small or large neural networks.
 

aten/src/ATen/Formatting.cpp

@@ -244,7 +244,7 @@ std::ostream& print(std::ostream& stream, const Tensor & tensor_, int64_t linesi
   if(!tensor_.defined()) {
     stream << "[ Tensor (undefined) ]";
   } else if (tensor_.is_sparse()) {
-    stream << "[ " << tensor_.pImpl->toString() << "{}\n";
+    stream << "[ " << tensor_.toString() << "{}\n";
     stream << "indices:\n" << tensor_._indices() << "\n";
     stream << "values:\n" << tensor_._values() << "\n";
     stream << "size:\n" << tensor_.sizes() << "\n";
@@ -254,7 +254,7 @@ std::ostream& print(std::ostream& stream, const Tensor & tensor_, int64_t linesi
     Tensor tensor = tensor_.toType(cpudouble).contiguous();
     if(tensor.ndimension() == 0) {
       stream << defaultfloat << tensor.data<double>()[0] << std::endl;
-      stream << "[ " << tensor_.pImpl->toString() << "{} ]";
+      stream << "[ " << tensor_.toString() << "{} ]";
     } else if(tensor.ndimension() == 1) {
       if (tensor.numel() > 0) {
         double scale;
@@ -268,17 +268,17 @@ std::ostream& print(std::ostream& stream, const Tensor & tensor_, int64_t linesi
           stream << std::setw(sz) << tensor_p[i]/scale << std::endl;
         }
       }
-      stream << "[ " << tensor_.pImpl->toString() << "{" << tensor.size(0) << "} ]";
+      stream << "[ " << tensor_.toString() << "{" << tensor.size(0) << "} ]";
     } else if(tensor.ndimension() == 2) {
       if (tensor.numel() > 0) {
         __printMatrix(stream, tensor, linesize, 0);
       }
-      stream << "[ " << tensor_.pImpl->toString() << "{" << tensor.size(0) << "," <<  tensor.size(1) << "} ]";
+      stream << "[ " << tensor_.toString() << "{" << tensor.size(0) << "," <<  tensor.size(1) << "} ]";
     } else {
       if (tensor.numel() > 0) {
         __printTensor(stream, tensor, linesize);
       }
-      stream << "[ " << tensor_.pImpl->toString() << "{" << tensor.size(0);
+      stream << "[ " << tensor_.toString() << "{" << tensor.size(0);
       for(int64_t i = 1; i < tensor.ndimension(); i++) {
         stream << "," << tensor.size(i);
       }

aten/src/ATen/Formatting.h

@@ -18,7 +18,6 @@ static inline void print(const Tensor & t, int64_t linesize=80) {
 }
 
 static inline std::ostream& operator<<(std::ostream & out, Scalar s) {
-  s = s.local();
   return out << (s.isFloatingPoint() ? s.toDouble() : s.toLong());
 }
 

aten/src/ATen/Retainable.h

@@ -2,11 +2,13 @@
 
 #include <atomic>
 
+#include "ATen/core/ATenGeneral.h"
+
 namespace at {
 
 // base class for refcounted things, allows for collects of generic
 // refcounted objects that include tensors
-struct Retainable {
+struct AT_API Retainable {
   Retainable(): refcount(1), weak_refcount(1) {}
   void retain() {
     ++refcount;

aten/src/ATen/Scalar.cpp

@@ -21,10 +21,6 @@ Tensor Scalar::toTensor() const {
   }
 }
 
-Scalar Scalar::local() const {
-  return *this;
-}
-
 Scalar Scalar::operator-() const {
  if (isFloatingPoint()) {
    return Scalar(-v.d);

aten/src/ATen/Scalar.h

@@ -28,9 +28,6 @@ class AT_API Scalar {
 
 #undef DEFINE_IMPLICIT_CTOR
 
-  // return a new scalar that is guarenteed to be not backed by a tensor.
-  Scalar local() const;
-
 #define DEFINE_ACCESSOR(type,name,member) \
   type to##name () const { \
     if (Tag::HAS_d == tag) { \

aten/src/ATen/SparseTensorImpl.cpp

@@ -75,7 +75,7 @@ TensorImpl* SparseTensorImpl::maybe_zero_dim(bool condition_when_zero_dim) {
            " changing dimensionality via maybe_zero_dim");
   return this;
 }
-const Storage& SparseTensorImpl::storage() {
+const Storage& SparseTensorImpl::storage() const {
   AT_ERROR("sparse tensors do not have storage");
 }
 int64_t SparseTensorImpl::storage_offset() const {

aten/src/ATen/SparseTensorImpl.h

@@ -57,7 +57,7 @@ struct AT_API SparseTensorImpl : public TensorImpl {
 
   int64_t dim() const override;
   TensorImpl* maybe_zero_dim(bool condition_when_zero_dim) override;
-  const Storage& storage() override;
+  const Storage& storage() const override;
   int64_t storage_offset() const override;
 
   // WARNING: This function does NOT preserve invariants of sparseDims/denseDims with

aten/src/ATen/Storage.cpp

@@ -8,7 +8,11 @@ Storage::Storage(
     size_t size,
     Allocator* allocator,
     bool resizable)
-    : storage_impl_(c10::make_intrusive<StorageImpl>(scalar_type, size, allocator, resizable)) {}
+    : storage_impl_(c10::make_intrusive<StorageImpl>(
+          at::scalarTypeToDataType(scalar_type),
+          size,
+          allocator,
+          resizable)) {}
 
 Storage::Storage(
     at::ScalarType scalar_type,
@@ -17,7 +21,7 @@ Storage::Storage(
     const std::function<void(void*)>& deleter,
     bool resizable)
     : storage_impl_(c10::make_intrusive<StorageImpl>(
-          scalar_type,
+          at::scalarTypeToDataType(scalar_type),
           size,
           std::move(data_ptr),
           /* allocator */ nullptr,

aten/src/ATen/Storage.h

@@ -31,10 +31,12 @@ struct AT_API Storage {
   bool resizable() const { return storage_impl_->resizable(); }
   // get() use here is to get const-correctness
   void* data() const { return storage_impl_.get()->data(); }
+  const at::DataType dtype() const {
+    return storage_impl_->dtype();
+  }
   const at::DataPtr& data_ptr() const { return storage_impl_->data_ptr(); }
   DeviceType device_type() const { return storage_impl_->device_type(); }
   at::Allocator* allocator() const { return storage_impl_.get()->allocator(); }
-  at::ScalarType scalar_type() const { return storage_impl_->scalar_type(); }
   at::Device device() const { return storage_impl_->device(); }
 
   StorageImpl* unsafeReleaseStorageImpl() {

aten/src/ATen/StorageImpl.cpp

@@ -4,27 +4,28 @@
 namespace at {
 
 StorageImpl::StorageImpl(
-    at::ScalarType scalar_type,
+    at::DataType data_type,
     ptrdiff_t size,
     at::DataPtr data_ptr,
     at::Allocator* allocator,
     bool resizable)
-    : scalar_type_(scalar_type),
+    : data_type_(data_type),
       data_ptr_(std::move(data_ptr)),
       size_(size),
       resizable_(resizable),
       allocator_(allocator),
       finalizer_(nullptr) {}
 
 StorageImpl::StorageImpl(
-    at::ScalarType scalar_type,
+    at::DataType data_type,
     ptrdiff_t size,
     at::Allocator* allocator,
     bool resizable)
     : StorageImpl(
-          scalar_type,
+          data_type,
           size,
-          allocator->allocate(at::elementSize(scalar_type) * size),
+          allocator->allocate(
+              at::elementSize(dataTypeToScalarType(data_type)) * size),
           allocator,
           resizable) {}
 

aten/src/ATen/StorageImpl.h

@@ -18,18 +18,18 @@ namespace at {
 
 struct Type;
 
-struct AT_API StorageImpl : public c10::raw_intrusive_ptr_target<StorageImpl> {
+struct AT_API StorageImpl : public c10::intrusive_ptr_target {
  public:
   StorageImpl() = delete;
   virtual ~StorageImpl() {};
   StorageImpl(
-      at::ScalarType scalar_type,
+      at::DataType data_type,
       ptrdiff_t size,
       at::DataPtr data_ptr,
       at::Allocator* allocator,
       bool resizable);
   StorageImpl(
-      at::ScalarType scalar_type,
+      at::DataType data_type,
       ptrdiff_t size,
       at::Allocator* allocator,
       bool resizable);
@@ -43,13 +43,14 @@ struct AT_API StorageImpl : public c10::raw_intrusive_ptr_target<StorageImpl> {
   // the real data shouldn't call th::from_type
   template <typename T>
   inline T* data() const {
-    auto scalar_type_T = at::CTypeToScalarType<th::from_type<T>>::to();
-    if (scalar_type_ != scalar_type_T) {
+    auto data_type_T =
+        at::scalarTypeToDataType(at::CTypeToScalarType<th::from_type<T>>::to());
+    if (dtype() != data_type_T) {
       AT_ERROR(
           "Attempt to access StorageImpl having data type ",
-          at::toString(scalar_type_),
+          dtype(),
           " as data type ",
-          at::toString(scalar_type_T));
+          data_type_T);
     }
     return unsafe_data<T>();
   }
@@ -70,7 +71,7 @@ struct AT_API StorageImpl : public c10::raw_intrusive_ptr_target<StorageImpl> {
   void operator=(const StorageImpl&) = delete;
 
   size_t elementSize() const {
-    return at::elementSize(scalar_type_);
+    return at::elementSize(dataTypeToScalarType(data_type_));
   }
 
   Type& type();
@@ -108,9 +109,9 @@ struct AT_API StorageImpl : public c10::raw_intrusive_ptr_target<StorageImpl> {
   at::Allocator* allocator() {
     return allocator_;
   };
-  at::ScalarType scalar_type() const {
-    return scalar_type_;
-  };
+  const DataType dtype() const {
+    return data_type_;
+  }
   const at::Allocator* allocator() const {
     return allocator_;
   };
@@ -129,7 +130,7 @@ struct AT_API StorageImpl : public c10::raw_intrusive_ptr_target<StorageImpl> {
   }
 
  private:
-  at::ScalarType scalar_type_;
+  at::DataType data_type_;
   at::DataPtr data_ptr_;
   ptrdiff_t size_;
   bool resizable_;