Fix linting

Author: MatthijsBurgh

src/caffe/layers/cudnn_conv_layer.cpp

@@ -116,7 +116,7 @@ void CuDNNConvolutionLayer<Dtype>::Reshape(
   cudnnConvolutionFwdAlgoPerf_t     fwd_algo_pref_[4];
   cudnnConvolutionBwdDataAlgoPerf_t bwd_data_algo_pref_[4];
 
-  //get memory sizes
+  // get memory sizes
   cudaMemGetInfo(&free_memory, &total_memory);
 #else
   // Specify workspace limit for kernels directly until we have a
@@ -142,46 +142,63 @@ void CuDNNConvolutionLayer<Dtype>::Reshape(
 // Note: Copied from https://github.com/Qengineering/caffe/tree/ssd/src/caffe/layers
 #if CUDNN_VERSION_MIN(8, 0, 0)
     // choose forward algorithm for filter
-    // in forward filter the CUDNN_CONVOLUTION_FWD_ALGO_WINOGRAD_NONFUSED is not implemented in cuDNN 8
-    CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm_v7(handle_[0], bottom_descs_[i], filter_desc_, conv_descs_[i], top_descs_[i], 4, &RetCnt, fwd_algo_pref_));
+    // in forward filter the CUDNN_CONVOLUTION_FWD_ALGO_WINOGRAD_NONFUSED is not
+    // implemented in cuDNN 8
+    CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm_v7(handle_[0],
+      bottom_descs_[i],
+      filter_desc_,
+      conv_descs_[i],
+      top_descs_[i],
+      4,
+      &RetCnt,
+      fwd_algo_pref_));
 
     found_conv_algorithm = false;
