Fix warnings on Visual Studio (#1422)

* Change DataReader::read()'s signature to fix warning C4267

This CL fixes lots of warning "C4267: 'initializing': conversion from
'size_t' to 'int'" in our codebase by matching DataReader::read()'s
signature to fread().

* Fix warnings C4244 and C4267 in tools/ncnnoptimize.cpp

C4244: 'initializing': conversion from 'double' to 'float',
    possible loss of data
C4267: 'initializing': conversion from 'size_t' to 'int',
    possible loss of data

* Fix warning C4244 in src\layer\selu.cpp

C4244: '=': conversion from 'double' to 'float', possible loss of data

* Fix warning C4244 in src\layer\cast.cpp

C4244: '=': conversion from 'double' to 'float', possible loss of data
C4244: 'return': conversion from 'float' to 'signed char', possible loss of data

* Fix warning C4244 in src\layer\psroipooling.cpp

C4244: 'initializing': conversion from 'double' to 'float',
    possible loss of data
C4244: 'initializing': conversion from 'double' to 'int',
    possible loss of data

benchmark/benchncnn.cpp

@@ -45,7 +45,7 @@ class DataReaderFromEmpty : public ncnn::DataReader
 {
 public:
     virtual int scan(const char* format, void* p) const { return 0; }
-    virtual int read(void* buf, int size) const { memset(buf, 0, size); return size; }
+    virtual size_t read(void* buf, size_t size) const { memset(buf, 0, size); return size; }
 };
 
 static int g_warmup_loop_count = 8;

src/datareader.cpp

@@ -28,7 +28,7 @@ int DataReader::scan(const char* /*format*/, void* /*p*/) const
 }
 #endif // NCNN_STRING
 
-int DataReader::read(void* /*buf*/, int /*size*/) const
+size_t DataReader::read(void* /*buf*/, size_t /*size*/) const
 {
     return 0;
 }
@@ -45,7 +45,7 @@ int DataReaderFromStdio::scan(const char* format, void* p) const
 }
 #endif // NCNN_STRING
 
-int DataReaderFromStdio::read(void* buf, int size) const
+size_t DataReaderFromStdio::read(void* buf, size_t size) const
 {
     return fread(buf, 1, size, fp);
 }
