Explicitly put size_t in std since newer gcc/clang require that

Author: XapaJIaMnu

src/wasm-ops/batch-normalization.cpp

@@ -22,8 +22,8 @@ void batch_normalization_f32_imp(float *X, float *Y, int32_t batch_size,
                                  int32_t num_channels, int32_t channel_size,
                                  float *scale, float *bias, float *mean,
                                  float *variance, float epsilon) {
-  for (size_t nc = 0; nc < batch_size * num_channels; ++nc) {
-    for (size_t i = 0; i < channel_size; ++i) {
+  for (std::size_t nc = 0; nc < batch_size * num_channels; ++nc) {
+    for (std::size_t i = 0; i < channel_size; ++i) {
       Y[nc * channel_size + i] =
           scale[nc % num_channels] *
               ((X[nc * channel_size + i] - mean[nc % num_channels]) /

src/wasm-ops/binary-op.h

@@ -74,7 +74,7 @@ void binary_imp(void *data, const T *input_1, const T *input_2, T *output) {
   std::vector<int32_t> broadcasted_indices(output_strides.size());
 
   // core functionality (with broadcasting)
-  for (size_t i = 0; i < output_length; ++i) {
+  for (std::size_t i = 0; i < output_length; ++i) {
     ShapeUtils::offset_to_indices(output_strides, i, broadcasted_indices);
     BroadcastUtils::broadcasted_to_original_indices(broadcasted_indices,
                                                     dims1_vector, indices_1);

src/wasm-ops/clip.h

@@ -14,7 +14,7 @@ void clip_f32(void *);
 template <typename T>
 void clip_imp(const T *input, T *output, const int32_t length, const float min,
               const float max) {
-  for (size_t i = 0; i < length; ++i) {
+  for (std::size_t i = 0; i < length; ++i) {
     const auto &val = input[i];
     output[i] = (val < min) ? min : (val > max) ? max : val;
   }

src/wasm-ops/common.h

@@ -10,10 +10,10 @@ static_assert(sizeof(int) == sizeof(int32_t),
               "'int' and 'int32_t' should be the same type");
 
 #define PARAM_VALUE(data, offset, type)                                        \
-  (*((type *)((((uint8_t *)(data)) + ((size_t)(offset))))))
+  (*((type *)((((uint8_t *)(data)) + ((std::size_t)(offset))))))
 #define PARAM_PTR(data, offset, type)                                          \
   ((type *)((offset == 0) ? nullptr                                            \
-                          : (((uint8_t *)(data)) + ((size_t)(offset)))))
+                          : (((uint8_t *)(data)) + ((std::size_t)(offset)))))
 
 #define PARAM_BOOL(data, offset) (!!PARAM_VALUE(data, offset, uint8_t))
 #define PARAM_INT32(data, offset) PARAM_VALUE(data, offset, int32_t)

src/wasm-ops/instance-normalization.cpp

@@ -23,31 +23,31 @@ void instance_normalization_f32_imp(float *X, float *Y, int32_t batch_size,
   float temp;
   float mean;
   float variance;
-  size_t physicalOffset;
-  size_t iterEnd;
-  size_t currentChannel;
+  std::size_t physicalOffset;
+  std::size_t iterEnd;
+  std::size_t currentChannel;
 
-  for (size_t nc = 0; nc < batch_size * num_channels; nc++) {
+  for (std::size_t nc = 0; nc < batch_size * num_channels; nc++) {
     physicalOffset = nc * channel_size;
     iterEnd = physicalOffset + channel_size;
     currentChannel = nc % num_channels;
 
     // compute mean for this channel
     temp = 0;
-    for (size_t i = physicalOffset; i < iterEnd; ++i) {
+    for (std::size_t i = physicalOffset; i < iterEnd; ++i) {
       temp += X[i];
     }
     mean = temp / channel_size;
 
     // compute variance for this channel
     temp = 0;
-    for (size_t i = physicalOffset; i < iterEnd; ++i) {
+    for (std::size_t i = physicalOffset; i < iterEnd; ++i) {
       temp += pow(X[i] - mean, 2);
     }
     variance = temp / channel_size;
 
     // compute normalized value for data in this channel
-    for (size_t i = physicalOffset; i < iterEnd; ++i) {
+    for (std::size_t i = physicalOffset; i < iterEnd; ++i) {
       Y[i] =
           scale[currentChannel] * ((X[i] - mean) / sqrt(variance + epsilon)) +
           bias[currentChannel];

src/wasm-ops/softmax.cpp

@@ -16,26 +16,26 @@ void softmax_f32(void *data) {
 
 // Core operator implementation
 void softmax_f32_imp(float *X, float *Y, int32_t N, int32_t D) {
-  for (size_t i = 0; i < N; i++) {
+  for (std::size_t i = 0; i < N; i++) {
     // find row offset
     int offset = i * D;
 
     // find max of each logical row
     float max = std::numeric_limits<float>::lowest();
-    for (size_t j = 0; j < D; j++) {
+    for (std::size_t j = 0; j < D; j++) {
       if (X[offset + j] > max)
         max = X[offset + j];
     }
 
     // find normalization scale per row
     float scale = 0;
-    for (size_t j = 0; j < D; j++) {
+    for (std::size_t j = 0; j < D; j++) {
       Y[offset + j] = exp(X[offset + j] - max);
       scale += Y[offset + j];
     }
 
     // perform the softmax normalization
-    for (size_t j = 0; j < D; j++) {
+    for (std::size_t j = 0; j < D; j++) {
       // If scale is 0, then all elements in that row are 0, so no normalization
       // operation required
       if (scale != 0)

src/wasm-ops/sum.cpp

@@ -15,8 +15,8 @@ void sum_f32(void *data) {
 
 // Core operator implementation
 void sum_f32_imp(int num_tensors, int size, float *Y, float *X) {
-  for (size_t i = 0; i < num_tensors; ++i) {
-    for (size_t j = 0; j < size; ++j)
+  for (std::size_t i = 0; i < num_tensors; ++i) {
+    for (std::size_t j = 0; j < size; ++j)
       Y[j] += X[i * size + j];
   }
 }

src/wasm-ops/utils/broadcast_utils.cpp

@@ -24,7 +24,7 @@ void BroadcastUtils::broadcasted_to_original_indices(
     return;
   }
   auto offset = broadcasted_indices.size() - dims.size();
-  for (size_t i = 0; i < rank; ++i) {
+  for (std::size_t i = 0; i < rank; ++i) {
     original_indices[i] = broadcasted_indices[offset + i] % dims[i];
   }
 }

src/wasm-ops/utils/shape_utils.cpp

@@ -4,15 +4,15 @@
 #include "shape_utils.h"
 #include <math.h>
 
-size_t ShapeUtils::size_from_dims(const std::vector<int32_t> &dims) {
+std::size_t ShapeUtils::size_from_dims(const std::vector<int32_t> &dims) {
   auto rank = dims.size();
   if (rank == 0) {
     return 1;
   }
   if (rank == 1) {
     return dims[0];
   }
-  size_t size = 1;
+  std::size_t size = 1;
   for (auto &e : dims) {
     size *= e;
   }
@@ -45,18 +45,18 @@ void ShapeUtils::compute_strides(const std::vector<int32_t> &dims,
   }
 }
 
-size_t ShapeUtils::indices_to_offset(const std::vector<int32_t> &strides,
+std::size_t ShapeUtils::indices_to_offset(const std::vector<int32_t> &strides,
                                      const std::vector<int32_t> &indices) {
-  size_t offset = 0;
-  for (size_t i = 0; i < indices.size(); ++i) {
+  std::size_t offset = 0;
+  for (std::size_t i = 0; i < indices.size(); ++i) {
     offset += strides[i] * indices[i];
   }
   return offset;
 }
 
 std::vector<int32_t>
 ShapeUtils::offset_to_indices(const std::vector<int32_t> &strides,
-                              size_t offset) {
+                              std::size_t offset) {
   auto rank = strides.size();
   if (rank == 0) {
     return std::vector<int32_t>();
@@ -70,7 +70,7 @@ ShapeUtils::offset_to_indices(const std::vector<int32_t> &strides,
 }
 
 void ShapeUtils::offset_to_indices(const std::vector<int32_t> &strides,
-                                   size_t offset,
+                                   std::size_t offset,
                                    std::vector<int32_t> &indices) {
   auto rank = strides.size();
   if (rank == 0) {
@@ -80,7 +80,7 @@ void ShapeUtils::offset_to_indices(const std::vector<int32_t> &strides,
     indices[0] = offset * strides[0];
     return;
   }
-  for (size_t i = 0; i < indices.size() - 1; ++i) {
+  for (std::size_t i = 0; i < indices.size() - 1; ++i) {
     indices[i] = floor(offset / strides[i]);
     offset -= indices[i] * strides[i];
   }

src/wasm-ops/utils/shape_utils.h

@@ -7,16 +7,16 @@
 #include <stdint.h>
 
 namespace ShapeUtils {
-size_t size_from_dims(const std::vector<int32_t> &dims);
+std::size_t size_from_dims(const std::vector<int32_t> &dims);
 std::vector<int32_t> compute_strides(const std::vector<int32_t> &dims);
 // Fills in values in the strides vector. Assumes it is of the required size.
 void compute_strides(const std::vector<int32_t> &dims,
                      std::vector<int32_t> &strides);
-size_t indices_to_offset(const std::vector<int32_t> &strides,
+std::size_t indices_to_offset(const std::vector<int32_t> &strides,
                          const std::vector<int32_t> &indices);
 std::vector<int32_t> offset_to_indices(const std::vector<int32_t> &strides,
-                                       size_t offset);
+                                       std::size_t offset);
 // Fills in values in the indices vector. Assumes it is of the required size.
-void offset_to_indices(const std::vector<int32_t> &strides, size_t offset,
+void offset_to_indices(const std::vector<int32_t> &strides, std::size_t offset,
                        std::vector<int32_t> &indices);
 }; // namespace ShapeUtils