Addressing some linter errors (pytorch#158670)

Summary: Addressing the linter errors reported in the changed files.

Test Plan:
```
buck test mode/opt deeplearning/fbgemm:QuantUtilsTest
```
https://www.internalfb.com/intern/testinfra/testrun/11821949118528688

```
buck test mode/opt caffe2/torch/fb/model_transform/splitting/tests:split_dispatcher_test
```
https://www.internalfb.com/intern/testinfra/testrun/7881299627525465

Rollback Plan:

Differential Revision: D78352311

Pull Request resolved: pytorch#158670
Approved by: https://github.com/excelle08, https://github.com/cyyever, https://github.com/digantdesai

Author: sampathvic

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

@@ -83,10 +83,8 @@ void CopyICFirst3dTensorToChannelsLast3dTensor(
   for (int64_t i = 0; i < G * OC_G; ++i) {
     for (const auto j : c10::irange(inner_size)) {
       for (const auto ic : c10::irange(IC_G)) {
-        // NOLINTNEXTLINE(cppcoreguidelines-narrowing-conversions,bugprone-narrowing-conversions)
-        int g = i / OC_G;
-        // NOLINTNEXTLINE(cppcoreguidelines-narrowing-conversions,bugprone-narrowing-conversions)
-        int oc = i % OC_G;
+        int g = static_cast<int>(i / OC_G);
+        int oc = static_cast<int>(i % OC_G);
         dst[(i * inner_size + j) * IC_G + ic] =
             src[((g * IC_G + ic) * OC_G + oc) * inner_size + j];
       }
@@ -112,24 +110,26 @@ fbgemm::conv_param_t<kSpatialDim> MakeFbgemmConvParam(
   std::array<int, kSpatialDim> image_shape_{};
   std::array<int, kSpatialDim> kernels_{};
   std::array<int, kSpatialDim> strides_{};
-  std::array<int, kSpatialDim * 2> pads_{};
+  std::array<int, kSpatialDim * 2ull> pads_{};
   std::array<int, kSpatialDim> dilations_{};
   std::array<int, kSpatialDim> output_padding_{};
-  std::move(image_shape.begin(), image_shape.begin() + image_shape.size(), image_shape_.begin());
   std::move(
-      kernels.begin(), kernels.begin() + kernels.size(), kernels_.begin());
+      image_shape.begin(), image_shape.begin() + static_cast<int64_t>(image_shape.size()), image_shape_.begin());
   std::move(
-      strides.begin(), strides.begin() + strides.size(), strides_.begin());
+      kernels.begin(), kernels.begin() + static_cast<int64_t>(kernels.size()), kernels_.begin());
+  std::move(
+      strides.begin(), strides.begin() + static_cast<int64_t>(strides.size()), strides_.begin());
   std::move(
       dilations.begin(),
-      dilations.begin() + dilations.size(),
+      dilations.begin() + static_cast<int64_t>(dilations.size()),
       dilations_.begin());
   std::move(
       output_padding.begin(),
-      output_padding.begin() + output_padding.size(),
+      output_padding.begin() + static_cast<int64_t>(output_padding.size()),
       output_padding_.begin());
-  std::copy(pads.begin(), pads.begin() + pads.size(), pads_.begin());
-  std::move(pads.begin(), pads.begin() + pads.size(), pads_.begin() + pads.size());
+  std::copy(pads.begin(), pads.begin() + static_cast<int64_t>(pads.size()), pads_.begin());
+  const auto pads_size = static_cast<int64_t>(pads.size());
+  std::move(pads.begin(), pads.begin() + pads_size, pads_.begin() + pads_size);
 
   return fbgemm::conv_param_t<kSpatialDim>(
       N, // batch size
@@ -158,7 +158,7 @@ Tensor MakeStridedQTensorCPU(
   TORCH_CHECK(
       isQIntType(typeMetaToScalarType(dtype)),
       "ScalarType is not supported in new_qtensor_cpu.");
-  int64_t size_bytes = nelements * dtype.itemsize();
+  int64_t size_bytes = static_cast<int64_t>(nelements * dtype.itemsize());
   auto storage = c10::make_intrusive<StorageImpl>(
       StorageImpl::use_byte_size_t(),
       size_bytes,
@@ -531,8 +531,8 @@ int register_embedding_params() {
             TORCH_INTERNAL_ASSERT(longs.size() == 1, "EmbeddingPackedParams: Expected bit_rate to be serialized");
             TORCH_CHECK(version == 1, "EmbeddingPackedParams: Currently only version 1 supported.");
 
-            at::Tensor weight = std::move(tensors[0]);
-            return PackedEmbeddingBagWeight::prepack(std::move(weight));
+            const auto& weight = tensors[0];
+            return PackedEmbeddingBagWeight::prepack(weight);
           })
       .def("bit_rate", &EmbeddingPackedParamsBase::bit_rate)
       .def("unpack", &EmbeddingPackedParamsBase::unpack)

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

@@ -380,7 +380,7 @@ struct TORCH_API PackedEmbeddingBagWeight : public EmbeddingPackedParamsBase {
 
   at::Tensor unpack() override;
   static c10::intrusive_ptr<EmbeddingPackedParamsBase> prepack(
-      at::Tensor weight);
+      const at::Tensor& weight);
 
   int64_t bit_rate() const override {
     return bit_rate_;

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

@@ -33,7 +33,7 @@
  * for each row along with the quantized weights.
  */
 c10::intrusive_ptr<EmbeddingPackedParamsBase> PackedEmbeddingBagWeight::prepack(
-    at::Tensor qweight) {
+    const at::Tensor& qweight) {
   static constexpr int64_t version = 1;
   TORCH_CHECK(
       qweight.dim() == 2,
@@ -67,8 +67,8 @@ c10::intrusive_ptr<EmbeddingPackedParamsBase> PackedEmbeddingBagWeight::prepack(
       "Expect embedding_bag weights to be quantized using kPerChannelAffineFloatQParams");
   std::vector<float> weight_bias(embedding_rows);
 
-  at::Tensor channel_scales = qweight.q_per_channel_scales();
-  at::Tensor channel_zero_points = qweight.q_per_channel_zero_points();
+  const auto& channel_scales = qweight.q_per_channel_scales();
+  const auto& channel_zero_points = qweight.q_per_channel_zero_points();
   std::vector<float> weight_scales(
       channel_scales.data_ptr<float>(),
       channel_scales.data_ptr<float>() + embedding_rows);
@@ -77,6 +77,11 @@ c10::intrusive_ptr<EmbeddingPackedParamsBase> PackedEmbeddingBagWeight::prepack(
       channel_zero_points.data_ptr<float>() + embedding_rows);
 
   for (const auto i : c10::irange(embedding_rows)) {
+    // As of now weight_zero_points and weight_scales are initialized with
+    // the size of embedding_rows. Hence, this linter is a false positive.
+    // However, if this assumption changes in the future, we need to
+    // ensure that the bounds are checked.
+    // NOLINTNEXTLINE(facebook-hte-LocalUncheckedArrayBounds)
     weight_bias[i] = weight_zero_points[i] * weight_scales[i] * -1;
   }
 
@@ -237,16 +242,16 @@ Tensor& qembeddingbag_byte_prepack_out(Tensor& output, const Tensor& weight) {
 
   const auto weight_sizes = weight.sizes();
   const auto cols_dim = weight_sizes.size() - 1;
-  const int64_t embedding_rows = c10::size_to_dim_(cols_dim, weight_sizes);
-  const int32_t embedding_cols = weight_sizes[cols_dim];
+  const int64_t embedding_rows = c10::size_to_dim_(static_cast<int>(cols_dim), weight_sizes);
+  const int32_t embedding_cols = static_cast<int32_t>(weight_sizes[cols_dim]);
   // Add 8 bytes per column to store FP32 scale and zero_point per row.
-  const int32_t output_columns = embedding_cols + 2 * sizeof(float);
+  const int32_t output_columns = static_cast<int32_t>(embedding_cols + 2 * sizeof(float));
   const auto weight_contig =
       weight.expect_contiguous(weight.suggest_memory_format());
 
   // Adjust output dimensions to account for FP32 scale and zero_points.
   std::vector<int64_t> output_shape = weight_sizes.vec();
-  output_shape[cols_dim] = output_columns;
+  output_shape.at(cols_dim) = output_columns;
   at::native::resize_(output, output_shape, std::nullopt);
   auto* output_data = output.data_ptr<uint8_t>();
 
@@ -330,13 +335,13 @@ Tensor qembeddingbag_byte_prepack_meta(const Tensor& weight) {
       "'embedding_bag_byte_prepack' only support float32 or float16.");
   const auto weight_sizes = weight.sizes();
   const auto cols_dim = weight_sizes.size() - 1;
-  const int32_t embedding_cols = weight_sizes[cols_dim];
+  const int32_t embedding_cols = static_cast<int32_t>(weight_sizes[cols_dim]);
   // Add 8 bytes per column to store FP32 scale and zero_point per row.
-  const int32_t output_columns = embedding_cols + 2 * sizeof(float);
+  const int32_t output_columns = static_cast<int32_t>(embedding_cols + 2 * sizeof(float));
 
   // Adjust output dimensions to account for FP32 scale and zero_points.
   std::vector<int64_t> output_shape = weight_sizes.vec();
-  output_shape[cols_dim] = output_columns;
+  output_shape.at(cols_dim) = output_columns;
   at::SymDimVector output_shape_vec(output_shape);
 
   return at::empty_symint(
@@ -407,7 +412,7 @@ Tensor _qembeddingbag_nbit_prepack_helper(
                 bit_width,
                 weight_data + start_idx * embedding_cols,
                 end_idx - start_idx,
-                embedding_cols,
+                static_cast<int>(embedding_cols),
                 output_data + start_idx * output_shape[1]);
           });
     } else {
@@ -418,7 +423,7 @@ Tensor _qembeddingbag_nbit_prepack_helper(
                 bit_width,
                 weight_data + start_idx * embedding_cols,
                 end_idx - start_idx,
-                embedding_cols,
+                static_cast<int>(embedding_cols),
                 output_data + start_idx * output_shape[1]);
           });
     }
@@ -475,7 +480,7 @@ Tensor _qembeddingbag_nbit_prepack_helper(
         std::uint8_t quantized = std::max(
             0,
             std::min<int>(
-                lrintf((X - Xmin) * inverse_scale), (1 << bit_width) - 1));
+                static_cast<int>(lrintf((X - Xmin) * inverse_scale)), (1 << bit_width) - 1));
         // We pack 2 4-bit values in a byte. Index 0 is packed in the lower
         // 4-bits and index 1 is packed in the upper 4-bits.
         if (col % NUM_ELEM_PER_BYTE == 0) {
@@ -528,8 +533,8 @@ Tensor qembeddingbag_2bit_prepack(
 
 class QEmbeddingPackWeights final {
  public:
-  static c10::intrusive_ptr<EmbeddingPackedParamsBase> run(at::Tensor weight) {
-    return PackedEmbeddingBagWeight::prepack(std::move(weight));
+  static c10::intrusive_ptr<EmbeddingPackedParamsBase> run(const at::Tensor& weight) {
+    return PackedEmbeddingBagWeight::prepack(weight);
   }
 };