1. Refine test_view unit test case 2. Revert code to make sure all the input tensors of DNNL is contiguous

Author: EikanWang

scripts/cpu/gen-dense-cpu-ops.py

@@ -306,8 +306,7 @@ def is_out_func(fname):
                     if param_var == 'out' and is_out_func(fname):
                         code += '      TORCH_INTERNAL_ASSERT({}.is_contiguous());\n'.format(param_var)
                     else:
-                        # param_seq_str = '{}.is_contiguous() ? {} : {}.contiguous()'.format(param_var, param_var, param_var)
-                        None
+                        param_seq_str = '{}.is_contiguous() ? {} : {}.contiguous()'.format(param_var, param_var, param_var)
                 param_seq_str_vec.append(param_seq_str)
             code += '      if (dbl::chk::dnnl_support_the_tensors(dnnl_input_tensors))\n'
             code += '        return AtenIpexCPUDev::dil_{}({});\n'.format(fname, ', '.join(param_seq_str_vec))

tests/cpu/test_lazy_reorder.py

@@ -368,12 +368,12 @@ def test_addbmm(self):
 
                 addbmm_cpu = torch.addbmm(res_cpu, b1_cpu, b2_cpu, beta=beta, alpha=alpha)
                 addbmm_dpcpp = torch.addbmm(res_dpcpp, b1_dpcpp, b2_dpcpp, beta=beta, alpha=alpha)
-                self.assertEqual(addbmm_cpu, addbmm_dpcpp)
+                self.assertEqual(addbmm_cpu, addbmm_dpcpp, 1e-4)
                 y_cpu = torch.randn(M, O, dtype=torch.float32)
                 y_dpcpp = y_cpu.to(device=device)
                 torch.addbmm(res_cpu, b1_cpu, b2_cpu, beta=beta, alpha=alpha, out=y_cpu)
                 torch.addbmm(res_dpcpp, b1_dpcpp, b2_dpcpp, beta=beta, alpha=alpha, out=y_dpcpp)
-                self.assertEqual(y_cpu, y_dpcpp)
+                self.assertEqual(y_cpu, y_dpcpp, 1e-4)
 
     def test_baddbmm(self):
         ipex.enable_auto_dnnl()
@@ -683,7 +683,6 @@ def test_batch_norm2d_backward(self):
 
         bn = torch.nn.BatchNorm2d(3)
         bn_dpcpp = copy.deepcopy(bn).to(device=device)
-
         y_cpu = bn(x_cpu).sum()
         y_dpcpp = bn_dpcpp(x_dpcpp).sum()
         y_cpu.backward()
@@ -758,21 +757,22 @@ def test_view(self):
         x_dpcpp = x_cpu.to(device=device).clone()
         self.assertTrue(ipex.is_dil_tensor(x_dpcpp))
         self.assertEqual(ipex.get_dil_tensor_sizes(x_dpcpp), [4, 16])
-        self.assertEqual(ipex.is_dil_tensor_strides(x_dpcpp), [16, 1])
+        self.assertEqual(ipex.get_dil_tensor_strides(x_dpcpp), [16, 1])
 
         x_cpu_view = x_cpu.view(new_shape)
         self.assertEqual(x_cpu_view.size(), [1, 4, 4, 4])
         self.assertEqual(x_cpu_view.stride(), [64, 16, 4, 1])
 
         x_dpcpp_view = x_dpcpp.view(new_shape)
         self.assertTrue(ipex.is_dil_tensor(x_dpcpp_view))
-        self.assertEqual(ipex.get_dil_tensor_sizes(x_dpcpp_view), [1, 4, 4, 4])
-        self.assertEqual(ipex.is_dil_tensor_strides(x_dpcpp_view), [64, 16, 4, 1])
 
         y = torch.randn(new_shape)
         out_cpu = x_cpu_view * y
         # test if the shape of x_dpcpp_view is compatible with y
         out_dpcpp = x_dpcpp_view * y
+        self.assertTrue(ipex.is_dil_tensor(out_dpcpp))
+        self.assertEqual(ipex.get_dil_tensor_sizes(out_dpcpp), [1, 4, 4, 4])
+        self.assertEqual(ipex.get_dil_tensor_strides(out_dpcpp), [64, 16, 4, 1])
         self.assertEqual(out_cpu, out_dpcpp)
 
         # test if metadata of x_dpcpp has not been altered