@@ -58,7 +58,7 @@ DataReaderFromMemory::DataReaderFromMemory(const unsigned char*& _mem) : mem(_me
 #if NCNN_STRING
 int DataReaderFromMemory::scan(const char* format, void* p) const
 {
-    int fmtlen = strlen(format);
+    size_t fmtlen = strlen(format);
 
     char* format_with_n = new char[fmtlen + 3];
     sprintf(format_with_n, "%s%%n", format);
@@ -73,7 +73,7 @@ int DataReaderFromMemory::scan(const char* format, void* p) const
 }
 #endif // NCNN_STRING
 
-int DataReaderFromMemory::read(void* buf, int size) const
+size_t DataReaderFromMemory::read(void* buf, size_t size) const
 {
     memcpy(buf, mem, size);
     mem += size;
@@ -115,9 +115,11 @@ int DataReaderFromAndroidAsset::scan(const char* format, void* p) const
 }
 #endif // NCNN_STRING
 
-int DataReaderFromAndroidAsset::read(void* buf, int size) const
+size_t DataReaderFromAndroidAsset::read(void* buf, size_t size) const
 {
     int nread = AAsset_read(asset, buf, size);
+    if (nread < 0)
+        return 0;
 
     if (mem)
     {

src/datareader.h

@@ -38,7 +38,7 @@ public:
 
     // read binary param and model data
     // return bytes read
-    virtual int read(void* buf, int size) const;
+    virtual size_t read(void* buf, size_t size) const;
 };
 
 #if NCNN_STDIO
@@ -50,7 +50,7 @@ public:
 #if NCNN_STRING
     virtual int scan(const char* format, void* p) const;
 #endif // NCNN_STRING
-    virtual int read(void* buf, int size) const;
+    virtual size_t read(void* buf, size_t size) const;
 
 protected:
     FILE* fp;
@@ -65,7 +65,7 @@ public:
 #if NCNN_STRING
     virtual int scan(const char* format, void* p) const;
 #endif // NCNN_STRING
-    virtual int read(void* buf, int size) const;
+    virtual size_t read(void* buf, size_t size) const;
 
 protected:
     const unsigned char*& mem;
@@ -80,7 +80,7 @@ public:
 #if NCNN_STRING
     virtual int scan(const char* format, void* p) const;
 #endif // NCNN_STRING
-    virtual int read(void* buf, int size) const;
+    virtual size_t read(void* buf, size_t size) const;
 
 protected:
     AAsset* asset;

src/layer/cast.cpp

@@ -153,15 +153,15 @@ static float float16_to_float32(unsigned short value)
 static signed char float32_to_int8(float value)
 {
     float tmp;
-    if (value >= 0.f) tmp = value + 0.5;
-    else tmp = value - 0.5;
+    if (value >= 0.f) tmp = value + 0.5f;
+    else tmp = value - 0.5f;
 
     if (tmp > 127)
         return 127;
     if (tmp < -128)
         return -128;
 
-    return tmp;
+    return static_cast<signed char>(tmp);
 }
 
 int Cast::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const

src/layer/psroipooling.cpp

@@ -60,10 +60,10 @@ int PSROIPooling::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>
     // For each ROI R = [x y w h]: avg pool over R
     const float* roi_ptr = roi_blob;
 
-    float roi_x1 = round(roi_ptr[0]) * spatial_scale;
-    float roi_y1 = round(roi_ptr[1]) * spatial_scale;
-    float roi_x2 = round(roi_ptr[2] + 1.f) * spatial_scale;
-    float roi_y2 = round(roi_ptr[3] + 1.f) * spatial_scale;
+    float roi_x1 = static_cast<float>(round(roi_ptr[0]) * spatial_scale);
+    float roi_y1 = static_cast<float>(round(roi_ptr[1]) * spatial_scale);
+    float roi_x2 = static_cast<float>(round(roi_ptr[2] + 1.f) * spatial_scale);
+    float roi_y2 = static_cast<float>(round(roi_ptr[3] + 1.f) * spatial_scale);
 
     float roi_w = std::max(roi_x2 - roi_x1, 0.1f);
     float roi_h = std::max(roi_y2 - roi_y1, 0.1f);
@@ -82,10 +82,10 @@ int PSROIPooling::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>
             {
                 const float* ptr = bottom_blob.channel((q * pooled_height + ph) * pooled_width + pw);
 
-                int hstart = floor(roi_y1 + (float)(ph) * bin_size_h);
-                int wstart = floor(roi_x1 + (float)(pw) * bin_size_w);
-                int hend = ceil(roi_y1 + (float)(ph + 1) * bin_size_h);
-                int wend = ceil(roi_x1 + (float)(pw + 1) * bin_size_w);
+                int hstart = static_cast<int>(floor(roi_y1 + (float)(ph) * bin_size_h));
+                int wstart = static_cast<int>(floor(roi_x1 + (float)(pw) * bin_size_w));
+                int hend = static_cast<int>(ceil(roi_y1 + (float)(ph + 1) * bin_size_h));
+                int wend = static_cast<int>(ceil(roi_x1 + (float)(pw + 1) * bin_size_w));
 
                 hstart = std::min(std::max(hstart, 0), h);
                 wstart = std::min(std::max(wstart, 0), w);

src/layer/selu.cpp

@@ -49,7 +49,7 @@ int SELU::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
         for (int i=0; i<size; i++)
         {
             if (ptr[i] < 0.f)
-                ptr[i] = (exp(ptr[i]) - 1.f) * alphaxlambda;
+                ptr[i] = static_cast<float>((exp(ptr[i]) - 1.f) * alphaxlambda);
             else
                 ptr[i] *= lambda;
         }

src/modelbin.cpp

@@ -51,7 +51,7 @@ Mat ModelBinFromDataReader::load(int w, int type) const
 {
     if (type == 0)
     {
-        int nread;
+        size_t nread;
 
         union
         {
@@ -66,9 +66,9 @@ Mat ModelBinFromDataReader::load(int w, int type) const
         } flag_struct;
 
         nread = dr.read(&flag_struct, sizeof(flag_struct));
-        if (nread != (int)sizeof(flag_struct))
+        if (nread != sizeof(flag_struct))
         {
-            fprintf(stderr, "ModelBin read flag_struct failed %d\n", nread);
+            fprintf(stderr, "ModelBin read flag_struct failed %zd\n", nread);
             return Mat();
         }
 
@@ -83,7 +83,7 @@ Mat ModelBinFromDataReader::load(int w, int type) const
             nread = dr.read(float16_weights.data(), align_data_size);
             if (nread != align_data_size)
             {
-                fprintf(stderr, "ModelBin read float16_weights failed %d\n", nread);
+                fprintf(stderr, "ModelBin read float16_weights failed %zd\n", nread);
                 return Mat();
             }
 
@@ -98,7 +98,7 @@ Mat ModelBinFromDataReader::load(int w, int type) const
             nread = dr.read(int8_weights.data(), align_data_size);
             if (nread != align_data_size)
             {
-                fprintf(stderr, "ModelBin read int8_weights failed %d\n", nread);
+                fprintf(stderr, "ModelBin read int8_weights failed %zd\n", nread);
                 return Mat();
             }
 
@@ -118,9 +118,9 @@ Mat ModelBinFromDataReader::load(int w, int type) const
 
             // raw data with extra scaling
             nread = dr.read(m, w * sizeof(float));
-            if (nread != w * (int)sizeof(float))
+            if (nread != w * sizeof(float))
             {
-                fprintf(stderr, "ModelBin read weight_data failed %d\n", nread);
+                fprintf(stderr, "ModelBin read weight_data failed %zd\n", nread);
                 return Mat();
             }
 
@@ -136,9 +136,9 @@ Mat ModelBinFromDataReader::load(int w, int type) const
             // quantized data
             float quantization_value[256];
             nread = dr.read(quantization_value, 256 * sizeof(float));
-            if (nread != 256 * (int)sizeof(float))
+            if (nread != 256 * sizeof(float))
             {
-                fprintf(stderr, "ModelBin read quantization_value failed %d\n", nread);
+                fprintf(stderr, "ModelBin read quantization_value failed %zd\n", nread);
                 return Mat();
             }
 
@@ -148,7 +148,7 @@ Mat ModelBinFromDataReader::load(int w, int type) const
             nread = dr.read(index_array.data(), align_weight_data_size);
             if (nread != align_weight_data_size)
             {
-                fprintf(stderr, "ModelBin read index_array failed %d\n", nread);
+                fprintf(stderr, "ModelBin read index_array failed %zd\n", nread);
                 return Mat();
             }
 
@@ -162,9 +162,9 @@ Mat ModelBinFromDataReader::load(int w, int type) const
         {
             // raw data
             nread = dr.read(m, w * sizeof(float));
-            if (nread != w * (int)sizeof(float))
+            if (nread != w * sizeof(float))
             {
-                fprintf(stderr, "ModelBin read weight_data failed %d\n", nread);
+                fprintf(stderr, "ModelBin read weight_data failed %zd\n", nread);
                 return Mat();
             }
         }
@@ -178,10 +178,10 @@ Mat ModelBinFromDataReader::load(int w, int type) const
             return m;
 
         // raw data
-        int nread = dr.read(m, w * sizeof(float));
-        if (nread != w * (int)sizeof(float))
+        size_t nread = dr.read(m, w * sizeof(float));
+        if (nread != w * sizeof(float))
         {
-            fprintf(stderr, "ModelBin read weight_data failed %d\n", nread);
+            fprintf(stderr, "ModelBin read weight_data failed %zd\n", nread);
             return Mat();
         }
 

src/paramdict.cpp

@@ -190,11 +190,11 @@ int ParamDict::load_param_bin(const DataReader& dr)
 //     binary -233(EOP)
 
     int id = 0;
-    int nread;
+    size_t nread;
     nread = dr.read(&id, sizeof(int));
-    if (nread != (int)sizeof(int))
+    if (nread != sizeof(int))
     {
-        fprintf(stderr, "ParamDict read id failed %d\n", nread);
+        fprintf(stderr, "ParamDict read id failed %zd\n", nread);
         return -1;
     }
 
@@ -210,9 +210,9 @@ int ParamDict::load_param_bin(const DataReader& dr)
         {
             int len = 0;
             nread = dr.read(&len, sizeof(int));
-            if (nread != (int)sizeof(int))
+            if (nread != sizeof(int))
             {
-                fprintf(stderr, "ParamDict read array length failed %d\n", nread);
+                fprintf(stderr, "ParamDict read array length failed %zd\n", nread);
                 return -1;
             }
 
@@ -220,9 +220,9 @@ int ParamDict::load_param_bin(const DataReader& dr)
 
             float* ptr = params[id].v;
             nread = dr.read(ptr, sizeof(float) * len);
-            if (nread != (int)sizeof(float) * len)
+            if (nread != sizeof(float) * len)
             {
-                fprintf(stderr, "ParamDict read array element failed %d\n", nread);
+                fprintf(stderr, "ParamDict read array element failed %zd\n", nread);
                 return -1;
             }
 
@@ -231,9 +231,9 @@ int ParamDict::load_param_bin(const DataReader& dr)
         else
         {
             nread = dr.read(&params[id].f, sizeof(float));
-            if (nread != (int)sizeof(float))
+            if (nread != sizeof(float))
             {
-                fprintf(stderr, "ParamDict read value failed %d\n", nread);
+                fprintf(stderr, "ParamDict read value failed %zd\n", nread);
                 return -1;
             }
 
@@ -241,9 +241,9 @@ int ParamDict::load_param_bin(const DataReader& dr)
         }
 
         nread = dr.read(&id, sizeof(int));
-        if (nread != (int)sizeof(int))
+        if (nread != sizeof(int))
         {
-            fprintf(stderr, "ParamDict read EOP failed %d\n", nread);
+            fprintf(stderr, "ParamDict read EOP failed %zd\n", nread);
             return -1;
         }
     }

tools/ncnnoptimize.cpp

@@ -94,7 +94,7 @@ class DataReaderFromEmpty : public ncnn::DataReader
 {
 public:
     virtual int scan(const char* format, void* p) const { return 0; }
-    virtual int read(void* /*buf*/, int size) const { return size; }
+    virtual size_t read(void* /*buf*/, size_t size) const { return size; }
 };
 
 class NetOptimize : public ncnn::Net
@@ -167,7 +167,7 @@ void NetOptimize::find_fastest_fp32_conv(const char* dataname, int w, int h, int
     // embeded system generally use single thread
     opt.num_threads = 1;
 
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
     ncnn::Extractor ex = create_extractor();
     
     ncnn::Mat input(w, h, c);
@@ -318,7 +318,7 @@ int NetOptimize::support_fp32_conv_type(const ncnn::Convolution* op, const ncnn:
 
 int NetOptimize::fuse_batchnorm_scale()
 {
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
     for (int i=0; i<layer_count; i++)
     {
         if (layers[i]->type != "BatchNorm")
@@ -379,7 +379,7 @@ int NetOptimize::fuse_batchnorm_scale()
 
 int NetOptimize::fuse_convolution_batchnorm()
 {
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
     for (int i=0; i<layer_count; i++)
     {
         if (layers[i]->type != "Convolution")
@@ -422,7 +422,7 @@ int NetOptimize::fuse_convolution_batchnorm()
             std::vector<float> b(channels);
             for (int i=0; i<channels; i++)
             {
-                float sqrt_var = sqrt(batchnorm->var_data[i] + eps);
+                float sqrt_var = static_cast<float>(sqrt(batchnorm->var_data[i] + eps));
                 a[i] = batchnorm->bias_data[i] - batchnorm->slope_data[i] * batchnorm->mean_data[i] / sqrt_var;
                 b[i] = batchnorm->slope_data[i] / sqrt_var;
             }
@@ -462,7 +462,7 @@ int NetOptimize::fuse_convolution_batchnorm()
 
 int NetOptimize::fuse_convolutiondepthwise_batchnorm()
 {
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
     for (int i=0; i<layer_count; i++)
     {
         if (layers[i]->type != "ConvolutionDepthWise")
@@ -505,7 +505,7 @@ int NetOptimize::fuse_convolutiondepthwise_batchnorm()
             std::vector<float> b(channels);
             for (int i=0; i<channels; i++)
             {
-                float sqrt_var = sqrt(batchnorm->var_data[i] + eps);
+                float sqrt_var = static_cast<float>(sqrt(batchnorm->var_data[i] + eps));
                 a[i] = batchnorm->bias_data[i] - batchnorm->slope_data[i] * batchnorm->mean_data[i] / sqrt_var;
                 b[i] = batchnorm->slope_data[i] / sqrt_var;
             }
@@ -545,7 +545,7 @@ int NetOptimize::fuse_convolutiondepthwise_batchnorm()
 
 int NetOptimize::fuse_deconvolution_batchnorm()
 {
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
     for (int i=0; i<layer_count; i++)
     {
         if (layers[i]->type != "Deconvolution")
@@ -588,7 +588,7 @@ int NetOptimize::fuse_deconvolution_batchnorm()
             std::vector<float> b(channels);
             for (int i=0; i<channels; i++)
             {
-                float sqrt_var = sqrt(batchnorm->var_data[i] + eps);
+                float sqrt_var = static_cast<float>(sqrt(batchnorm->var_data[i] + eps));
                 a[i] = batchnorm->bias_data[i] - batchnorm->slope_data[i] * batchnorm->mean_data[i] / sqrt_var;
                 b[i] = batchnorm->slope_data[i] / sqrt_var;
             }
@@ -628,7 +628,7 @@ int NetOptimize::fuse_deconvolution_batchnorm()
 
 int NetOptimize::fuse_deconvolutiondepthwise_batchnorm()
 {
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
     for (int i=0; i<layer_count; i++)
     {
         if (layers[i]->type != "DeconvolutionDepthWise")
@@ -671,7 +671,7 @@ int NetOptimize::fuse_deconvolutiondepthwise_batchnorm()
             std::vector<float> b(channels);
             for (int i=0; i<channels; i++)
             {
-                float sqrt_var = sqrt(batchnorm->var_data[i] + eps);
+                float sqrt_var = static_cast<float>(sqrt(batchnorm->var_data[i] + eps));
                 a[i] = batchnorm->bias_data[i] - batchnorm->slope_data[i] * batchnorm->mean_data[i] / sqrt_var;
                 b[i] = batchnorm->slope_data[i] / sqrt_var;
             }
@@ -711,7 +711,7 @@ int NetOptimize::fuse_deconvolutiondepthwise_batchnorm()
 
 int NetOptimize::fuse_innerproduct_batchnorm()
 {
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
     for (int i=0; i<layer_count; i++)
     {
         if (layers[i]->type != "InnerProduct")
@@ -754,7 +754,7 @@ int NetOptimize::fuse_innerproduct_batchnorm()
             std::vector<float> b(channels);
             for (int i=0; i<channels; i++)
             {
-                float sqrt_var = sqrt(batchnorm->var_data[i] + eps);
+                float sqrt_var = static_cast<float>(sqrt(batchnorm->var_data[i] + eps));
                 a[i] = batchnorm->bias_data[i] - batchnorm->slope_data[i] * batchnorm->mean_data[i] / sqrt_var;
                 b[i] = batchnorm->slope_data[i] / sqrt_var;
             }
@@ -794,7 +794,7 @@ int NetOptimize::fuse_innerproduct_batchnorm()
 
 int NetOptimize::fuse_innerproduct_dropout()
 {
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
     for (int i=0; i<layer_count; i++)
     {
         if (layers[i]->type != "InnerProduct")
@@ -862,7 +862,7 @@ int NetOptimize::fuse_innerproduct_dropout()
 
 int NetOptimize::fuse_convolution_activation()
 {
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
     for (int i=0; i<layer_count; i++)
     {
         if (layers[i]->type != "Convolution")
@@ -933,7 +933,7 @@ int NetOptimize::fuse_convolution_activation()
 
 int NetOptimize::fuse_convolutiondepthwise_activation()
 {
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
     for (int i=0; i<layer_count; i++)
     {
         if (layers[i]->type != "ConvolutionDepthWise")
@@ -1004,7 +1004,7 @@ int NetOptimize::fuse_convolutiondepthwise_activation()
 
 int NetOptimize::fuse_deconvolution_activation()
 {
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
     for (int i=0; i<layer_count; i++)
     {
         if (layers[i]->type != "Deconvolution")
@@ -1075,7 +1075,7 @@ int NetOptimize::fuse_deconvolution_activation()
 
 int NetOptimize::fuse_deconvolutiondepthwise_activation()
 {
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
     for (int i=0; i<layer_count; i++)
     {
         if (layers[i]->type != "DeconvolutionDepthWise")
@@ -1146,7 +1146,7 @@ int NetOptimize::fuse_deconvolutiondepthwise_activation()
 
 int NetOptimize::fuse_innerproduct_activation()
 {
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
     for (int i=0; i<layer_count; i++)
     {
         if (layers[i]->type != "InnerProduct")
@@ -1217,7 +1217,7 @@ int NetOptimize::fuse_innerproduct_activation()
 
 int NetOptimize::eliminate_dropout()
 {
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
     for (int i=0; i<layer_count; i++)
     {
         if (layers[i]->type != "Dropout")
@@ -1261,7 +1261,7 @@ int NetOptimize::eliminate_dropout()
 
 int NetOptimize::eliminate_pooling1x1()
 {
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
     for (int i=0; i<layer_count; i++)
     {
         if (layers[i]->type != "Pooling")
@@ -1318,7 +1318,7 @@ int NetOptimize::eliminate_pooling1x1()
 
 int NetOptimize::eliminate_noop()
 {
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
     for (int i=0; i<layer_count; i++)
     {
         if (layers[i]->type != "Noop")
@@ -1331,7 +1331,7 @@ int NetOptimize::eliminate_noop()
             // Noop
             fprintf(stderr, "eliminate_noop %s\n", noop->name.c_str());
 
-            int top_blob_count = noop->tops.size();
+            size_t top_blob_count = noop->tops.size();
             for (int k=0; k<top_blob_count; k++)
             {
                 int top_blob_index_final = noop->tops[k];
@@ -1365,7 +1365,7 @@ int NetOptimize::eliminate_noop()
 
         fprintf(stderr, "eliminate_noop %s %s\n", any->name.c_str(), noop->name.c_str());
 
-        int top_blob_count = std::min(noop->tops.size(), any->tops.size());
+        size_t top_blob_count = std::min(noop->tops.size(), any->tops.size());
         for (int k=0; k<top_blob_count; k++)
         {
             int top_blob_index_final = noop->tops[k];
@@ -1380,7 +1380,7 @@ int NetOptimize::eliminate_noop()
 
 int NetOptimize::eliminate_orphaned_memorydata()
 {
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
     for (int i=0; i<layer_count; i++)
     {
         if (layers[i]->type != "MemoryData")
@@ -1423,7 +1423,7 @@ int NetOptimize::eliminate_orphaned_memorydata()
 
 int NetOptimize::eliminate_reshape_after_global_pooling()
 {
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
     for (int i=0; i<layer_count; i++)
     {
         if (layers[i]->type != "Pooling")
@@ -1469,7 +1469,7 @@ int NetOptimize::eliminate_reshape_after_global_pooling()
 
 int NetOptimize::eliminate_flatten_after_global_pooling()
 {
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
     for (int i=0; i<layer_count; i++)
     {
         if (layers[i]->type != "Pooling")
@@ -1513,7 +1513,7 @@ int NetOptimize::eliminate_flatten_after_global_pooling()
 
 int NetOptimize::eliminate_flatten_after_innerproduct()
 {
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
     for (int i=0; i<layer_count; i++)
     {
         if (layers[i]->type != "InnerProduct")
@@ -1554,7 +1554,7 @@ int NetOptimize::eliminate_flatten_after_innerproduct()
 
 int NetOptimize::eliminate_reshape_before_binaryop()
 {
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
     for (int i=0; i<layer_count; i++)
     {
         if (layers[i]->type != "Reshape")
@@ -1602,7 +1602,7 @@ int NetOptimize::eliminate_reshape_before_binaryop()
 
 int NetOptimize::replace_convolution_with_innerproduct_after_global_pooling()
 {
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
     for (int i=0; i<layer_count; i++)
     {
         if (layers[i]->type != "Pooling")
@@ -1664,7 +1664,7 @@ int NetOptimize::replace_convolution_with_innerproduct_after_global_pooling()
 
 int NetOptimize::replace_convolution_with_innerproduct_after_innerproduct()
 {
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
     for (;;)
     {
     bool replaced = false;
@@ -1785,7 +1785,7 @@ int NetOptimize::fwrite_weight_tag_data(int tag, const ncnn::Mat& data, FILE* bp
 
     // padding to 32bit align
     int nwrite = ftell(bp) - p0;
-    int nalign = alignSize(nwrite, 4);
+    size_t nalign = alignSize(nwrite, 4);
     unsigned char padding[4] = {0x00, 0x00, 0x00, 0x00};
     fwrite(padding, sizeof(unsigned char), nalign - nwrite, bp);
 
@@ -1801,7 +1801,7 @@ int NetOptimize::fwrite_weight_data(const ncnn::Mat& data, FILE* bp)
 
     // padding to 32bit align
     int nwrite = ftell(bp) - p0;
-    int nalign = alignSize(nwrite, 4);
+    size_t nalign = alignSize(nwrite, 4);
     unsigned char padding[4] = {0x00, 0x00, 0x00, 0x00};
     fwrite(padding, sizeof(unsigned char), nalign - nwrite, bp);
 
@@ -1815,7 +1815,7 @@ int NetOptimize::save(const char* parampath, const char* binpath)
 
     fprintf(pp, "7767517\n");
 
-    const int layer_count = layers.size();
+    const size_t layer_count = layers.size();
 
     int layer_count_fused = 0;
     std::set<std::string> blob_names;
@@ -1827,14 +1827,14 @@ int NetOptimize::save(const char* parampath, const char* binpath)
 
         layer_count_fused++;
 
-        int bottom_count = layer->bottoms.size();
+        size_t bottom_count = layer->bottoms.size();
         for (int j=0; j<bottom_count; j++)
         {
             int bottom_blob_index = layer->bottoms[j];
             blob_names.insert(blobs[bottom_blob_index].name);
         }
 
-        int top_count = layer->tops.size();
+        size_t top_count = layer->tops.size();
         for (int j=0; j<top_count; j++)
         {
             int top_blob_index = layer->tops[j];
@@ -1842,9 +1842,9 @@ int NetOptimize::save(const char* parampath, const char* binpath)
         }
     }
 
-    int blob_count_fused = blob_names.size();
+    size_t blob_count_fused = blob_names.size();
 
-    fprintf(pp, "%d %d\n", layer_count_fused, blob_count_fused);
+    fprintf(pp, "%d %zd\n", layer_count_fused, blob_count_fused);
 
     for (int i=0; i<layer_count; i++)
     {
@@ -1852,10 +1852,10 @@ int NetOptimize::save(const char* parampath, const char* binpath)
         if (layer->type == "ncnnfused")
             continue;
 
-        int bottom_count = layer->bottoms.size();
-        int top_count = layer->tops.size();
+        size_t bottom_count = layer->bottoms.size();
+        size_t top_count = layer->tops.size();
 
-        fprintf(pp, "%-24s %-24s %d %d", layer->type.c_str(), layer->name.c_str(), bottom_count, top_count);
+        fprintf(pp, "%-24s %-24s %zd %zd", layer->type.c_str(), layer->name.c_str(), bottom_count, top_count);
 
         for (int j=0; j<bottom_count; j++)
         {