Fix most failed test cases.

Two known issues here:
1. matmul does not support broadcast operator. Pinzhen will refine matmul DNNL op
2. does not register all data types for DPCPP backend. Eikan will fix it.

Author: EikanWang

tests/cpu/test_torch.py

@@ -81,7 +81,7 @@
 from multiprocessing.reduction import ForkingPickler
 from common_device_type import instantiate_device_type_tests, \
     skipIf, skipCPUIfNoLapack, skipCUDAIfNoMagma, skipCUDAIfRocm, onlyCUDA, onlyCPU, \
-    dtypes, dtypesIfCUDA, deviceCountAtLeast, skipCUDAIf, precisionOverride
+    dtypes, dtypesIfCUDA, deviceCountAtLeast, skipCUDAIf, precisionOverride, ipex
 import torch.backends.quantized
 
 
@@ -8725,7 +8725,10 @@ def test_diagflat(self, device):
 
         # Noncontig input
         x = torch.randn((2, 3, 4), dtype=dtype, device=device).transpose(2, 0)
-        self.assertFalse(x.is_contiguous())
+        if ipex.get_auto_dnnl():
+            self.assertTrue(x.is_contiguous())
+        else:
+            self.assertFalse(x.is_contiguous())
         result = torch.diagflat(x)
         expected = torch.diag(x.contiguous().view(-1))
         self.assertEqual(result, expected)
@@ -9773,8 +9776,12 @@ def test_cdist_non_contiguous(self, device):
             y = torch.randn(5, 3, device=device).transpose(-1, -2)
             actual = torch.cdist(x, y, p=1, compute_mode=cm)
             expected = brute_cdist(x, y, p=1)
-            self.assertFalse(x.is_contiguous())
-            self.assertFalse(y.is_contiguous())
+            if ipex.get_auto_dnnl():
+                self.assertTrue(x.is_contiguous())
+                self.assertTrue(y.is_contiguous())
+            else:
+                self.assertFalse(x.is_contiguous())
+                self.assertFalse(y.is_contiguous())
             self.assertTrue(torch.allclose(expected, actual))
 
             x = torch.randn(7, 5, device=device)
@@ -9799,23 +9806,33 @@ def test_cdist_non_contiguous_batch(self, device):
             y = torch.randn(4, 3, 2, 5, 3, device=device).transpose(-1, -2)
             actual = torch.cdist(x, y, p=1, compute_mode=cm)
             expected = brute_cdist(x, y, p=1)
-            self.assertFalse(x.is_contiguous())
-            self.assertFalse(y.is_contiguous())
+            if ipex.get_auto_dnnl():
+                self.assertTrue(x.is_contiguous())
+                self.assertTrue(y.is_contiguous())
+            else:
+                self.assertFalse(x.is_contiguous())
+                self.assertFalse(y.is_contiguous())
             self.assertTrue(torch.allclose(expected, actual))
 
             x = torch.randn(7, 2, 7, 5, device=device)
             y = torch.randn(7, 2, 5, 3, device=device).transpose(-1, -2)
             actual = torch.cdist(x, y, p=1, compute_mode=cm)
             expected = brute_cdist(x, y, p=1)
             self.assertTrue(x.is_contiguous())
-            self.assertFalse(y.is_contiguous())
+            if ipex.get_auto_dnnl():
+                self.assertTrue(y.is_contiguous())
+            else:
+                self.assertFalse(y.is_contiguous())
             self.assertTrue(torch.allclose(expected, actual))
 
             x = torch.randn(4, 5, 7, device=device).transpose(-1, -2)
             y = torch.randn(4, 3, 5, device=device)
             actual = torch.cdist(x, y, p=1, compute_mode=cm)
             expected = brute_cdist(x, y, p=1)
-            self.assertFalse(x.is_contiguous())
+            if ipex.get_auto_dnnl():
+                self.assertTrue(x.is_contiguous())
+            else:
+                self.assertFalse(x.is_contiguous())
             self.assertTrue(y.is_contiguous())
             self.assertTrue(torch.allclose(expected, actual))
 
@@ -10249,6 +10266,7 @@ def test_unfold_scalars(self, device):
 
     def test_copy_all_dtypes_and_devices(self, device):
         from copy import copy