torch_ipex/csrc/aten_ipex_bridge.cpp

@@ -75,7 +75,6 @@ void reorderDilTensorToPublic(const at::Tensor& ipexTensor) {
     TORCH_INTERNAL_ASSERT(shade_data_context->cpu_raw_data == shade_data_context->dil_tensor.get_data_handle());
     TORCH_INTERNAL_ASSERT(shade_data_context->cpu_raw_data != nullptr);
     TORCH_INTERNAL_ASSERT(shade_data_context->cpu_del_fun != nullptr);
-    TORCH_INTERNAL_ASSERT(check_aten_dil_shape_info(ipexTensor, dil_tensor));
 #endif
   } else {
 #if defined(_DEBUG)

torch_ipex/csrc/cpu/DevOPs.cpp

@@ -30,6 +30,7 @@ namespace cpu {
 
 #define CHECK_DNNL_OP_PRE_COND(tensor)                                    \
   TORCH_INTERNAL_ASSERT(tensor.defined());                                \
+  TORCH_INTERNAL_ASSERT(tensor.is_contiguous());                          \
   TORCH_INTERNAL_ASSERT(tensor.layout() == c10::kStrided)
 
 at::Tensor AtenIpexCPUDev::dil_convolution(

torch_ipex/csrc/cpu/ShadeDataContext.h

@@ -110,15 +110,11 @@ struct ShadeDataContext {
         //   C = A[4:7, :]
         // All these tensors share same buffer of Tensor A with different storge offsets and elements.
         // So the context modification will impact all these tensors.
-        if ((shade_data_context->dil_tensor.get_data_handle() == raw_cpu_data) &&
-            (shade_data_context->dil_tensor.get_nelems() == tensor.storage().numel()) &&
-            (shade_data_context->dil_tensor.get_data_type() == get_dil_data_type(tensor.scalar_type()))) {
-          //TODO: Do we need to check strides here?
+        if (check_tensor_own_whole_storage(tensor)) {
           TORCH_INTERNAL_ASSERT(shade_data_context->dil_tensor.get_size() == tensor.storage().capacity());
           return true;
         }
       }
-      TORCH_INTERNAL_ASSERT(false);
     }
 
     return false;
@@ -145,13 +141,9 @@ struct ShadeDataContext {
     TORCH_INTERNAL_ASSERT(tensor.has_storage());
     void *raw_context = tensor.storage().data_ptr().get_context();
     TORCH_INTERNAL_ASSERT(raw_context != nullptr);
-    if (isDilTensor(tensor)) {
-      ShadeDataContext *shade_data_context = (ShadeDataContext*)raw_context;
-      return shade_data_context->dil_tensor;
-    } else {
-      TORCH_INTERNAL_ASSERT(false);
-      return dil::tensor();
-    }
+    TORCH_INTERNAL_ASSERT(isDilTensor(tensor));
+    ShadeDataContext *shade_data_context = (ShadeDataContext*)raw_context;
+    return shade_data_context->dil_tensor;
   }
 
   /**

torch_ipex/csrc/cpu/dbl/Common.cpp

@@ -37,7 +37,7 @@ at::Tensor dil_tensor_to_dense(const at::Tensor& tensor) {
 dil::tensor try_gen_dil_tensor(const at::Tensor &input) {
   if (cpu::ShadeDataContext::isDilTensor(input)) {
     auto dil_tensor = cpu::ShadeDataContext::getDilTensor(input);
-    if (dil_tensor.is_public_format()) {
+    if ((!check_aten_dil_shape_info(input, dil_tensor)) && dil_tensor.is_public_format()) {
       dil_tensor.set_dims_and_strides(input.sizes().vec(), input.strides().vec());
     }
     return dil_tensor;

torch_ipex/csrc/init_python_bindings.cpp

@@ -124,7 +124,7 @@ void InitIpexModuleBindings(py::module m) {
 
   m.def("is_dil_tensor", &isDilTensor);
   m.def("get_dil_tensor_sizes", &getDilTensorSizes);
-  m.def("is_dil_tensor_strides", &getDilTensorStrides);
+  m.def("get_dil_tensor_strides", &getDilTensorStrides);
 }
 
 }  // namespace