-    for(int n=0;n<RetCnt;n++){
+    for (int n = 0; n < RetCnt; n++) {
       if (fwd_algo_pref_[n].status == CUDNN_STATUS_SUCCESS &&
-          fwd_algo_pref_[n].algo != CUDNN_CONVOLUTION_FWD_ALGO_WINOGRAD_NONFUSED &&
-          fwd_algo_pref_[n].memory < free_memory){
+          fwd_algo_pref_[n].algo != CUDNN_CONVOLUTION_FWD_ALGO_WINOGRAD_NONFUSED &&  // NOLINT(whitespace/line_length)
+          fwd_algo_pref_[n].memory < free_memory) {
         found_conv_algorithm = true;
         fwd_algo_[i] = fwd_algo_pref_[n].algo;
         workspace_fwd_sizes_[i] = fwd_algo_pref_[n].memory;
         break;
       }
     }
-    if(!found_conv_algorithm) LOG(ERROR) << "cuDNN did not return a suitable algorithm for convolution.";
-    else{
+    if (!found_conv_algorithm) {
+      LOG(ERROR) << "cuDNN did not return a suitable algorithm for convolution.";  // NOLINT(whitespace/line_length)
+    } else {
       // choose backward algorithm for filter
         // for better or worse, just a fixed constant due to the missing
         // cudnnGetConvolutionBackwardFilterAlgorithm in cuDNN version 8.0
       bwd_filter_algo_[i] = CUDNN_CONVOLUTION_BWD_FILTER_ALGO_1;
-      //twice the amount of the forward search to be save
+      // twice the amount of the forward search to be save
       workspace_bwd_filter_sizes_[i] = 2*workspace_fwd_sizes_[i];
     }
 
     // choose backward algo for data
-    CUDNN_CHECK(cudnnGetConvolutionBackwardDataAlgorithm_v7(handle_[0], filter_desc_, top_descs_[i], conv_descs_[i], bottom_descs_[i], 4, &RetCnt, bwd_data_algo_pref_));
+    CUDNN_CHECK(cudnnGetConvolutionBackwardDataAlgorithm_v7(handle_[0],
+      filter_desc_,
+      top_descs_[i],
+      conv_descs_[i],
+      bottom_descs_[i],
+      4,
+      &RetCnt,
+      bwd_data_algo_pref_));
 
     found_conv_algorithm = false;
-    for(int n=0;n<RetCnt;n++){
+    for (int n = 0; n < RetCnt; n++) {
       if (bwd_data_algo_pref_[n].status == CUDNN_STATUS_SUCCESS &&
-          bwd_data_algo_pref_[n].algo != CUDNN_CONVOLUTION_BWD_DATA_ALGO_WINOGRAD &&
-          bwd_data_algo_pref_[n].algo != CUDNN_CONVOLUTION_BWD_DATA_ALGO_WINOGRAD_NONFUSED &&
-          bwd_data_algo_pref_[n].memory < free_memory){
+          bwd_data_algo_pref_[n].algo != CUDNN_CONVOLUTION_BWD_DATA_ALGO_WINOGRAD &&  // NOLINT(whitespace/line_length)
+          bwd_data_algo_pref_[n].algo != CUDNN_CONVOLUTION_BWD_DATA_ALGO_WINOGRAD_NONFUSED &&  // NOLINT(whitespace/line_length)
+          bwd_data_algo_pref_[n].memory < free_memory) {
         found_conv_algorithm = true;
         bwd_data_algo_[i]              = bwd_data_algo_pref_[n].algo;
         workspace_bwd_data_sizes_[i]   = bwd_data_algo_pref_[n].memory;
         break;
       }
     }
-    if(!found_conv_algorithm) LOG(ERROR) << "cuDNN did not return a suitable algorithm for convolution.";
+    if (!found_conv_algorithm)
+      LOG(ERROR) << "cuDNN did not return a suitable algorithm for convolution.";  // NOLINT(whitespace/line_length)
 #else
     // choose forward and backward algorithms + workspace(s)
     CUDNN_CHECK(cudnnGetConvolutionForwardAlgorithm(handle_[0],

src/caffe/layers/cudnn_deconv_layer.cpp

@@ -154,7 +154,7 @@ void CuDNNDeconvolutionLayer<Dtype>::Reshape(
 
   //   // We have found that CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_PRECOMP_GEMM is
   //   // buggy. Thus, if this algo was chosen, choose winograd instead. If
-  //   // winograd is not supported or workspace is larger than threshold, choose
+  //   // winograd is not supported or workspace is larger than threshold, choose  // NOLINT(whitespace/line_length)
   //   // implicit_gemm instead.
   //   if (fwd_algo_[i] == CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_PRECOMP_GEMM) {
   //     size_t winograd_workspace_size;
@@ -226,7 +226,7 @@ void CuDNNDeconvolutionLayer<Dtype>::Reshape(
   //       &workspace_bwd_data_sizes_[i]));
   // }
 
-  // // reduce over all workspace sizes to get a maximum to allocate / reallocate
+  // // reduce over all workspace sizes to get a maximum to allocate / reallocate  // NOLINT(whitespace/line_length)
   // size_t total_workspace_fwd = 0;
   // size_t total_workspace_bwd_data = 0;
   // size_t total_workspace_bwd_filter = 0;
@@ -255,7 +255,7 @@ void CuDNNDeconvolutionLayer<Dtype>::Reshape(
   //   // free the existing workspace and allocate a new (larger) one
   //   cudaFree(this->workspaceData);
 
-  //   cudaError_t err = cudaMalloc(&(this->workspaceData), workspaceSizeInBytes);
+  //   cudaError_t err = cudaMalloc(&(this->workspaceData), workspaceSizeInBytes);  // NOLINT(whitespace/line_length)
   //   if (err != cudaSuccess) {
   //     // force zero memory path
   //     for (int i = 0; i < bottom.size(); i++) {
@@ -278,7 +278,7 @@ void CuDNNDeconvolutionLayer<Dtype>::Reshape(
 
   //   // if we succeed in the allocation, set pointer aliases for workspaces
   //   for (int g = 0; g < (this->group_ * CUDNN_STREAMS_PER_GROUP); g++) {
-  //     workspace[g] = reinterpret_cast<char *>(workspaceData) + g*max_workspace;
+  //     workspace[g] = reinterpret_cast<char *>(workspaceData) + g*max_workspace;  // NOLINT(whitespace/line_length)
   //   }
   // }