+        ipex.enable_auto_dnnl()
         for dt in torch.testing.get_all_dtypes():
             x = torch.tensor([1, 2, 3, 4], dtype=dt, device=device)
             x_clone = x.clone()
@@ -10264,6 +10282,7 @@ def test_copy_all_dtypes_and_devices(self, device):
             # copy is a shallow copy, only copies the tensor view,
             # not the data
             self.assertEqual(x, y)
+        ipex.enable_auto_dnnl()
 
     def test_resize_all_dtypes_and_devices(self, device):
         shape = (2, 2)
@@ -10761,7 +10780,8 @@ def test_tensor_shape_empty(self, device):
         self.assertEqual([(0, 1, 0, 0), (0, 1, 1, 0), (0, 1, 2, 0)],
                          [z.shape for z in torch.split(x, (0, 1, 2), dim=2)])
 
-        self.assertRaises(RuntimeError, lambda: torch.split(x, 0, dim=1))
+        with self.assertRaises(RuntimeError):
+            torch.split(x, 0, dim=1)
         # This is strange because the split size is larger than the dim size, but consistent with
         # how split handles that case generally (when no 0s are involved).
         self.assertEqual([(0, 1, 3, 0)], [z.shape for z in torch.split(x, 1, dim=0)])
@@ -12764,8 +12784,12 @@ def _test_memory_format_transformations(self, device, input_generator_fn, transf
         clone = transformation_fn(xc)
 
         if default_is_preserve:
-            self.assertFalse(clone.is_contiguous())
-            self.assertTrue(clone.is_contiguous(memory_format=memory_format))
+            if ipex.get_auto_dnnl():
+                self.assertTrue(clone.is_contiguous())
+                self.assertFalse(clone.is_contiguous(memory_format=memory_format))
+            else:
+                self.assertFalse(clone.is_contiguous())
+                self.assertTrue(clone.is_contiguous(memory_format=memory_format))
         else:
             self.assertTrue(clone.is_contiguous())
             self.assertFalse(clone.is_contiguous(memory_format=memory_format))
@@ -14398,7 +14422,6 @@ def fn(self, device, dtype):
         # Runs the tensor op on CPU and device
         cpu_result = getattr(cpu_tensor, op_str)(*cpu_args)
         device_result = getattr(device_tensor, op_str)(*device_args)
-
         # Compares CPU and device inputs and outputs
         precision = half_precision if dtype == torch.half else float_precision
 
@@ -14512,4 +14535,5 @@ class TestTorch(TestCase, _TestTorchMixin):
 instantiate_device_type_tests(TestTensorDeviceOps, globals(), except_for='cpu')
 
 if __name__ == '__main__':
+    ipex.enable_auto_dnnl()
     run_tests()

torch_ipex/csrc/aten_ipex_bridge.cpp

@@ -64,9 +64,10 @@ at::Tensor shallowFallbackToCPUTensorImpl(const at::Tensor& ipexTensor);
 void reorderDilTensorToPublic(const at::Tensor& ipexTensor) {
   void *data_ctx = ipexTensor.unsafeGetTensorImpl()->storage().data_ptr().get_context();
   cpu::ShadeDataContext *shade_data_context = (cpu::ShadeDataContext*)data_ctx;
-  // All aten::tensor with dnnl::tensor should be contiguous
+#if defined(_DEBUG)
   TORCH_WARN(ipexTensor.is_contiguous());
   TORCH_INTERNAL_ASSERT(! (shade_data_context->dil_tensor.is_empty()));
+#endif
   dil::tensor &dil_tensor = shade_data_context->dil_tensor;
 
   if (dil_tensor.is_public_format()) {
@@ -298,32 +299,6 @@ at::Tensor upgradeToDPCPPTensor(const at::Tensor& cpuTensor) {
   return _tensor;
 }
 
-at::Tensor shallowUpgradeToDPCPPShadeTensor(const at::Tensor& cpuTensor) {
-  if (!(cpuTensor.defined())) {
-    return at::Tensor();
-  }
-  TORCH_INTERNAL_ASSERT(cpuTensor.device().type() == at::DeviceType::CPU);
-  if (cpuTensor.is_sparse()) shallowUpgradeToDPCPPTensor(cpuTensor);
-
-  auto cpu_storage_impl = cpuTensor.storage().unsafeGetStorageImpl();
-  auto& data_ptr = cpu_storage_impl->data_ptr();
-  auto cur_del_fn = data_ptr.get_deleter();
-  bool res = data_ptr.compare_exchange_deleter(cur_del_fn, &(c10::detail::deleteNothing));
-  TORCH_INTERNAL_ASSERT(res);
-  // Make sure that does not triger free resource for set_ptr
-  cpu::ShadeDataContext *shade_data_context = cpu::ShadeDataContext::allocShadeDataContext();
-  shade_data_context->cpu_raw_data = data_ptr.get();
-  shade_data_context->cpu_del_fun = cur_del_fn;
-  shade_data_context->data_type = cpu::SHADE_DATA_TYPE::CPU_RAW;
-  c10::DataPtr shade_data_ptr(
-    data_ptr.get(),
-    shade_data_context,
-    cpu::ShadeDataContext::freeShadeDataContext,
-    at::DeviceType::CPU);
-  cpuTensor.unsafeGetTensorImpl()->storage().set_data_ptr(std::move(shade_data_ptr));
-  return shallowUpgradeToDPCPPTensor(cpuTensor);
-}
-
 // Upgrade CPU tensor to DPCPP Tensor with shallow copy
 // It will create an new DPCPP tensor but shares CPU tensor buffer
 // [NOTE]: Device info of Dense CPU tensor is polluted.

torch_ipex/csrc/cpu/DevOPs.cpp

@@ -1089,10 +1089,13 @@ at::Tensor AtenIpexCPUDev::dil_clone(const at::Tensor& self, c10::optional<c10::
 at::Tensor AtenIpexCPUDev::dil_transpose(const at::Tensor & self, int64_t dim0, int64_t dim1) {
   DEBUG("AtenIpexCPUDev::dil_transpose\n");
   CHECK_DNNL_OP_PRE_COND(self);
-  const dil::tensor& x = dbl::comm::try_gen_dil_tensor(self);
+  dil::tensor x = dbl::comm::try_gen_dil_tensor(self);
+  TORCH_CHECK(x.ndims() > 0, "DNNL transpose cannot generate DNNL tensor for the input aten Tensor. input tensor dim: ", self.dim());
   dil::tensor y;
   std::vector<int> axes(x.ndims());
   std::iota(axes.begin(), axes.end(), 0);
+  dim0 = at::maybe_wrap_dim(dim0, self.dim());
+  dim1 = at::maybe_wrap_dim(dim1, self.dim());
   std::swap(axes[dim0], axes[dim1]);
   y.transpose_from(x, axes);
   return dbl::comm::gen_aten_tensor_by(y);
@@ -1110,7 +1113,7 @@ at::Tensor& AtenIpexCPUDev::dil_cat_out(at::Tensor& result, at::TensorList tenso
   DEBUG("AtenIpexCPUDev::dil_cat_out\n");
   CHECK_DNNL_OP_PRE_COND(result);
   check_cat_no_zero_dim(tensors);
-  dim = legacy_cat_wrap_dim(dim, tensors);
+  dim = at::legacy_cat_wrap_dim(dim, tensors);
   std::vector<dil::tensor> x;
   for (auto i =0; i< tensors.size(); i++) {
     TORCH_CHECK(!(tensors[i].dim() == 1 && tensors[i].sizes()[0] == 0),
@@ -1126,7 +1129,7 @@ at::Tensor& AtenIpexCPUDev::dil_cat_out(at::Tensor& result, at::TensorList tenso
 at::Tensor AtenIpexCPUDev::dil_cat(at::TensorList tensors, int64_t dim) {
   DEBUG("AtenIpexCPUDev::dil_cat\n");
   check_cat_no_zero_dim(tensors);
-  dim = legacy_cat_wrap_dim(dim, tensors);
+  dim = at::legacy_cat_wrap_dim(dim, tensors);
   std::vector<dil::tensor> x;
   at::Tensor tensors_contiguous[tensors.size()];
   for (auto i = 0; i < tensors.size(); i++) {
@@ -1154,6 +1157,8 @@ std::vector<at::Tensor> AtenIpexCPUDev::dil_split_with_sizes(const at::Tensor& s
              "entries, but got split_sizes=", split_sizes);
     sizes.push_back((int32_t)length);
   }
+
+  dim = at::maybe_wrap_dim(dim, self.dim());
   auto y = dil::spliter::compute(x, sizes, dim, false);
   for (auto j = 0; j < num_splits; j++) {
     splits[j] = dbl::comm::gen_aten_tensor_by(y[j]);
@@ -1164,6 +1169,7 @@ std::vector<at::Tensor> AtenIpexCPUDev::dil_split_with_sizes(const at::Tensor& s
 std::vector<at::Tensor> AtenIpexCPUDev::dil_split(const at::Tensor& self, int64_t split_size, int64_t dim) {
   DEBUG("AtenIpexCPUDev::dil_split\n");
   CHECK_DNNL_OP_PRE_COND(self);
+  dim = at::maybe_wrap_dim(dim, self.dim());
   int64_t dim_size = self.size(dim);
   int64_t num_splits = 1;
   if (split_size != 0) {

torch_ipex/csrc/cpu/ShadeDataContext.h

@@ -90,7 +90,9 @@ struct ShadeDataContext {
     TORCH_INTERNAL_ASSERT((data_type == SHADE_DATA_TYPE::CPU_RAW) || (data_type == SHADE_DATA_TYPE::DIL));
 
     if (data_type == SHADE_DATA_TYPE::DIL) {
+#if defined(_DEBUG)
       TORCH_WARN(tensor.is_contiguous());
+#endif
       auto raw_cpu_data = tensor.storage().data_ptr().get();
       if (raw_cpu_data == nullptr) {
         // the dnnl tensor does not share data with raw tensor data.

torch_ipex/csrc/cpu/dbl/DNNLChecker.cpp

@@ -9,12 +9,13 @@ namespace dbl {
 namespace chk {
 
 bool dnnl_support_the_tensors(const std::vector<at::Tensor> &tensor_vec) {
-  return dnnl_support_the_dimension_of(tensor_vec) &&
+  return dnnl_tensor_has_data(tensor_vec) &&
+         dnnl_support_the_dimension_of(tensor_vec) &&
          dnnl_support_the_data_type_of(tensor_vec);
 }
 
 bool dnnl_inplace_support_the_tensors(const std::vector<at::Tensor> &tensor_vec) {
-  return dnnl_support_the_dimension_of(tensor_vec) &&
+  return dnnl_tensor_has_data(tensor_vec) &&
          dnnl_support_the_data_type_of(tensor_vec) &&
          dnnl_support_the_memory_layout_of(tensor_vec);
 }
@@ -53,6 +54,14 @@ bool dnnl_support_the_dimension_of(const std::vector<at::Tensor> &tensor_vec) {
   return true;
 }
 
+bool dnnl_tensor_has_data(const std::vector<at::Tensor> &tensor_vec) {
+  for (auto it = tensor_vec.begin(); it != tensor_vec.end(); ++it)
+    if (it->data_ptr() == nullptr)
+      return false;
+
+  return true;
+}
+
 }  // namespace chk
 }  // namespace dbl
 }  // namespace cpu

torch_ipex/csrc/cpu/dbl/DNNLChecker.h

@@ -61,6 +61,14 @@ bool dnnl_support_the_data_type_of(const std::vector<at::Tensor> &tensor_vec);
  */
 bool dnnl_support_the_dimension_of(const std::vector<at::Tensor> &tensor_vec);
 
+/**
+ * Check if the input tensor has data
+ *
+ * @param tensor_vec input tensors
+ *
+ */
+static inline bool dnnl_tensor_has_data(const std::vector<at::Tensor> &tensor_vec);
+
 }  // namespace chk
 }  // namespace dbl
 }  // namespace cpu

torch_ipex/csrc/utils.cpp

@@ -80,7 +80,9 @@ dil::data_type get_dil_data_type(at::ScalarType at_dt) {
   }  else if (at_dt == at::ScalarType::QUInt8) {
     return dil::data_type::u8;
   } else {
+#if defined(_DEBUG)
     TORCH_WARN("DNNL does not support current data type.");
+#endif
     return dil::data_type::undef;
   }
 }
@@ -109,7 +111,8 @@ bool check_tensor_own_whole_storage(const at::Tensor& tensor) {
     return false;
 
   return (tensor.storage_offset() == 0) &&
-         (tensor.numel() == tensor.storage().numel());
+         (tensor.numel() == tensor.storage().numel()) &&
+         (tensor.itemsize() == tensor.storage().itemsize());
 }
 
 bool check_tensor_own_shade_context(const at::Tensor& tensor) {