Merge from upstream

.jenkins/caffe2/build.sh

@@ -226,7 +226,7 @@ else
     export MAX_JOBS=`expr $(nproc) - 1`
   fi
 
-  FULL_CAFFE2=1 python setup.py install --user
+  USE_OPENCV=1 BUILD_BINARY=1 python setup.py install --user
 
   # This is to save test binaries for testing
   cp -r torch/lib/tmp_install $INSTALL_PREFIX

CMakeLists.txt

@@ -56,7 +56,7 @@ include(CMakeDependentOption)
 option(BUILD_TORCH "Build Torch" OFF)
 option(ATEN_NO_TEST "Do not build ATen test binaries" OFF)
 option(BUILD_ATEN_MOBILE "Build ATen for Android and iOS" OFF)
-option(BUILD_BINARY "Build C++ binaries" ON)
+option(BUILD_BINARY "Build C++ binaries" OFF)
 option(BUILD_DOCS "Build Caffe2 documentation" OFF)
 option(BUILD_CUSTOM_PROTOBUF "Build and use Caffe2's own protobuf under third_party" ON)
 option(BUILD_PYTHON "Build Python binaries" ON)
@@ -115,7 +115,7 @@ option(USE_IDEEP "Use IDEEP interface in MKL BLAS" ON)
 option(USE_MKLML "Use MKLML interface in MKL BLAS" ON)
 option(USE_DISTRIBUTED "Use distributed" ON)
 cmake_dependent_option(
-    USE_MPI "Use MPI. Only available if USE_DISTRIBUTED is on." ON
+    USE_MPI "Use MPI for Caffe2. Only available if USE_DISTRIBUTED is on." OFF
     "USE_DISTRIBUTED" OFF)
 cmake_dependent_option(
     USE_GLOO "Use Gloo. Only available if USE_DISTRIBUTED is on." ON

aten/src/ATen/Context.cpp

@@ -107,19 +107,33 @@ bool Context::setFlushDenormal(bool on) {
 #endif
 }
 
-Type& getMaybeVariableType(TensorOptions options) {
-  return globalContext().getMaybeVariableType(
+Type& getType(TensorOptions options) {
+  return globalContext().getType(
             options.backend(), options.dtype(), options.is_variable());
 }
 
-Type& getMaybeVariableType(const TensorImpl* impl) {
+Type& getType(const TensorImpl* impl) {
   Backend backend = tensorTypeIdToBackend(impl->type_id());
-  return globalContext().getMaybeVariableType(
+  return globalContext().getType(
             backend, impl->scalar_type(), impl->is_variable());
 }
 
 Allocator* getCPUAllocator() {
   return getTHDefaultAllocator();
 }
 
+struct LegacyTypeInit : public LegacyTypeInitInterface {
+  LegacyTypeInit(LegacyTypeInitArgs) {}
+  void initCPU() const override {
+    globalContext();
+  }
+  void initCUDA() const override {
+    globalContext().lazyInitCUDA();
+  }
+  void initComplex() const override {
+    globalContext().lazyInitComplex();
+  }
+};
+REGISTER_LEGACY_TYPE_INIT(LegacyTypeInit);
+
 }

aten/src/ATen/Context.h

@@ -8,8 +8,9 @@
 #include "ATen/Utils.h"
 #include "ATen/core/Error.h"
 #include "ATen/detail/CUDAHooksInterface.h"
-#include "ATen/detail/VariableHooksInterface.h"
+#include "ATen/core/VariableHooksInterface.h"
 #include "ATen/detail/ComplexHooksInterface.h"
+#include "ATen/core/LegacyTypeDispatch.h"
 
 // This is temporary
 #include "ATen/core/ATenCoreTest.h"
@@ -24,43 +25,25 @@ class AT_API Context {
 public:
   Context();
   Type* getNonVariableTypeRaw(Backend p, ScalarType s) {
-    return type_registry[static_cast<int>(p)][static_cast<int>(s)].get();
+    return globalLegacyTypeDispatch().getNonVariableTypeRaw(p, s);
   }
   Type * getNonVariableTypeOpt(Backend p, ScalarType s) {
-    if (p != Backend::Undefined) {
-      initCUDAIfNeeded(backendToDeviceType(p));
-      initComplexIfNeeded(s);
-    }
-    auto type = getNonVariableTypeRaw(p, s);
-
-    if(!type) {
-      // there is only a single Undefined Type.
-      if (p == Backend::Undefined || s == ScalarType::Undefined) {
-        return getNonVariableTypeRaw(Backend::Undefined, ScalarType::Undefined);
-      }
-    }
-
-    return type;
+    return globalLegacyTypeDispatch().getNonVariableTypeOpt(p, s);
   }
   Type & getNonVariableType(Backend p, ScalarType s) {
-    auto* type = getNonVariableTypeOpt(p, s);
-    if (!type) AT_ERROR(toString(p), toString(s), "Type is not enabled.");
-    return *type;
+    return globalLegacyTypeDispatch().getNonVariableType(p, s);
   }
   Type & getVariableType(Backend p, ScalarType s) {
-    auto& baseType = getNonVariableType(p, s);
-    return detail::getVariableHooks().getVariableTypeFromBaseType(baseType);
-  }
-  Type & getMaybeVariableType(Backend p, ScalarType s, bool is_variable) {
-    if (is_variable) {
-      return getVariableType(p, s);
-    } else {
-      return getNonVariableType(p, s);
-    }
+    return globalLegacyTypeDispatch().getVariableType(p, s);
+  }
+  Type & getType(Backend p, ScalarType s, bool is_variable) {
+    return globalLegacyTypeDispatch().getType(p, s, is_variable);
   }
+  // The passed in Type must be delete'able
+  // TODO: Just make it take a unique_ptr
   void registerType(Backend b, ScalarType s, Type* t) {
-    type_registry[static_cast<int>(b)][static_cast<int>(s)].reset(t);
-    detail::getVariableHooks().registerVariableTypeFor(this, b, s);
+    globalLegacyTypeDispatch().registerType(b, s,
+      LegacyTypeDispatch::TypeUniquePtr{t, LegacyTypeDeleter([](Type* p) { delete p; }) });
   }
 
   Generator & defaultGenerator(DeviceType device_type) {
@@ -127,11 +110,6 @@ class AT_API Context {
   std::unique_ptr<Generator>
     generator_registry[static_cast<int>(DeviceType::COMPILE_TIME_MAX_DEVICE_TYPES)];
 private:
-  // NB: type_registry has nullptr for all CUDA backends until
-  // CUDA initialization has occurred
-  std::unique_ptr<Type> type_registry
-    [static_cast<int>(Backend::NumOptions)]
-    [static_cast<int>(ScalarType::NumOptions)];
   void initCUDAIfNeeded(DeviceType p) {
     if (p == DeviceType::CUDA) {
       lazyInitCUDA();
@@ -150,8 +128,6 @@ class AT_API Context {
   std::atomic<size_t> next_id;
   std::unique_ptr<THCState, void(*)(THCState*)> thc_state;
   friend struct Type;
-  friend void register_cpu_types(Context * context);
-  friend void register_cuda_types(Context * context);
 };
 
 AT_API Context & globalContext();
@@ -174,8 +150,8 @@ static inline Type& getNonVariableType(DeviceType p, ScalarType s) {
   return globalContext().getNonVariableType(deviceTypeToBackend(p), s);
 }
 
-AT_API Type& getMaybeVariableType(TensorOptions options);
-AT_API Type& getMaybeVariableType(const TensorImpl*);
+AT_API Type& getType(TensorOptions options);
+AT_API Type& getType(const TensorImpl*);
 
 AT_API Allocator* getCPUAllocator();