use irange for loops 2 (pytorch#66746)

Summary:
Pull Request resolved: pytorch#66746

Modified loops in files under fbsource/fbcode/caffe2/ from the format

`for(TYPE var=x0;var<x_max;x++)`

to the format

`for(const auto var: irange(xmax))`

This was achieved by running r-barnes's loop upgrader script (D28874212) with some modification to exclude all files under /torch/jit and a number of reversions or unused variable suppression warnings added by hand.

Test Plan: Sandcastle

Reviewed By: malfet

Differential Revision: D31705361

fbshipit-source-id: 33fd22eb03086d114e2c98e56703e8ec84460268

Author: r-barnes

aten/src/ATen/native/quantized/cpu/qlinear.cpp

@@ -303,7 +303,7 @@ at::Tensor PackedLinearWeightsQnnp::apply_impl(
         w_zero_points[0]);
     auto* qnnp_w_data = qnnp_weight.data_ptr<c10::quint8>();
     auto wt_numel = weight_contig.numel();
-    for (int i = 0; i < wt_numel; ++i) {
+    for (const auto i : c10::irange(wt_numel)) {
       qnnp_w_data[i] = static_cast<c10::quint8>(w_data[i] + 128);
     }
     // Original bias was float, so we requantize it here.

aten/src/ATen/native/quantized/cpu/qlinear_dynamic.cpp

@@ -301,7 +301,7 @@ at::Tensor PackedLinearWeightsQnnp::apply_dynamic_impl(
     auto* qnnp_w_data = qnnp_weight.data_ptr<c10::quint8>();
     int8_t* w_data = (int8_t*)weight_contig.data_ptr<c10::qint8>();
     auto wt_numel = weight_contig.numel();
-    for (int i = 0; i < wt_numel; ++i) {
+    for (const auto i : c10::irange(wt_numel)) {
       qnnp_w_data[i] = static_cast<c10::quint8>(w_data[i] + 128);
     }
 

aten/src/ATen/native/quantized/cpu/qpool.cpp

@@ -9,6 +9,7 @@
 #include <ATen/native/quantized/cpu/quantized_ops.h>
 #include <ATen/native/quantized/cpu/init_qnnpack.h>
 #include <ATen/native/quantized/cpu/qnnpack_utils.h>
+#include <c10/util/irange.h>
 #include <caffe2/utils/threadpool/pthreadpool-cpp.h>
 
 #include <algorithm>
@@ -43,7 +44,7 @@ void spatial_dilated_max_pooling(
     int64_t dW, // dilation
     T* oData) { // output arrays (data and max-index)
   at::parallel_for(0, iC, 0, [&](int64_t start, int64_t end) {
-    for (auto p = start; p < end; ++p) {
+    for (const auto p : c10::irange(start, end)) {
       // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
       int64_t row, col;
       const T* i_p = iData + p * iW * iH;
@@ -195,7 +196,7 @@ Tensor q_maxpool_2d(
           oData);
     } else {
       at::parallel_for(0, nbatch, 0, [&](int64_t start, int64_t end) {
-        for (auto p = start; p < end; ++p) {
+        for (const auto p : c10::irange(start, end)) {
           auto* iData = qxd + p * iC * iW * iH;
           auto* oData = qyd + p * oC * oW * oH;
           spatial_dilated_max_pooling<Q>(

aten/src/ATen/native/quantized/cpu/qrelu.cpp

@@ -6,6 +6,7 @@
 #include <ATen/native/quantized/cpu/init_qnnpack.h>
 #include <ATen/native/quantized/cpu/qnnpack_utils.h>
 #include <ATen/native/quantized/cpu/quantized_ops.h>
+#include <c10/util/irange.h>
 #include <caffe2/utils/threadpool/pthreadpool-cpp.h>
 #include <torch/library.h>
 
@@ -30,7 +31,7 @@ Tensor qnnpack_relu(Tensor input) {
   initQNNPACK();
 
   size_t num_elems = 1;
-  for (int i = 1; i < input_contig.ndimension(); ++i) {
+  for (const auto i : c10::irange(1, input_contig.ndimension())) {
     num_elems *= input_contig.size(i);
   }
 

aten/src/ATen/native/quantized/cpu/qsigmoid.cpp

@@ -7,6 +7,7 @@
 #include <ATen/native/quantized/cpu/quantized_ops.h>
 #include <ATen/native/quantized/cpu/init_qnnpack.h>
 #include <ATen/native/quantized/cpu/qnnpack_utils.h>
+#include <c10/util/irange.h>
 #include <caffe2/utils/threadpool/pthreadpool-cpp.h>
 
 #include <algorithm>
@@ -26,7 +27,7 @@ Tensor qnnpack_sigmoid(
 
   Tensor input_contig = input.contiguous(input.suggest_memory_format());
   size_t num_elems = 1;
-  for (int i = 1; i < input_contig.ndimension(); ++i) {
+  for (const auto i : c10::irange(1, input_contig.ndimension())) {
     num_elems *= input_contig.size(i);
   }
 

aten/src/ATen/native/quantized/cpu/qtanh.cpp

@@ -7,6 +7,7 @@
 #include <ATen/native/quantized/cpu/quantized_ops.h>
 #include <ATen/native/quantized/cpu/init_qnnpack.h>
 #include <ATen/native/quantized/cpu/qnnpack_utils.h>
+#include <c10/util/irange.h>
 #include <caffe2/utils/threadpool/pthreadpool-cpp.h>
 
 #include <algorithm>
@@ -29,7 +30,7 @@ Tensor qnnpack_tanh(Tensor input) {
 
   Tensor input_contig = input.contiguous(input.suggest_memory_format());
   size_t num_elems = 1;
-  for (int i = 1; i < input_contig.ndimension(); ++i) {
+  for (const auto i : c10::irange(1, input_contig.ndimension())) {
     num_elems *= input_contig.size(i);
   }
   const auto zero_point = input_contig.q_zero_point();

aten/src/ATen/native/quantized/cpu/quant_utils.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <ATen/ATen.h>
+#include <c10/util/irange.h>
 #include <algorithm>
 #include <cmath>
 
@@ -193,7 +194,7 @@ static C10_UNUSED torch::List<int64_t> MakeArgForConv1d(const torch::List<int64_
 inline void HandleWeightsSaturation(int64_t N, float* weight) {
   const float kFp16Max = RawUint16ToFp16(0x7BFF);
   bool found_out_of_range = false;
-  for (int64_t i = 0; i < N; ++i) {
+  for (const auto i : c10::irange(N)) {
     bool saturate = CheckAndSaturate<float>(kFp16Max, weight + i);
     if (saturate) {
       found_out_of_range = true;

aten/src/ATen/native/quantized/cpu/qupsample_bilinear2d.cpp

@@ -2,6 +2,7 @@
 #include <ATen/native/UpSample.h>
 #include <ATen/native/quantized/affine_quantizer.h>
 #include <ATen/native/quantized/cpu/quantized_ops.h>
+#include <c10/util/irange.h>
 
 #include <algorithm>
 #include <cmath>
@@ -57,7 +58,7 @@ static void upsample_bilinear2d_out_frame(
   const int64_t input_q_zero_point = input.q_zero_point();
   const int64_t output_q_zero_point = output.q_zero_point();
 
-  for (int64_t h2 = 0; h2 < output_height; ++h2) {
+  for (const auto h2 : c10::irange(output_height)) {
     const auto h1r = area_pixel_compute_source_index<float>(
         rheight, h2, align_corners, /*cubic=*/false);
 
@@ -67,7 +68,7 @@ static void upsample_bilinear2d_out_frame(
     const float h1lambda = h1r - h1;
     const float h0lambda = static_cast<float>(1.) - h1lambda;
 
-    for (int64_t w2 = 0; w2 < output_width; ++w2) {
+    for (const auto w2 : c10::irange(output_width)) {
       const auto w1r = area_pixel_compute_source_index<float>(
           rwidth, w2, align_corners, /*cubic=*/false);
 
@@ -79,7 +80,8 @@ static void upsample_bilinear2d_out_frame(
       const typename scalar_t::underlying* pos1 = i_p + h1 * input_width + w1;
       typename scalar_t::underlying* pos2 = o_p + h2 * output_width + w2;
 
-      for (int64_t c = 0; c < channels; ++c) {
+      for (const auto c : c10::irange(channels)) {
+        (void)c; //Suppress unused variable warning
         float result = h0lambda * (w0lambda * pos1[0] + w1lambda * pos1[w1p]) +
             h1lambda *
                 (w0lambda * pos1[h1p * input_width] +

aten/src/ATen/native/quantized/cpu/qupsample_nearest2d.cpp

@@ -44,18 +44,19 @@ static void upsample_nearest2d_out_frame(
     return;
   }
 
-  for (int64_t h2 = 0; h2 < output_height; ++h2) {
+  for (const auto h2 : c10::irange(output_height)) {
     const int64_t h1 =
         nn_compute_source_index_fn(height_scale, h2, input_height);
 
-    for (int64_t w2 = 0; w2 < output_width; ++w2) {
+    for (const auto w2 : c10::irange(output_width)) {
       const int64_t w1 =
           nn_compute_source_index_fn(width_scale, w2, input_width);
 
       const auto* pos1 = &i_p[h1 * input_width + w1];
       auto* pos2 = &o_p[h2 * output_width + w2];
 
-      for (int64_t c = 0; c < channels; ++c) {
+      for (const auto c : c10::irange(channels)) {
+        (void)c; //Suppress unused variable warning
         pos2[0] = pos1[0];
         pos1 += input_height * input_width;
         pos2 += output_height * output_width;
@@ -88,11 +89,11 @@ static void upsample_nearest2d_out_frame_nhwc(
       return;
     }
 
-    for (int64_t h2 = 0; h2 < output_height; ++h2) {
+    for (const auto h2 : c10::irange(output_height)) {
       const int64_t h1 =
           nn_compute_source_index_fn(height_scale, h2, input_height);
 
-      for (int64_t w2 = 0; w2 < output_width; ++w2) {
+      for (const auto w2 : c10::irange(output_width)) {
         const int64_t w1 =
             nn_compute_source_index_fn(width_scale, w2, input_width);
 

aten/src/ATen/native/quantized/cpu/qupsample_nearest3d.cpp

@@ -48,22 +48,23 @@ static void upsample_nearest3d_out_frame(
     return;
   }
 
-  for (int64_t d2 = 0; d2 < output_depth; ++d2) {
+  for (const auto d2 : c10::irange(output_depth)) {
     const int64_t d1 =
           nn_compute_source_index_fn(depth_scale, d2, input_depth);
 
-    for (int64_t h2 = 0; h2 < output_height; ++h2) {
+    for (const auto h2 : c10::irange(output_height)) {
       const int64_t h1 =
           nn_compute_source_index_fn(height_scale, h2, input_height);
 
-      for (int64_t w2 = 0; w2 < output_width; ++w2) {
+      for (const auto w2 : c10::irange(output_width)) {
         const int64_t w1 =
             nn_compute_source_index_fn(width_scale, w2, input_width);
 
         const auto* pos1 = &i_p[d1 * input_height * input_width + h1 * input_width + w1];
         auto* pos2 = &o_p[d2 * output_height * output_width + h2 * output_width + w2];
 
-        for (int64_t c = 0; c < channels; ++c) {
+        for (const auto c : c10::irange(channels)) {
+          (void)c; //Suppress unused variable warning
           pos2[0] = pos1[0];
           pos1 += input_depth * input_height * input_width;
           pos2 += output_depth * output_height * output_width;
@@ -101,14 +102,14 @@ static void upsample_nearest3d_out_frame_nhwc(
       return;
     }
 
-    for (int64_t d2 = 0; d2 < output_depth; ++d2) {
+    for (const auto d2 : c10::irange(output_depth)) {
       const int64_t d1 =
           nn_compute_source_index_fn(depth_scale, d2, input_depth);
-      for (int64_t h2 = 0; h2 < output_height; ++h2) {
+      for (const auto h2 : c10::irange(output_height)) {
         const int64_t h1 =
             nn_compute_source_index_fn(height_scale, h2, input_height);
 
-        for (int64_t w2 = 0; w2 < output_width; ++w2) {
+        for (const auto w2 : c10::irange(output_width)) {
           const int64_t w1 =
               nn_compute_source_index_fn(width_scale, w2, input_width);
 

aten/src/ATen/native/quantized/fake_quant_per_channel_affine.cpp

@@ -218,7 +218,7 @@ std::tuple<Tensor, Tensor, Tensor> _fake_quantize_learnable_per_channel_affine_b
   // into the same shapes as X along the channel axis.
   // NOLINTNEXTLINE(cppcoreguidelines-no-malloc)
   int64_t* axis_mask = (int64_t *) calloc(numDimensions, sizeof(int64_t));
-  for (int i = 0; i < numDimensions; ++i) {
+  for (const auto i : c10::irange(numDimensions)) {
     axis_mask[i] = (i == axis) ? X.size(axis) : 1;
   }
   auto X_shape = X.sizes();

aten/src/ATen/native/sparse/SoftMax.cpp

@@ -7,6 +7,7 @@
 #include <ATen/Parallel.h>
 #include <ATen/SparseTensorUtils.h>
 #include <c10/util/accumulate.h>
+#include <c10/util/irange.h>
 
 #include <map>
 
@@ -71,9 +72,9 @@ std::vector<int64_t> get_offsets(const Tensor& indices, const IntArrayRef& sizes
     }
   }
 
-  for (int64_t i=0; i < nnz; i++) {
+  for (const auto i : c10::irange(nnz)) {
     int64_t acc = 0;
-    for (int64_t j=0; j < ndim; j++) {
+    for (const auto j : c10::irange(ndim)) {
       auto indices_row = indices_accessor[j];
       auto stride = strides[j];
       if (j != dim) {
@@ -119,9 +120,9 @@ std::vector<std::vector<int64_t>> get_pools(const Tensor& indices, const IntArra
     }
   }
 
-  for (int64_t i=0; i < nnz; i++) {
+  for (const auto i : c10::irange(nnz)) {
     int64_t pool_index = 0;
-    for (int64_t j=0; j < ndim; j++) {
+    for (const auto j : c10::irange(ndim)) {
       if (j != dim) {
         const auto indices_row = indices_accessor[j];
         const auto stride = strides[j];
@@ -315,7 +316,7 @@ void cpu_sparse_coo_softmax(Tensor output, const Tensor& input, const int64_t di
 
   int64_t grain_size = 1;
   parallel_for(0, pools.size(), grain_size, [&](int64_t begin, int64_t end) {
-      for (auto p = begin; p < end; p++) {
+      for (const auto p : c10::irange(begin, end)) {
         auto pool_indices = pools[p];
 
         // Skip empty pools
@@ -329,7 +330,7 @@ void cpu_sparse_coo_softmax(Tensor output, const Tensor& input, const int64_t di
         /* Compute mx */
         for (int64_t i : pool_indices) {
           auto values_row = values_accessor[i];
-          for (int64_t j=0; j < nvalues; j++) {
+          for (const auto j : c10::irange(nvalues)) {
             mx_row[j] = std::max(mx_row[j], values_row[j]);
           }
         }
@@ -338,7 +339,7 @@ void cpu_sparse_coo_softmax(Tensor output, const Tensor& input, const int64_t di
         for (int64_t i : pool_indices) {
           auto values_row = values_accessor[i];
           auto out_values_row = out_values_accessor[i];
-          for (int64_t j=0; j < nvalues; j++) {
+          for (const auto j : c10::irange(nvalues)) {
             auto v = std::exp(values_row[j] - mx_row[j]);
             if (!LogSoftMax) {
               out_values_row[j] = v;
@@ -347,7 +348,7 @@ void cpu_sparse_coo_softmax(Tensor output, const Tensor& input, const int64_t di
           }
         }
 
-        for (int64_t j=0; j < nvalues; j++) {
+        for (const auto j : c10::irange(nvalues)) {
           if (LogSoftMax) {
             mx_row[j] += std::log(exp_sums_row[j]);
           } else {
@@ -359,7 +360,7 @@ void cpu_sparse_coo_softmax(Tensor output, const Tensor& input, const int64_t di
         for (int64_t i : pool_indices) {
           auto values_row = values_accessor[i];
           auto out_values_row = out_values_accessor[i];
-          for (int64_t j=0; j < nvalues; j++) {
+          for (const auto j : c10::irange(nvalues)) {
             if (LogSoftMax) {
               out_values_row[j] = values_row[j] - mx_row[j];
             } else {
@@ -421,7 +422,7 @@ void cpu_sparse_coo_softmax_backward(const Tensor& grad_input, const Tensor& gra
         values.set_(r);
       }
     } else {
-      for(int64_t i=0; i<out_nnz; i++) {
+      for (const auto i : c10::irange(out_nnz)) {
         auto low = std::lower_bound(grad_offsets.begin(), grad_offsets.end(), out_offsets[i]);
         auto j = low - grad_offsets.begin();
         if (j < grad_nnz && out_offsets[i] == grad_offsets[j]) {
@@ -456,7 +457,7 @@ void cpu_sparse_coo_softmax_backward(const Tensor& grad_input, const Tensor& gra
 
   int64_t grain_size = 1;
   parallel_for(0, pools.size(), grain_size, [&](int64_t begin, int64_t end) {
-      for (auto p = begin; p < end; p++) {
+      for (const auto p : c10::irange(begin, end)) {
         auto pool_indices = pools[p];
 
         // Skip empty pools
@@ -473,7 +474,7 @@ void cpu_sparse_coo_softmax_backward(const Tensor& grad_input, const Tensor& gra
 
           if (j < grad_nnz && (out_offsets[i] == grad_offsets[j])) {
             auto grad_values_row = grad_values_accessor[j];
-            for (int64_t k=0; k<nvalues; k++) {
+            for (const auto k : c10::irange(nvalues)) {
               if (LogSoftMax) {
                 tmp_row[k] -= grad_values_row[k];
               } else {
@@ -492,15 +493,15 @@ void cpu_sparse_coo_softmax_backward(const Tensor& grad_input, const Tensor& gra
 
           if (j < grad_nnz && (out_offsets[i] == grad_offsets[j])) {
             auto grad_values_row = grad_values_accessor[j];
-            for (int64_t k=0; k<nvalues; k++) {
+            for (const auto k : c10::irange(nvalues)) {
               if (LogSoftMax) {
                 values_row[k] = grad_values_row[k] + std::exp(out_values_row[k]) * tmp_row[k];
               } else {
                 values_row[k] = out_values_row[k] * (grad_values_row[k] + tmp_row[k]);
               }
             }
           } else {
-            for (int64_t k=0; k<nvalues; k++) {
+            for (const auto k : c10::irange(nvalues)) {
               if (LogSoftMax) {
                 values_row[k] = std::exp(out_values_row[k]) * tmp_row[k];
               } else {

aten/src/ATen/native/sparse/SparseCsrTensorMath.cpp

@@ -13,6 +13,7 @@
 #include <ATen/native/Resize.h>
 #include <ATen/native/mkl/SparseBlasImpl.h>
 #include <ATen/native/sparse/SparseBlasImpl.h>
+#include <c10/util/irange.h>
 
 #include <algorithm>
 
@@ -60,7 +61,7 @@ void convert_indices_from_coo_to_csr_cpu(const Tensor& result, const Tensor& inp
 
   at::parallel_for(0, numel - 1, GRAIN_SIZE, [&](int64_t start, int64_t end) {
     input_t curr_value = data_in[start], next_value;
-    for (int64_t i = start; i < end; i++) {
+    for (const auto i : c10::irange(start, end)) {
       next_value = data_in[i + 1];
       for (; curr_value < next_value; curr_value++)
         data_out[curr_value + 1] = static_cast<output_t>(i + 1);