     T alpha = static_cast<T>(1.0), beta = static_cast<T>(0.0);
     auto workspace_handle = dev_ctx.cudnn_workspace_handle();
     if (input_grad) {
-      T* input_grad_data = input_grad->mutable_data<T>(ctx.GetPlace());
       // Because beta is zero, it is unnecessary to reset input_grad.
       for (int g = 0; g < groups; g++) {
         auto cudnn_func = [&](void* cudnn_workspace) {
           PADDLE_ENFORCE_CUDA_SUCCESS(
               platform::dynload::cudnnConvolutionForward(
-                  handle, &alpha, cudnn_output_desc,
-                  output_grad_data + output_grad_offset * g, cudnn_filter_desc,
-                  filter_data + filter_offset * g, cudnn_conv_desc, data_algo,
-                  cudnn_workspace, workspace_size_in_bytes, &beta,
-                  cudnn_input_desc, input_grad_data + input_offset * g));
+                  handle, &alpha, args1.idesc.desc(),
+                  output_grad_data + output_grad_offset * g, args1.wdesc.desc(),
+                  filter_data + filter_offset * g, args1.cdesc.desc(),
+                  data_algo, cudnn_workspace, workspace_size, &beta,
+                  args1.odesc.desc(), input_grad_data + input_offset * g));
         };
-        workspace_handle.RunFunc(cudnn_func, workspace_size_in_bytes);
+        workspace_handle.RunFunc(cudnn_func, workspace_size);
       }
 
       if (data_layout == DataLayout::kNHWC) {


    // ------------------- cudnn conv backward filter ---------------------
    if (filter_grad) {
      T* filter_grad_data = filter_grad->mutable_data<T>(ctx.GetPlace());
      // Because beta is zero, it is unnecessary to reset filter_grad.
      // Gradient with respect to the filter
      for (int g = 0; g < groups; g++) {
        auto cudnn_func = [&](void* cudnn_workspace) {
          PADDLE_ENFORCE_CUDA_SUCCESS(
              platform::dynload::cudnnConvolutionBackwardFilter(
                  handle, &alpha, cudnn_output_desc,
                  output_grad_data + output_grad_offset * g, cudnn_input_desc,
                  input_data + input_offset * g, cudnn_conv_desc, filter_algo,
                  cudnn_workspace, workspace_size_in_bytes, &beta,
                  cudnn_filter_desc, filter_grad_data + filter_offset * g));
        };
        workspace_handle.RunFunc(cudnn_func, workspace_size_in_bytes);
      }
    }
  }

namespace operators {

using Tensor = framework::Tensor;
using DataLayout = platform::DataLayout;

template <typename T, int D>
static void DataTranspose(const framework::ExecutionContext& ctx,
