Clang-format-10: bad format style: skip comment was added

Author: mozga-intel

src/engine/threaded_engine_pooled.cc

@@ -152,10 +152,12 @@ class ThreadedEnginePooled : public ThreadedEngine {
       LOG(FATAL) << "Please compile with CUDA enabled";
 #endif  // MXNET_USE_CUDA
     }
+    // clang-format off
     bool is_copy = (opr_block->opr->prop == FnProperty::kCopyFromGPU ||
                     opr_block->opr->prop == FnProperty::kCopyToGPU);
     auto&& rctx  = is_copy ? streams_->GetIORunContext(opr_block->ctx) :
                              streams_->GetRunContext(opr_block->ctx);
+    // clang-format on
 #if MXNET_USE_CUDA
     CallbackOnStart on_start;
     CallbackOnComplete callback;

src/kvstore/kvstore_dist.h

@@ -507,10 +507,12 @@ class KVStoreDist : public KVStoreLocal {
       size_t size         = recv_buf.shape().Size();
       const int dtype     = recv_buf.dtype();
       const int num_bytes = mshadow::mshadow_sizeof(dtype);
+      // clang-format off
       PSKV& pskv          = (gradient_compression_->get_type() == CompressionType::kNone) ?
                                 EncodeDefaultKey(key, size, num_bytes) :
                                 EncodeCompressedKey(key, size, false, num_bytes);
-      char* data          = static_cast<char*>(recv_buf.data().dptr_);
+      // clang-format on
+      char* data = static_cast<char*>(recv_buf.data().dptr_);
       // false means not to delete data when SArray is deleted
       auto vals = new ps::SArray<char>(data, size * num_bytes, false);
       // issue pull

src/operator/contrib/bilinear_resize-inl.h

@@ -270,12 +270,14 @@ static bool BilinearSampleOpInferShape(const nnvm::NodeAttrs& attrs,
       break;
     }
     case bilinear_resize::odd_scale: {
+      // clang-format off
       new_height = ((dshape[2] % 2) == 0) ?
                        (int16_t)(dshape[2] * param.scale_height.value()) :
                        (int16_t)((dshape[2] - 1) * param.scale_height.value()) + 1;
       new_width  = ((dshape[3] % 2) == 0) ?
                        (int16_t)(dshape[3] * param.scale_width.value()) :
                        (int16_t)((dshape[3] - 1) * param.scale_width.value()) + 1;
+      // clang-format on
       break;
     }
     case bilinear_resize::like: {

src/operator/contrib/bounding_box.cu

@@ -489,9 +489,11 @@ __launch_bounds__(NMS<DType>::THRESHOLD) __global__
 #pragma unroll
   for (int i = 0; i < n_threads / warp_size; ++i) {
     uint32_t my_mask = my_next_mask;
+    // clang-format off
     my_next_mask     = (((i + 1) < n_threads / warp_size) && (my_element_in_batch < topk)) ?
                            nms_results[(i + 1) * topk * num_batches + my_element] :
                            full_mask;
+    // clang-format on
     if (my_warp == i && !__all_sync(full_mask, my_mask == full_mask)) {
       my_mask = my_mask | earlier_threads_mask;
       // Loop over warp_size - 1 because the last

src/operator/contrib/multi_lamb.cc

@@ -44,8 +44,10 @@ struct MultiLAMBKernelStep1 {
     using namespace mshadow_op;
     for (size_t index = 0; index < kernel_params.ntensors; ++index) {
       if ((size_t)i < kernel_params.sizes[index]) {
+        // clang-format off
         MPDType w           = has_mixed_precision ? kernel_params.weights32[index][i] :
                                                     MPDType(kernel_params.weights[index][i]);
+        // clang-format on
         MPDType scaled_grad = static_cast<MPDType>(kernel_params.grads[index][i]) * rescale_grad;
         if (clip_gradient >= 0.0f)
           scaled_grad = mshadow_op::clip::Map(scaled_grad, static_cast<MPDType>(clip_gradient));

src/operator/contrib/multi_lans.cc

@@ -45,8 +45,10 @@ struct MultiLANSKernelStep1 {
     using namespace mshadow_op;
     for (size_t index = 0; index < kernel_params.ntensors; ++index) {
       if ((size_t)i < kernel_params.sizes[index]) {
+        // clang-format off
         MPDType w           = has_mixed_precision ? kernel_params.weights32[index][i] :
                                                     MPDType(kernel_params.weights[index][i]);
+        // clang-format on
         float g_norm        = sqrt(g_sq_norm[index]);
         MPDType scaled_grad = static_cast<MPDType>(kernel_params.grads[index][i]) * rescale_grad;
         scaled_grad /= g_norm;
@@ -95,8 +97,10 @@ struct MultiLANSKernelStep2 {
                                   const OpReqType req) {
     for (size_t index = 0; index < kernel_params.ntensors; ++index) {
       if ((size_t)i < kernel_params.sizes[index]) {
+        // clang-format off
         MPDType w  = has_mixed_precision ? kernel_params.weights32[index][i] :
                                            MPDType(kernel_params.weights[index][i]);
+        // clang-format on
         float r1   = sqrt(sum_sq_weigths[index]);
         float r2_m = sqrt(sum_sq_temp_m[index]);
         float r2_g = sqrt(sum_sq_temp_g[index]);

src/operator/nn/batch_norm.cu

@@ -346,11 +346,13 @@ __global__ void BatchNormalizationUpdateOutputKernel(DeviceTensor input,
   }
 
   // Write normalized and update the output
+  // clang-format off
   const AccReal gamma = ((flags & FIX_GAMMA_FLAG) == 0 && weight.numElements() > 0) ?
                             ScalarConvert<DType, AccReal>::to(weight[plane]) :
                             ScalarConvert<int, AccReal>::to(1);
   const AccReal beta  = bias.numElements() > 0 ? ScalarConvert<DType, AccReal>::to(bias[plane]) :
                                                  ScalarConvert<int, AccReal>::to(0);
+  // clang-format on
   for (int batch = 0, nbatch = input.OuterSize(); batch < nbatch; ++batch) {
     for (int x = threadIdx.x, nx = input.InnerSize(); x < nx; x += blockDim.x) {
       const DType inp = input.get_ref(batch, plane, x);

src/operator/nn/dnnl/dnnl_base.cc

@@ -238,6 +238,7 @@ const dnnl::memory* GetWeights(const NDArray& arr, int num_groups) {
     H = 3;
     W = 4;
   }
+  // clang-format off
   if (ndim == 2) {
     tz         = dnnl::memory::dims{arr.shape()[O], arr.shape()[I]};
     format_tag = dnnl::memory::format_tag::oi;
@@ -271,6 +272,7 @@ const dnnl::memory* GetWeights(const NDArray& arr, int num_groups) {
   } else {
     LOG(FATAL) << "The weight array has an unsupported number of dimensions";
   }
+  // clang-format on
   const auto md = dnnl::memory::desc{tz, type, format_tag};
   return arr.GetDNNLData(md);
 }

src/operator/nn/dnnl/dnnl_rnn.cc

@@ -196,6 +196,7 @@ RnnPrimitive GetRnnFwdPrim(const DNNLRnnLayerParam& layer_param,
   auto src_state_desc    = memory::desc(layer_param.state_dims, data_type, tag::ldnc);
   auto src_cell_desc     = memory::desc(layer_param.cell_dims, data_type, tag::ldnc);
   auto weight_peep_desc  = memory::desc();
+  // clang-format off
   auto weight_proj_desc  = layer_param.proj_size > 0 ?
                                memory::desc(layer_param.weight_proj_dims, weight_type, tag::any) :
                                memory::desc();
@@ -205,6 +206,7 @@ RnnPrimitive GetRnnFwdPrim(const DNNLRnnLayerParam& layer_param,
   auto dst_cell_desc     = layer_param.state_outputs ?
                                memory::desc(layer_param.cell_dims, data_type, tag::ldnc) :
                                memory::desc();
+  // clang-format on
 
   auto fwd = RnnPrimitive();
   switch (mode) {
@@ -265,19 +267,23 @@ RnnBwdPrimitive GetRnnBwdPrim(const DNNLRnnForwardTraining& fwd,
   memory::data_type data_type          = get_dnnl_type(data.dtype());
   memory::data_type weight_type        = get_dnnl_type(params.dtype());
   const prop_kind prop                 = prop_kind::backward;
+  // clang-format off
   rnn_direction dnnl_rnn_direction     = layer_param.bidirectional ?
                                              rnn_direction::bidirectional_concat :
                                              rnn_direction::unidirectional;
+  // clang-format on
 
   auto src_layer_desc    = memory::desc(layer_param.src_dims, data_type, tag::tnc);
   auto weight_layer_desc = memory::desc(layer_param.weight_layer_dims, weight_type, tag::any);
   auto weight_iter_desc  = memory::desc(layer_param.weight_iter_dims, weight_type, tag::any);
   auto bias_desc         = memory::desc(layer_param.bias_dims, data_type, tag::ldgo);
   auto dst_layer_desc    = memory::desc(layer_param.dst_dims, data_type, tag::tnc);
   auto src_state_desc    = memory::desc(layer_param.state_dims, data_type, tag::ldnc);
+  // clang-format off
   auto dst_state_desc    = layer_param.state_outputs ?
                                memory::desc(layer_param.state_dims, data_type, tag::ldnc) :
                                memory::desc();
+  // clang-format on
 
   const void* fwd_pd = fwd.GetPrimDesc();
   auto bwd           = RnnBwdPrimitive();
@@ -1126,9 +1132,11 @@ void DNNLRnnOp::Forward(const OpContext& ctx,
   const int seq_length = default_param.seq_length_;
   const int batch_size = default_param.batch_size_;
   const int state_size = default_param.state_size;
+  // clang-format off
   const int iter_size  = default_param.projection_size.has_value() ?
                              default_param.projection_size.value() :
                              default_param.state_size;
+  // clang-format on
   const int directions = default_param.bidirectional ? 2 : 1;
   dnnl::memory::desc dst_desc({seq_length, batch_size, directions * iter_size},
                               get_dnnl_type(data_dtype),

src/operator/nn/softmax-inl.h

@@ -851,10 +851,12 @@ __global__ void masked_softmax_grad_kernel(OType* out,
 
   DType final_result;
   for (index_t i = x; i < M; i += x_size) {
+    // clang-format off
     bool mask_value = bcst_mask_axis ? in_mask[base_mask] : in_mask[base_mask + i * sa_mask];
     final_result    = negate ? -OP2::Map(ograd[base + i * sa], out[base + i * sa], ssum) :
                                OP2::Map(ograd[base + i * sa], out[base + i * sa], ssum);
     final_result    = mask_value ? final_result / static_cast<DType>(temperature) : DType(0.0f);
+    // clang-format on
     KERNEL_ASSIGN(igrad[base + i * sa], Req, final_result);
   }
 }