rename Mat packing to elempack

Author: nihui

src/command.cpp

@@ -847,9 +847,9 @@ VkTransfer::~VkTransfer()
 
 void VkTransfer::record_upload(const Mat& src, VkMat& dst, const Option& opt)
 {
-    if (src.elemsize / src.packing == 4)
+    if (src.elemsize / src.elempack == 4)
     {
-        if (opt.use_fp16_storage || (opt.use_fp16_packed && src.packing % 4 == 0))
+        if (opt.use_fp16_storage || (opt.use_fp16_packed && src.elempack % 4 == 0))
         {
             Mat src_fp16;
             cast_float32_to_float16(src, src_fp16);

src/layer/arm/absval_arm.cpp

@@ -35,10 +35,10 @@ int AbsVal_arm::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
     int h = bottom_top_blob.h;
     int channels = bottom_top_blob.c;
     int size = w * h;
-    int packing = bottom_top_blob.packing;
+    int elempack = bottom_top_blob.elempack;
 
 #if __ARM_NEON
-    if (packing == 4)
+    if (elempack == 4)
     {
         #pragma omp parallel for num_threads(opt.num_threads)
         for (int q=0; q<channels; q++)

src/layer/arm/batchnorm_arm.cpp

@@ -42,10 +42,10 @@ int BatchNorm_arm::forward_inplace(Mat& bottom_top_blob, const Option& opt) cons
     int w = bottom_top_blob.w;
     int h = bottom_top_blob.h;
     int size = w * h;
-    int packing = bottom_top_blob.packing;
+    int elempack = bottom_top_blob.elempack;
 
 #if __ARM_NEON
-    if (packing == 4)
+    if (elempack == 4)
     {
         const float* a_data_ptr = a_data;
         const float* b_data_ptr = b_data;

src/layer/arm/clip_arm.cpp

@@ -35,10 +35,10 @@ int Clip_arm::forward_inplace(Mat &bottom_top_blob, const Option &opt) const
     int h = bottom_top_blob.h;
     int channels = bottom_top_blob.c;
     int size = w * h;
-    int packing = bottom_top_blob.packing;
+    int elempack = bottom_top_blob.elempack;
 
 #if __ARM_NEON
-    if (packing == 4)
+    if (elempack == 4)
     {
         #pragma omp parallel for num_threads(opt.num_threads)
         for (int q=0; q<channels; q++)

src/layer/arm/convolution_arm.cpp

@@ -471,7 +471,7 @@ int Convolution_arm::forward(const Mat& bottom_blob, Mat& top_blob, const Option
     int h = bottom_blob.h;
     int channels = bottom_blob.c;
     size_t elemsize = bottom_blob.elemsize;
-    int packing = bottom_blob.packing;
+    int elempack = bottom_blob.elempack;
 
 //     fprintf(stderr, "Convolution input %d x %d  pad = %d %d  ksize=%d %d  stride=%d %d\n", w, h, pad_w, pad_h, kernel_w, kernel_h, stride_w, stride_h);
 
@@ -505,8 +505,8 @@ int Convolution_arm::forward(const Mat& bottom_blob, Mat& top_blob, const Option
 
     int outw = (w - kernel_extent_w) / stride_w + 1;
     int outh = (h - kernel_extent_h) / stride_h + 1;
-    int out_packing = num_output % 4 == 0 ? 4 : 1;
-    size_t out_elemsize = elemsize / packing * out_packing;
+    int out_elempack = num_output % 4 == 0 ? 4 : 1;
+    size_t out_elemsize = elemsize / elempack * out_elempack;
 
     const int maxk = kernel_w * kernel_h;
 
@@ -530,15 +530,15 @@ int Convolution_arm::forward(const Mat& bottom_blob, Mat& top_blob, const Option
     }
 
     // float32
-    top_blob.create(outw, outh, num_output / out_packing, out_elemsize, out_packing, opt.blob_allocator);
+    top_blob.create(outw, outh, num_output / out_elempack, out_elemsize, out_elempack, opt.blob_allocator);
     if (top_blob.empty())
         return -100;
 
-    if (packing == 4 && out_packing == 4)
+    if (elempack == 4 && out_elempack == 4)
     {
         // num_output
         #pragma omp parallel for num_threads(opt.num_threads)
-        for (int p=0; p<num_output / out_packing; p++)
+        for (int p=0; p<num_output / out_elempack; p++)
         {
             float* outptr = top_blob.channel(p);
 
@@ -628,11 +628,11 @@ int Convolution_arm::forward(const Mat& bottom_blob, Mat& top_blob, const Option
         return 0;
     }
 
-    if (packing == 1 && out_packing == 4)
+    if (elempack == 1 && out_elempack == 4)
     {
         // num_output
         #pragma omp parallel for num_threads(opt.num_threads)
-        for (int p=0; p<num_output / out_packing; p++)
+        for (int p=0; p<num_output / out_elempack; p++)
         {
             float* outptr = top_blob.channel(p);
 
@@ -707,7 +707,7 @@ int Convolution_arm::forward(const Mat& bottom_blob, Mat& top_blob, const Option
         return 0;
     }
 
-    if (packing == 4 && out_packing == 1)
+    if (elempack == 4 && out_elempack == 1)
     {
         // num_output
         #pragma omp parallel for num_threads(opt.num_threads)

src/layer/arm/convolutiondepthwise_arm.cpp

@@ -397,7 +397,7 @@ int ConvolutionDepthWise_arm::forward(const Mat& bottom_blob, Mat& top_blob, con
     int h = bottom_blob.h;
     int channels = bottom_blob.c;
     size_t elemsize = bottom_blob.elemsize;
-    int packing = bottom_blob.packing;
+    int elempack = bottom_blob.elempack;
 
     const int kernel_extent_w = dilation_w * (kernel_w - 1) + 1;
     const int kernel_extent_h = dilation_h * (kernel_h - 1) + 1;
@@ -455,8 +455,8 @@ int ConvolutionDepthWise_arm::forward(const Mat& bottom_blob, Mat& top_blob, con
 
     int outw = (w - kernel_extent_w) / stride_w + 1;
     int outh = (h - kernel_extent_h) / stride_h + 1;
-    int out_packing = num_output % 4 == 0 ? 4 : 1;
-    size_t out_elemsize = elemsize / packing * out_packing;
+    int out_elempack = num_output % 4 == 0 ? 4 : 1;
+    size_t out_elemsize = elemsize / elempack * out_elempack;
 
     if (opt.use_packing_layout)
     {
@@ -482,17 +482,17 @@ int ConvolutionDepthWise_arm::forward(const Mat& bottom_blob, Mat& top_blob, con
         }
     }
 
-    top_blob.create(outw, outh, num_output / out_packing, out_elemsize, out_packing, opt.blob_allocator);
+    top_blob.create(outw, outh, num_output / out_elempack, out_elemsize, out_elempack, opt.blob_allocator);
     if (top_blob.empty())
         return -100;
 
     // depth-wise
-    if (channels == group / packing && group / packing == num_output / packing)
+    if (channels == group / elempack && group / elempack == num_output / elempack)
     {
-    if (packing == 4)
+    if (elempack == 4)
     {
         #pragma omp parallel for num_threads(opt.num_threads)
-        for (int g=0; g<group / packing; g++)
+        for (int g=0; g<group / elempack; g++)
         {
             float* outptr = top_blob.channel(g);
             const float* kptr = (const float*)weight_data_pack4 + maxk * g * 4;
@@ -561,20 +561,20 @@ int ConvolutionDepthWise_arm::forward(const Mat& bottom_blob, Mat& top_blob, con
     }
     }
 
-    const int channels_g = channels * packing / group;
+    const int channels_g = channels * elempack / group;
     const int num_output_g = num_output / group;
 
     // unpacking
     Mat bottom_blob_bordered_unpacked = bottom_blob_bordered;
-    if (packing == 4 && channels_g % 4 != 0)
+    if (elempack == 4 && channels_g % 4 != 0)
     {
         convert_packing(bottom_blob_bordered, bottom_blob_bordered_unpacked, 1, opt.workspace_allocator, opt.num_threads);
     }
 
     Mat top_blob_unpacked = top_blob;
-    if (num_output_g % 4 != 0 && out_packing == 4)
+    if (num_output_g % 4 != 0 && out_elempack == 4)
     {
-        top_blob_unpacked.create(outw, outh, num_output, elemsize / packing, 1, opt.workspace_allocator);
+        top_blob_unpacked.create(outw, outh, num_output, elemsize / elempack, 1, opt.workspace_allocator);
         if (top_blob_unpacked.empty())
             return -100;
     }
@@ -843,7 +843,7 @@ int ConvolutionDepthWise_arm::forward(const Mat& bottom_blob, Mat& top_blob, con
     }
 
     // packing
-    if (num_output_g % 4 != 0 && out_packing == 4)
+    if (num_output_g % 4 != 0 && out_elempack == 4)
     {
         convert_packing(top_blob_unpacked, top_blob, 4, opt.blob_allocator, opt.num_threads);
     }

src/layer/arm/innerproduct_arm.cpp

@@ -160,26 +160,26 @@ int InnerProduct_arm::forward(const Mat& bottom_blob, Mat& top_blob, const Optio
     int h = bottom_blob.h;
     int channels = bottom_blob.c;
     size_t elemsize = bottom_blob.elemsize;
-    int packing = bottom_blob.packing;
+    int elempack = bottom_blob.elempack;
     int size = w * h;
 
     if (opt.use_packing_layout)
     {
 
     int num_input = bottom_blob.w;
 
-    int out_packing = num_output % 4 == 0 ? 4 : 1;
-    size_t out_elemsize = elemsize / packing * out_packing;
+    int out_elempack = num_output % 4 == 0 ? 4 : 1;
+    size_t out_elemsize = elemsize / elempack * out_elempack;
 
-    top_blob.create(num_output / out_packing, out_elemsize, out_packing, opt.blob_allocator);
+    top_blob.create(num_output / out_elempack, out_elemsize, out_elempack, opt.blob_allocator);
     if (top_blob.empty())
         return -100;
 
-    if (packing == 4 && out_packing == 4)
+    if (elempack == 4 && out_elempack == 4)
     {
         // num_output
         #pragma omp parallel for num_threads(opt.num_threads)
-        for (int p=0; p<num_output / out_packing; p++)
+        for (int p=0; p<num_output / out_elempack; p++)
         {
             const float* w = (const float*)weight_data_pack4 + num_input * p * 16;
             const float* m = bottom_blob;
@@ -256,11 +256,11 @@ int InnerProduct_arm::forward(const Mat& bottom_blob, Mat& top_blob, const Optio
         return 0;
     }
 
-    if (packing == 1 && out_packing == 4)
+    if (elempack == 1 && out_elempack == 4)
     {
         // num_output
         #pragma omp parallel for num_threads(opt.num_threads)
-        for (int p=0; p<num_output / out_packing; p++)
+        for (int p=0; p<num_output / out_elempack; p++)
         {
             const float* w = (const float*)weight_data_pack1to4 + num_input * p * 4;
             const float* m = bottom_blob;
@@ -321,7 +321,7 @@ int InnerProduct_arm::forward(const Mat& bottom_blob, Mat& top_blob, const Optio
         return 0;
     }
 
-    if (packing == 4 && out_packing == 1)
+    if (elempack == 4 && out_elempack == 1)
     {
         // num_output
         #pragma omp parallel for num_threads(opt.num_threads)

src/layer/arm/packing_arm.cpp

@@ -34,16 +34,16 @@ int Packing_arm::forward(const Mat& bottom_blob, Mat& top_blob, const Option& op
         return Packing::forward(bottom_blob, top_blob, opt);
     }
 
-    int packing = bottom_blob.packing;
+    int elempack = bottom_blob.elempack;
 
-    if (packing == out_packing)
+    if (elempack == out_elempack)
     {
         top_blob = bottom_blob;
         return 0;
     }
 
-    bool pack1to4 = packing == 1 && out_packing == 4;
-    bool pack4to1 = packing == 4 && out_packing == 1;
+    bool pack1to4 = elempack == 1 && out_elempack == 4;
+    bool pack4to1 = elempack == 4 && out_elempack == 1;
 
     if (!pack1to4 && !pack4to1)
     {
@@ -59,17 +59,17 @@ int Packing_arm::forward(const Mat& bottom_blob, Mat& top_blob, const Option& op
     if (!use_padding)
     {
         // identity if use_padding not allowed
-        if (dims == 1 && w * packing % out_packing != 0)
+        if (dims == 1 && w * elempack % out_elempack != 0)
         {
             top_blob = bottom_blob;
             return 0;
         }
-        if (dims == 2 && h * packing % out_packing != 0)
+        if (dims == 2 && h * elempack % out_elempack != 0)
         {
             top_blob = bottom_blob;
             return 0;
         }
-        if (dims == 3 && channels * packing % out_packing != 0)
+        if (dims == 3 && channels * elempack % out_elempack != 0)
         {
             top_blob = bottom_blob;
             return 0;
@@ -79,19 +79,19 @@ int Packing_arm::forward(const Mat& bottom_blob, Mat& top_blob, const Option& op
     if (dims == 1)
     {
         top_blob = bottom_blob;
-        top_blob.w = w * packing / out_packing;
-        top_blob.cstep = w * packing / out_packing;
-        top_blob.elemsize = elemsize / packing * out_packing;
-        top_blob.packing = out_packing;
+        top_blob.w = w * elempack / out_elempack;
+        top_blob.cstep = w * elempack / out_elempack;
+        top_blob.elemsize = elemsize / elempack * out_elempack;
+        top_blob.elempack = out_elempack;
         return 0;
     }
 
     if (dims == 2)
     {
-        int outh = h * packing / out_packing;
-        size_t out_elemsize = elemsize / packing * out_packing;
+        int outh = h * elempack / out_elempack;
+        size_t out_elemsize = elemsize / elempack * out_elempack;
 
-        top_blob.create(w, outh, out_elemsize, out_packing, opt.blob_allocator);
+        top_blob.create(w, outh, out_elemsize, out_elempack, opt.blob_allocator);
         if (top_blob.empty())
             return -100;
 
@@ -195,10 +195,10 @@ int Packing_arm::forward(const Mat& bottom_blob, Mat& top_blob, const Option& op
     if (dims == 3)
     {
         int size = w * h;
-        int outc = channels * packing / out_packing;
-        size_t out_elemsize = elemsize / packing * out_packing;
+        int outc = channels * elempack / out_elempack;
+        size_t out_elemsize = elemsize / elempack * out_elempack;
 
-        top_blob.create(w, h, outc, out_elemsize, out_packing, opt.blob_allocator);
+        top_blob.create(w, h, outc, out_elemsize, out_elempack, opt.blob_allocator);
         if (top_blob.empty())
             return -100;
 

src/layer/arm/padding_arm.cpp

@@ -162,10 +162,10 @@ int Padding_arm::forward(const Mat& bottom_blob, Mat& top_blob, const Option& op
     int channels = bottom_blob.c;
     int dims = bottom_blob.dims;
     size_t elemsize = bottom_blob.elemsize;
-    int packing = bottom_blob.packing;
+    int elempack = bottom_blob.elempack;
 
 #if __ARM_NEON
-    if (packing == 4)
+    if (elempack == 4)
     {
         int outw = w + left + right;
 

src/layer/arm/relu_arm.cpp

@@ -119,10 +119,10 @@ int ReLU_arm::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
     int h = bottom_top_blob.h;
     int channels = bottom_top_blob.c;
     int size = w * h;
-    int packing = bottom_top_blob.packing;
+    int elempack = bottom_top_blob.elempack;
 
 #if __ARM_NEON
-    if (packing == 4)
+    if (elempack == 4)
     {
         if (slope == 0.f)
         {