Huawei_Technology
/
mindspore
Not watched
1
0
Fork 0
Code
Releases 13 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 30c242d70a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '30c242d70a'
${ noResults }
mindspore/mindspore/ccsrc/common/trans.cc

750 lines
28 kB
Raw Blame History 

  1. /**

  2.  * Copyright 2020 Huawei Technologies Co., Ltd

  3.  *

  4.  * Licensed under the Apache License, Version 2.0 (the "License");

  5.  * you may not use this file except in compliance with the License.

  6.  * You may obtain a copy of the License at

  7.  *

  8.  * http://www.apache.org/licenses/LICENSE-2.0

  9.  *

  10.  * Unless required by applicable law or agreed to in writing, software

  11.  * distributed under the License is distributed on an "AS IS" BASIS,

  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  13.  * See the License for the specific language governing permissions and

  14.  * limitations under the License.

  15.  */

  16. #include "common/trans.h"

  17. #include <algorithm>

  18. #include <functional>

  19. #include <numeric>

  20. #include <utility>

  21. #include "./securec.h"

  22. #include "common/utils.h"

  23. #include "device/convert_tensor_utils.h"

  24. #include "utils/convert_utils.h"

  25. #include "utils/log_adapter.h"

  26. #include "utils/utils.h"

  27. 

  28. namespace mindspore {

  29. namespace trans {

  30. const size_t kNchwDims = 4;

  31. const std::map<TypeId, size_t> type_map = {{kNumberTypeBool, 1},    {kNumberTypeInt, 4},     {kNumberTypeInt8, 1},

  32.                                            {kNumberTypeInt16, 2},   {kNumberTypeInt32, 4},   {kNumberTypeInt64, 8},

  33.                                            {kNumberTypeUInt, 4},    {kNumberTypeUInt8, 1},   {kNumberTypeUInt16, 2},

  34.                                            {kNumberTypeUInt32, 4},  {kNumberTypeUInt64, 8},  {kNumberTypeFloat, 4},

  35.                                            {kNumberTypeFloat16, 2}, {kNumberTypeFloat32, 4}, {kNumberTypeFloat64, 8}};

  36. 

  37. template <typename T>

  38. T Ceil(T n1, T n2) {

  39.   return (n2 != 0) ? (n1 - 1) / n2 + 1 : 0;

  40. }

  41. 

  42. enum DataTypeTransMode {

  43.   FROM_FLOAT_TO_FLOAT16,

  44.   FROM_FLOAT_TO_INT32,

  45.   FROM_FLOAT16_TO_FLOAT,

  46.   FROM_FLOAT16_TO_INT32,

  47.   FROM_INT32_TO_FLOAT,

  48.   FROM_INT32_TO_FLOAT16,

  49.   FROM_INT32_TO_UINT8,

  50.   FROM_INT32_TO_INT8,

  51.   FROM_UINT8_TO_FLOAT,

  52.   FROM_UINT8_TO_INT32,

  53.   FROM_INT8_TO_FLOAT,

  54.   FROM_INT8_TO_INT32,

  55.   FROM_INT64_TO_INT32,

  56.   FROM_UINT16_TO_INT32,

  57. };

  58. 

  59. const std::map<std::pair<TypeId, TypeId>, DataTypeTransMode> mode_map{

  60.   {std::pair<TypeId, TypeId>(kNumberTypeFloat32, kNumberTypeFloat16), FROM_FLOAT_TO_FLOAT16},

  61.   {std::pair<TypeId, TypeId>(kNumberTypeFloat32, kNumberTypeInt32), FROM_FLOAT_TO_INT32},

  62.   {std::pair<TypeId, TypeId>(kNumberTypeFloat16, kNumberTypeFloat32), FROM_FLOAT16_TO_FLOAT},

  63.   {std::pair<TypeId, TypeId>(kNumberTypeFloat16, kNumberTypeInt32), FROM_FLOAT16_TO_INT32},

  64.   {std::pair<TypeId, TypeId>(kNumberTypeInt32, kNumberTypeFloat32), FROM_INT32_TO_FLOAT},

  65.   {std::pair<TypeId, TypeId>(kNumberTypeInt32, kNumberTypeFloat16), FROM_INT32_TO_FLOAT16},

  66.   {std::pair<TypeId, TypeId>(kNumberTypeInt32, kNumberTypeUInt8), FROM_INT32_TO_UINT8},

  67.   {std::pair<TypeId, TypeId>(kNumberTypeInt32, kNumberTypeInt8), FROM_INT32_TO_INT8},

  68.   {std::pair<TypeId, TypeId>(kNumberTypeUInt8, kNumberTypeFloat32), FROM_UINT8_TO_FLOAT},

  69.   {std::pair<TypeId, TypeId>(kNumberTypeUInt8, kNumberTypeInt32), FROM_UINT8_TO_INT32},

  70.   {std::pair<TypeId, TypeId>(kNumberTypeInt8, kNumberTypeFloat32), FROM_INT8_TO_FLOAT},

  71.   {std::pair<TypeId, TypeId>(kNumberTypeInt8, kNumberTypeInt32), FROM_INT8_TO_INT32},

  72.   {std::pair<TypeId, TypeId>(kNumberTypeInt64, kNumberTypeInt32), FROM_INT64_TO_INT32},

  73.   {std::pair<TypeId, TypeId>(kNumberTypeUInt16, kNumberTypeInt32), FROM_UINT16_TO_INT32}};

  74. 

  75. template <typename SrcT, typename DstT>

  76. void TransDataSrc2Dst(const TypeIdArgs &args, void *dst, const size_t data_size) {

  77.   for (size_t idx = 0; idx != data_size; idx++) {

  78.     SrcT src_data = static_cast<const SrcT *>(args.data)[idx];

  79.     static_cast<DstT *>(dst)[idx] = static_cast<DstT>(src_data);

  80.   }

  81. }

  82. 

  83. bool CastKernel(const TypeIdArgs &args, void *dst, const size_t data_size, const DataTypeTransMode mode) {

  84.   switch (mode) {

  85.     case FROM_FLOAT_TO_FLOAT16:

  86.       device::FloatToHalf(dst, args.data, data_size);

  87.       break;

  88.     case FROM_FLOAT16_TO_FLOAT:

  89.       device::HalfToFloat(dst, args.data, data_size);

  90.       break;

  91.     case FROM_FLOAT_TO_INT32:

  92.       TransDataSrc2Dst<float, int32_t>(args, dst, data_size);

  93.       break;

  94.     case FROM_FLOAT16_TO_INT32:

  95.       TransDataSrc2Dst<float16, int32_t>(args, dst, data_size);

  96.       break;

  97.     case FROM_INT32_TO_FLOAT:

  98.       TransDataSrc2Dst<int32_t, float>(args, dst, data_size);

  99.       break;

  100.     case FROM_INT32_TO_INT8:

  101.       TransDataSrc2Dst<int32_t, int8_t>(args, dst, data_size);

  102.       break;

  103.     case FROM_INT32_TO_UINT8:

  104.       TransDataSrc2Dst<int32_t, uint8_t>(args, dst, data_size);

  105.       break;

  106.     case FROM_UINT8_TO_INT32:

  107.       TransDataSrc2Dst<uint8_t, int32_t>(args, dst, data_size);

  108.       break;

  109.     case FROM_UINT8_TO_FLOAT:

  110.       TransDataSrc2Dst<uint8_t, float>(args, dst, data_size);

  111.       break;

  112.     case FROM_INT8_TO_FLOAT:

  113.       TransDataSrc2Dst<int8_t, float>(args, dst, data_size);

  114.       break;

  115.     case FROM_INT8_TO_INT32:

  116.       TransDataSrc2Dst<int8_t, int32_t>(args, dst, data_size);

  117.       break;

  118.     case FROM_INT64_TO_INT32:

  119.       TransDataSrc2Dst<int64_t, int32_t>(args, dst, data_size);

  120.       break;

  121.     case FROM_UINT16_TO_INT32:

  122.       TransDataSrc2Dst<uint16_t, int32_t>(args, dst, data_size);

  123.       break;

  124.     default:

  125.       MS_LOG(ERROR) << "Unsupported datatype trans";

  126.       return false;

  127.   }

  128.   return true;

  129. }

  130. 

  131. size_t CubeSizeByType(const TypeId data_type) {

  132.   const size_t default_error = 0;

  133.   auto dt_size = TypeIdSize(data_type);

  134.   if (dt_size < 1) {

  135.     MS_LOG(ERROR) << "Illegal dtype.";

  136.     return default_error;

  137.   } else if (dt_size == 1) {

  138.     return kCubeSize * 2;

  139.   }

  140.   return kCubeSize;

  141. }

  142. 

  143. size_t ShapeSize(const std::vector<size_t> &shape) {

  144.   size_t product = std::accumulate(shape.begin(), shape.end(), 1, std::multiplies<size_t>());

  145.   return product;

  146. }

  147. 

  148. size_t TypeIdSize(const TypeId data_type) {

  149.   const size_t unsupported_type_error = 0;

  150.   auto iter = type_map.find(data_type);

  151.   if (iter != type_map.end()) {

  152.     return iter->second;

  153.   }

  154.   return unsupported_type_error;

  155. }

  156. 

  157. std::vector<size_t> TransShapeTo4d(const std::vector<size_t> &shape) {

  158.   std::vector<size_t> shape_4d(4, 1);

  159.   switch (shape.size()) {

  160.     case 0:

  161.       break;

  162.     case 1:

  163.       shape_4d[1] = shape[0];

  164.       break;

  165.     case 2:

  166.       shape_4d[0] = shape[0];

  167.       shape_4d[1] = shape[1];

  168.       break;

  169.     case 3:

  170.       MS_LOG(EXCEPTION) << "Unexpected shape size = 3,it should has a default format";

  171.     case 4:

  172.       for (size_t i = 0; i < 4; ++i) {

  173.         shape_4d[i] = shape[i];

  174.       }

  175.       break;

  176.     default:

  177.       MS_LOG(EXCEPTION) << "Unexpected shape size = " << shape.size();

  178.   }

  179.   return shape_4d;

  180. }

  181. 

  182. std::vector<size_t> TransShapeToDevice(const std::vector<size_t> &shape, const std::string &format) {

  183.   std::vector<size_t> device_shape;

  184.   if (format == kOpFormat_FRAC_NZ) {

  185.     if (shape.size() < 2) {

  186.       MS_EXCEPTION(NotSupportError) << "Format " << format << " is not support shape " << shape.size();

  187.     }

  188.     if (shape.size() > 2) {

  189.       (void)std::copy(shape.begin(), shape.end() - 2, std::back_inserter(device_shape));

  190.     }

  191.     auto h1 = (shape[shape.size() - 2] - 1) / kCubeSize + 1;

  192.     auto w1 = (shape[shape.size() - 1] - 1) / kCubeSize + 1;

  193.     device_shape.push_back(w1);

  194.     device_shape.push_back(h1);

  195.     device_shape.push_back(kCubeSize);

  196.     device_shape.push_back(kCubeSize);

  197.     return device_shape;

  198.   }

  199.   if (shape.size() != 4) {

  200.     MS_LOG(EXCEPTION) << "shape_4d size should be 4";

  201.   }

  202.   if (format == kOpFormat_NC1HWC0) {

  203.     size_t C1 = (shape[1] + kCubeSize - 1) / kCubeSize;

  204.     size_t C0 = kCubeSize;

  205.     device_shape.push_back(shape[0]);

  206.     device_shape.push_back(C1);

  207.     device_shape.push_back(shape[2]);

  208.     device_shape.push_back(shape[3]);

  209.     device_shape.push_back(C0);

  210.     return device_shape;

  211.   } else if (format == kOpFormat_FRAC_Z) {

  212.     size_t cout16 = ((shape[0] + kCubeSize - 1) / kCubeSize) * kCubeSize;

  213.     size_t cin16 = ((shape[1] + kCubeSize - 1) / kCubeSize) * kCubeSize;

  214.     device_shape.push_back(shape[2] * shape[3] * cin16 / kCubeSize);

  215.     device_shape.push_back(cout16 / kCubeSize);

  216.     device_shape.push_back(kCubeSize);

  217.     device_shape.push_back(kCubeSize);

  218.     return device_shape;

  219.   } else if (format == kOpFormat_NHWC) {

  220.     device_shape.push_back(shape[0]);

  221.     device_shape.push_back(shape[2]);

  222.     device_shape.push_back(shape[3]);

  223.     device_shape.push_back(shape[1]);

  224.     return device_shape;

  225.   } else if (format == kOpFormat_NCHW) {

  226.     return shape;

  227.   } else if (format == kOpFormat_HWCN) {

  228.     return {shape[2], shape[3], shape[1], shape[0]};

  229.   }

  230.   MS_LOG(EXCEPTION) << "Unexpected format[" << format << "]";

  231. }

  232. 

  233. bool TransDataType(const TypeIdArgs &args, void *result) {

  234.   MS_LOG(DEBUG) << "Begin trans datatype from " << TypeIdLabel(args.host_data_type) << " to "

  235.                 << TypeIdLabel(args.device_data_type);

  236.   MS_EXCEPTION_IF_NULL(result);

  237.   std::pair<TypeId, TypeId> type_info(args.host_data_type, args.device_data_type);

  238.   auto iter = mode_map.find(type_info);

  239.   if (iter == mode_map.end()) {

  240.     MS_LOG(ERROR) << "Unsupported datatype trans. src_type :" << TypeIdLabel(args.host_data_type)

  241.                   << ", dst_type:" << TypeIdLabel(args.device_data_type);

  242.     return false;

  243.   }

  244.   auto trans_mode = iter->second;

  245.   auto type_size = TypeIdSize(args.device_data_type);

  246.   if (type_size < 1) {

  247.     MS_LOG(ERROR) << "Invalid host data type.";

  248.     return false;

  249.   }

  250.   if (args.host_shape_size < 1) {

  251.     MS_LOG(ERROR) << "Invalid host data size.";

  252.     return false;

  253.   }

  254.   if (!CastKernel(args, result, args.host_shape_size, trans_mode)) {

  255.     MS_LOG(ERROR) << "Failed to trans datatype..";

  256.     return false;

  257.   }

  258.   return true;

  259. }

  260. 

  261. bool TransFormat(const FormatArgs &args, void *result) {

  262.   MS_LOG(DEBUG) << "Start trans format.";

  263.   if (TypeIdSize(args.src_data_type) < 1) {

  264.     MS_LOG(ERROR) << "Invalid datatype..";

  265.     return false;

  266.   }

  267.   if ((args.host_format == kOpFormat_NCHW || args.host_format == kOpFormat_ND) &&

  268.       args.device_format == kOpFormat_FRAC_Z) {

  269.     return NchwToFracZ(args, result);

  270.   } else if (args.device_format == kOpFormat_FRAC_NZ) {

  271.     return NchwToFracNz(args, result);

  272.   } else if (args.device_format == kOpFormat_NC1HWC0) {

  273.     return NchwToNc1hwc0(args, result);

  274.   }

  275.   return true;

  276. }

  277. 

  278. bool TransFormatFromDeviceToHost(const FormatArgs &args, void *result) {

  279.   MS_LOG(DEBUG) << "Start trans format.";

  280.   if (TypeIdSize(args.src_data_type) < 1) {

  281.     MS_LOG(ERROR) << "Invalid datatype..";

  282.     return false;

  283.   }

  284.   if ((args.host_format == kOpFormat_NCHW || args.host_format == kOpFormat_ND) &&

  285.       args.device_format == kOpFormat_FRAC_Z) {

  286.     return FracZToNchw(args, result);

  287.   } else if (args.device_format == kOpFormat_FRAC_NZ) {

  288.     return FracNzToNchw(args, result);

  289.   } else if (args.device_format == kOpFormat_NC1HWC0) {

  290.     return Nc1hwc0ToNchw(args, result);

  291.   }

  292.   return true;

  293. }

  294. 

  295. bool NchwToFracZ(const FormatArgs &args, void *result) {

  296.   MS_LOG(DEBUG) << "Trans format from nchw to frac_z";

  297.   MS_EXCEPTION_IF_NULL(result);

  298.   if (args.host_shape.size() != kNchwDims) {

  299.     MS_LOG(ERROR) << "Invalid host shape, host shape dims:" << args.host_shape.size() << ", expect dims:" << kNchwDims;

  300.     return false;

  301.   }

  302.   size_t size = TypeIdSize(args.src_data_type);

  303.   if (size < 1) {

  304.     MS_LOG(ERROR) << "Illegal dtype.";

  305.     return false;

  306.   }

  307.   auto n = args.host_shape[0];

  308.   auto c = args.host_shape[1];

  309.   auto h = args.host_shape[2];

  310.   auto w = args.host_shape[3];

  311. 

  312.   size_t c0 = CubeSizeByType(args.src_data_type);

  313.   if (c0 < 1) {

  314.     MS_LOG(ERROR) << "Illegal dtype.";

  315.     return false;

  316.   }

  317.   size_t c1 = Ceil(c, c0);

  318.   size_t hw = h * w;

  319.   size_t chw = c * hw;

  320.   size_t hwc0 = hw * c0;

  321.   size_t nchw = n * chw;

  322. 

  323.   size_t hf_cnt = Ceil(n, kCubeSize);

  324.   size_t vf_cnt = c1 * hw;

  325.   size_t fractal_ele_cnt = c0 * kCubeSize;

  326.   size_t total_ele_cnt = hf_cnt * vf_cnt * fractal_ele_cnt;

  327. 

  328.   size_t dst_size = total_ele_cnt * size;

  329.   if (dst_size != args.device_size) {

  330.     MS_LOG(ERROR) << "Illegal total data size."

  331.                   << "dst size is :" << dst_size << "device size is :" << args.device_size;

  332.     return false;

  333.   }

  334.   for (size_t vfi = 0; vfi < vf_cnt; vfi++) {

  335.     auto vf_base_i = vfi * hf_cnt;  // vertical fractal matrix base index

  336.     for (size_t hfi = 0; hfi < hf_cnt; hfi++) {

  337.       auto gfi = vf_base_i + hfi;  // global fractal matrix index

  338.       auto src_n_offset = hfi * chw * kCubeSize;

  339.       auto src_f_offset = src_n_offset + vfi % hw + vfi / hw * hwc0;

  340.       for (size_t row = 0; row < c0; row++) {

  341.         auto src_ci = vfi / hw * c0 + row;

  342.         auto src_row_offset = src_f_offset + row * hw;

  343.         for (size_t col = 0; col < kCubeSize; col++) {

  344.           auto src_ni = hfi * kCubeSize + col;

  345.           auto src_offset = src_row_offset + chw * col;

  346. 

  347.           auto need_pad_zero = src_ni >= n || src_offset >= nchw || src_ci >= c;

  348.           auto idx = gfi * fractal_ele_cnt + col * c0 + row;

  349.           auto offset = idx * size;

  350.           auto protected_size = dst_size - offset < static_cast<size_t>(SECUREC_MEM_MAX_LEN)

  351.                                   ? dst_size - offset

  352.                                   : static_cast<size_t>(SECUREC_MEM_MAX_LEN);

  353.           errno_t ret;

  354.           if (need_pad_zero) {

  355.             ret = memset_s(static_cast<uint8_t *>(result) + offset, protected_size, 0, size);

  356.           } else {

  357.             ret = memcpy_s(static_cast<uint8_t *>(result) + offset, protected_size,

  358.                            static_cast<uint8_t const *>(args.data) + src_offset * size, size);

  359.           }

  360.           if (ret != 0) {

  361.             MS_LOG(ERROR) << "Failed to operate the dst memory error-code " << ret;

  362.             return false;

  363.           }

  364.         }

  365.       }

  366.     }

  367.   }

  368.   return true;

  369. }

  370. 

  371. bool FracZToNchw(const FormatArgs &args, void *result) {

  372.   MS_LOG(DEBUG) << "Trans format from frac_z to nchw";

  373.   MS_EXCEPTION_IF_NULL(result);

  374.   if (args.host_shape.size() != kNchwDims) {

  375.     MS_LOG(ERROR) << "Invalid host shape, host shape dims:" << args.host_shape.size() << ", expect dims:" << kNchwDims;

  376.     return false;

  377.   }

  378.   size_t size = TypeIdSize(args.src_data_type);

  379.   if (size < 1) {

  380.     MS_LOG(ERROR) << "Illegal dtype.";

  381.     return false;

  382.   }

  383.   size_t total_size = ShapeSize(args.device_shape) * size;

  384.   if (total_size != args.device_size) {

  385.     MS_LOG(ERROR) << "Illegal total data size, total_size:" << total_size << ", device_size:" << args.device_size;

  386.     return false;

  387.   }

  388. 

  389.   auto n0 = args.device_shape.at(1);

  390.   auto ni = args.device_shape.at(2);

  391.   auto c0 = args.device_shape.at(3);

  392. 

  393.   auto n = args.host_shape[0];

  394.   auto c = args.host_shape[1];

  395.   auto h = args.host_shape[2];

  396.   auto w = args.host_shape[3];

  397. 

  398.   size_t nc = ni * n0;

  399.   size_t ncc0 = nc * c0;

  400.   size_t wncc0 = w * ncc0;

  401.   size_t hwncc0 = h * wncc0;

  402.   size_t hw = h * w;

  403.   size_t chw = c * hw;

  404. 

  405.   for (size_t n_idx = 0; n_idx < n; n_idx++) {

  406.     size_t n_head_addr = n_idx * chw;

  407.     for (size_t c_idx = 0; c_idx < c; c_idx++) {

  408.       size_t c_head_addr = n_head_addr + c_idx * hw;

  409.       for (size_t h_idx = 0; h_idx < h; h_idx++) {

  410.         size_t h_head_addr = c_head_addr + h_idx * w;

  411.         for (size_t w_idx = 0; w_idx < w; w_idx++) {

  412.           size_t dst_idx = h_head_addr + w_idx;

  413.           size_t c1_idx = c_idx / c0;

  414.           size_t c0_idx = c_idx % c0;

  415.           size_t nc_idx = n_idx;

  416.           size_t src_idx = c1_idx * hwncc0 + h_idx * wncc0 + w_idx * ncc0 + nc_idx * c0 + c0_idx;

  417.           auto src_offset = src_idx * size;

  418.           auto dst_offset = dst_idx * size;

  419.           auto protected_size = total_size - dst_offset < static_cast<size_t>(SECUREC_MEM_MAX_LEN)

  420.                                   ? total_size - dst_offset

  421.                                   : static_cast<size_t>(SECUREC_MEM_MAX_LEN);

  422.           auto ret = memcpy_s(static_cast<uint8_t *>(result) + dst_offset, protected_size,

  423.                               static_cast<uint8_t const *>(args.data) + src_offset, size);

  424.           if (ret != EOK) {

  425.             MS_LOG(ERROR) << "Failed to operate the dst memory error-code " << ret;

  426.             return false;

  427.           }

  428.         }

  429.       }

  430.     }

  431.   }

  432.   return true;

  433. }

  434. 

  435. bool TransShapeToNz(const std::vector<size_t> &host_shape, std::vector<size_t> *hw_shape) {

  436.   MS_EXCEPTION_IF_NULL(hw_shape);

  437.   if (host_shape.empty()) {

  438.     MS_LOG(ERROR) << "Size of vector is 0.";

  439.     return false;

  440.   }

  441.   switch (host_shape.size()) {

  442.     case 1:

  443.       hw_shape->push_back(1);

  444.       hw_shape->push_back(1);

  445.       hw_shape->push_back(host_shape[0]);

  446.       return true;

  447.     default:

  448.       auto size = host_shape.size();

  449.       if (size < 2) {

  450.         MS_LOG(ERROR) << "Illegal size.";

  451.         return false;

  452.       }

  453.       size_t times = 1;

  454.       for (size_t i = 0; i != size - 2; i++) {

  455.         times *= host_shape[i];

  456.       }

  457.       hw_shape->push_back(times);

  458.       hw_shape->push_back(host_shape[size - 2]);

  459.       hw_shape->push_back(host_shape[size - 1]);

  460.       return true;

  461.   }

  462. }

  463. 

  464. bool NchwToFracNz(const FormatArgs &args, void *result) {

  465.   MS_LOG(DEBUG) << "Trans format from nchw to frac_nz.";

  466.   MS_EXCEPTION_IF_NULL(result);

  467.   std::vector<size_t> hw_shape;

  468.   if (!TransShapeToNz(args.host_shape, &hw_shape)) {

  469.     MS_LOG(ERROR) << "Trans shape failed..";

  470.     return false;

  471.   }

  472.   if (hw_shape.size() < 3 || args.device_shape.size() < 4) {

  473.     MS_LOG(ERROR) << "Invalid shape size.";

  474.     return false;

  475.   }

  476.   auto size = TypeIdSize(args.src_data_type);

  477.   if (size < 1) {

  478.     MS_LOG(ERROR) << "Illegal dtype";

  479.     return false;

  480.   }

  481. 

  482.   auto dst_size = ShapeSize(args.device_shape) * size;

  483.   if (dst_size != args.device_size) {

  484.     MS_LOG(ERROR) << "Illegal total data size, total_size:" << dst_size << ", device_size:" << args.device_size;

  485.     return false;

  486.   }

  487.   auto times = hw_shape.at(0);

  488.   auto h = hw_shape.at(1);

  489.   auto w = hw_shape.at(2);

  490.   auto hw = h * w;

  491. 

  492.   auto shape_size = args.device_shape.size();

  493.   auto w1 = args.device_shape[shape_size - 4];

  494.   auto h1 = args.device_shape[shape_size - 3];

  495.   auto h0 = args.device_shape[shape_size - 2];

  496.   auto w0 = args.device_shape[shape_size - 1];

  497.   auto h1h0w0 = h1 * h0 * w0;

  498.   auto w1h1h0w0 = w1 * h1h0w0;

  499.   auto num_w1 = w / w0;

  500. 

  501.   for (size_t times_idx = 0; times_idx < times; times_idx++) {

  502.     auto times_head = times_idx * w1h1h0w0;

  503.     auto src_times_head = times_idx * hw;

  504.     for (size_t h1h0_idx = 0; h1h0_idx < h; h1h0_idx++) {

  505.       auto h1h0_head = times_head + h1h0_idx * w0;

  506.       auto src_h_head = src_times_head + h1h0_idx * w;

  507.       for (size_t w1_idx = 0; w1_idx < num_w1; w1_idx++) {

  508.         size_t dst_offset = (h1h0_head + w1_idx * h1h0w0) * size;

  509.         size_t src_offset = (src_h_head + w1_idx * w0) * size;

  510.         auto protected_size = dst_size - dst_offset < static_cast<size_t>(SECUREC_MEM_MAX_LEN)

  511.                                 ? dst_size - dst_offset

  512.                                 : static_cast<size_t>(SECUREC_MEM_MAX_LEN);

  513.         auto cp_ret = memcpy_s(static_cast<uint8_t *>(result) + dst_offset, protected_size,

  514.                                static_cast<uint8_t const *>(args.data) + src_offset, size * w0);

  515.         if (cp_ret != EOK) {

  516.           MS_LOG(ERROR) << "Failed to operate the dst memory, error-code " << cp_ret;

  517.           return false;

  518.         }

  519.       }

  520.       auto w1_head = num_w1 * w0;

  521.       for (size_t w0_idx = 0; w1_head + w0_idx < w; w0_idx++) {

  522.         auto src_w_idx = w1_head + w0_idx;

  523.         size_t dst_offset = (h1h0_head + num_w1 * h1h0w0 + w0_idx) * size;

  524.         size_t src_offset = (src_h_head + src_w_idx) * size;

  525.         auto protected_size = dst_size - dst_offset < static_cast<size_t>(SECUREC_MEM_MAX_LEN)

  526.                                 ? dst_size - dst_offset

  527.                                 : static_cast<size_t>(SECUREC_MEM_MAX_LEN);

  528.         auto cp_ret = memcpy_s(static_cast<uint8_t *>(result) + dst_offset, protected_size,

  529.                                static_cast<uint8_t const *>(args.data) + src_offset, size);

  530.         if (cp_ret != EOK) {

  531.           MS_LOG(ERROR) << "Failed to operate the dst memory error-code " << cp_ret;

  532.           return false;

  533.         }

  534.       }

  535.     }

  536.   }

  537.   return true;

  538. }

  539. 

  540. bool FracNzToNchw(const FormatArgs &args, void *result) {

  541.   MS_LOG(DEBUG) << "Trans format from frac_nz to nchw";

  542.   MS_EXCEPTION_IF_NULL(result);

  543.   std::vector<size_t> hw_shape;

  544.   if (!TransShapeToNz(args.host_shape, &hw_shape)) {

  545.     MS_LOG(ERROR) << "Trans shape failed..";

  546.     return false;

  547.   }

  548.   if (hw_shape.size() < 3 || args.device_shape.size() < 4) {

  549.     MS_LOG(ERROR) << "Invalid shape size.";

  550.     return false;

  551.   }

  552.   auto size = TypeIdSize(args.src_data_type);

  553.   if (size < 1) {

  554.     MS_LOG(ERROR) << "Illegal dtype";

  555.     return false;

  556.   }

  557. 

  558.   auto dst_size = ShapeSize(args.device_shape) * size;

  559.   if (dst_size != args.device_size) {

  560.     MS_LOG(ERROR) << "Illegal total data size, total_size:" << dst_size << ", device_size:" << args.device_size;

  561.     return false;

  562.   }

  563.   auto times = hw_shape.at(0);

  564.   auto h = hw_shape.at(1);

  565.   auto w = hw_shape.at(2);

  566.   auto hw = h * w;

  567. 

  568.   auto shape_size = args.device_shape.size();

  569.   auto w1 = args.device_shape[shape_size - 4];

  570.   auto h1 = args.device_shape[shape_size - 3];

  571.   auto h0 = args.device_shape[shape_size - 2];

  572.   auto w0 = args.device_shape[shape_size - 1];

  573.   auto h1h0w0 = h1 * h0 * w0;

  574.   auto w1h1h0w0 = w1 * h1h0w0;

  575.   auto num_w1 = w / w0;

  576. 

  577.   for (size_t times_idx = 0; times_idx < times; times_idx++) {

  578.     auto times_head = times_idx * w1h1h0w0;

  579.     auto src_times_head = times_idx * hw;

  580.     for (size_t h1h0_idx = 0; h1h0_idx < h; h1h0_idx++) {

  581.       auto h1h0_head = times_head + h1h0_idx * w0;

  582.       auto src_h_head = src_times_head + h1h0_idx * w;

  583.       for (size_t w1_idx = 0; w1_idx < num_w1; w1_idx++) {

  584.         size_t src_offset = (h1h0_head + w1_idx * h1h0w0) * size;

  585.         size_t dst_offset = (src_h_head + w1_idx * w0) * size;

  586.         auto protected_size = dst_size - dst_offset < static_cast<size_t>(SECUREC_MEM_MAX_LEN)

  587.                                 ? dst_size - dst_offset

  588.                                 : static_cast<size_t>(SECUREC_MEM_MAX_LEN);

  589.         auto cp_ret = memcpy_s(static_cast<uint8_t *>(result) + dst_offset, protected_size,

  590.                                static_cast<uint8_t const *>(args.data) + src_offset, size * w0);

  591.         if (cp_ret != EOK) {

  592.           MS_LOG(ERROR) << "Failed to operate the dst memory, error-code " << cp_ret;

  593.           return false;

  594.         }

  595.       }

  596.       auto w1_head = num_w1 * w0;

  597.       for (size_t w0_idx = 0; w1_head + w0_idx < w; w0_idx++) {

  598.         auto src_w_idx = w1_head + w0_idx;

  599.         size_t src_offset = (h1h0_head + num_w1 * h1h0w0 + w0_idx) * size;

  600.         size_t dst_offset = (src_h_head + src_w_idx) * size;

  601.         auto protected_size = dst_size - dst_offset < static_cast<size_t>(SECUREC_MEM_MAX_LEN)

  602.                                 ? dst_size - dst_offset

  603.                                 : static_cast<size_t>(SECUREC_MEM_MAX_LEN);

  604.         auto cp_ret = memcpy_s(static_cast<uint8_t *>(result) + dst_offset, protected_size,

  605.                                static_cast<uint8_t const *>(args.data) + src_offset, size);

  606.         if (cp_ret != EOK) {

  607.           MS_LOG(ERROR) << "Failed to operate the dst memory error-code " << cp_ret;

  608.           return false;

  609.         }

  610.       }

  611.     }

  612.   }

  613.   return true;

  614. }

  615. 

  616. bool NchwToNc1hwc0(const FormatArgs &args, void *result) {

  617.   MS_LOG(DEBUG) << "Trans format from nchw to Nc1h1wc0";

  618.   MS_EXCEPTION_IF_NULL(result);

  619.   if (args.host_shape.size() != kNchwDims) {

  620.     MS_LOG(ERROR) << "Invalid host shape, host shape dims:" << args.host_shape.size() << ", expect dims:" << kNchwDims;

  621.     return false;

  622.   }

  623.   size_t size = TypeIdSize(args.src_data_type);

  624.   if (size < 1) {

  625.     MS_LOG(ERROR) << "Illegal dtype.";

  626.     return false;

  627.   }

  628.   auto total_size = ShapeSize(args.device_shape) * size;

  629.   if (total_size != args.device_size) {

  630.     MS_LOG(ERROR) << "Illegal total data size, total_size:" << total_size << ", device_size:" << args.device_size;

  631.     return false;

  632.   }

  633. 

  634.   auto n = args.host_shape[0];

  635.   auto c = args.host_shape[1];

  636.   auto h = args.host_shape[2];

  637.   auto w = args.host_shape[3];

  638.   size_t c0 = CubeSizeByType(args.src_data_type);

  639.   if (c0 < 1) {

  640.     MS_LOG(ERROR) << "Illegal dtype.";

  641.     return false;

  642.   }

  643.   size_t c1 = Ceil(c, c0);

  644.   size_t hw = h * w;

  645.   size_t chw = c * hw;

  646.   size_t c1hwc0 = c1 * hw * c0;

  647.   size_t wc0 = w * c0;

  648. 

  649.   for (size_t n_idx = 0; n_idx < n; n_idx++) {

  650.     size_t n_head_addr = n_idx * c1hwc0;

  651.     for (size_t c1_idx = 0; c1_idx < c1; c1_idx++) {

  652.       size_t c1_head_addr = n_head_addr + c1_idx * hw * c0;

  653.       for (size_t h_idx = 0; h_idx < h; h_idx++) {

  654.         size_t h_head_addr = c1_head_addr + h_idx * wc0;

  655.         for (size_t w_idx = 0; w_idx < w; w_idx++) {

  656.           size_t w_head_addr = h_head_addr + w_idx * c0;

  657.           for (size_t c0_idx = 0; c0_idx < c0; c0_idx++) {

  658.             size_t dst_index = c0_idx + w_head_addr;

  659.             size_t dst_offset = dst_index * size;

  660.             auto protected_size = total_size - dst_offset < static_cast<size_t>(SECUREC_MEM_MAX_LEN)

  661.                                     ? total_size - dst_offset

  662.                                     : static_cast<size_t>(SECUREC_MEM_MAX_LEN);

  663.             size_t c_idx = c0_idx + c1_idx * c0;

  664.             size_t src_idx = n_idx * chw + c_idx * hw + h_idx * w + w_idx;

  665.             auto src_offset = src_idx * size;

  666. 

  667.             if (c_idx < c) {

  668.               auto ret = memcpy_s(static_cast<uint8_t *>(result) + dst_offset, protected_size,

  669.                                   static_cast<uint8_t const *>(args.data) + src_offset, size);

  670.               if (ret != EOK) {

  671.                 MS_LOG(ERROR) << "Failed to operate the dst memory error-code " << ret;

  672.                 return false;

  673.               }

  674.             } else {

  675.               auto ret = memset_s(static_cast<uint8_t *>(result) + dst_offset, protected_size, 0, size);

  676.               if (ret != EOK) {

  677.                 MS_LOG(ERROR) << "Failed to operate the dst memory error-code " << ret;

  678.                 return false;

  679.               }

  680.             }

  681.           }

  682.         }

  683.       }

  684.     }

  685.   }

  686.   return true;

  687. }

  688. 

  689. bool Nc1hwc0ToNchw(const FormatArgs &args, void *result) {

  690.   MS_LOG(DEBUG) << "Trans format from nc1h1wc0 to nchw";

  691.   MS_EXCEPTION_IF_NULL(result);

  692.   if (args.host_shape.size() != kNchwDims) {

  693.     MS_LOG(ERROR) << "Invalid host shape, host shape dims:" << args.host_shape.size() << ", expect dims:" << kNchwDims;

  694.     return false;

  695.   }

  696.   size_t size = TypeIdSize(args.src_data_type);

  697.   if (size < 1) {

  698.     MS_LOG(ERROR) << "Illegal dtype.";

  699.     return false;

  700.   }

  701.   size_t total_size = ShapeSize(args.device_shape) * size;

  702.   if (total_size != args.device_size) {

  703.     MS_LOG(ERROR) << "Illegal total data size, total_size:" << total_size << ", device_size:" << args.device_size;

  704.     return false;

  705.   }

  706. 

  707.   auto n = args.host_shape[0];

  708.   auto c = args.host_shape[1];

  709.   auto h = args.host_shape[2];

  710.   auto w = args.host_shape[3];

  711.   auto c1 = args.device_shape[1];

  712.   auto c0 = args.device_shape[4];

  713. 

  714.   size_t hw = h * w;

  715.   size_t chw = c * hw;

  716.   size_t wc0 = w * c0;

  717.   size_t hwc0 = h * wc0;

  718.   size_t c1hwc0 = c1 * hwc0;

  719. 

  720.   for (size_t n_idx = 0; n_idx < n; n_idx++) {

  721.     size_t n_head_addr = n_idx * chw;

  722.     for (size_t c_idx = 0; c_idx < c; c_idx++) {

  723.       size_t c_head_addr = n_head_addr + c_idx * hw;

  724.       for (size_t h_idx = 0; h_idx < h; h_idx++) {

  725.         size_t h_head_addr = c_head_addr + h_idx * w;

  726.         for (size_t w_idx = 0; w_idx < w; w_idx++) {

  727.           size_t dst_idx = h_head_addr + w_idx;

  728.           size_t c1_idx = c_idx / c0;

  729.           size_t c0_idx = c_idx % c0;

  730.           size_t src_idx = n_idx * c1hwc0 + c1_idx * hwc0 + h_idx * wc0 + w_idx * c0 + c0_idx;

  731.           auto src_offset = src_idx * size;

  732.           auto dst_offset = dst_idx * size;

  733.           auto protected_size = total_size - dst_offset < static_cast<size_t>(SECUREC_MEM_MAX_LEN)

  734.                                   ? total_size - dst_offset

  735.                                   : static_cast<size_t>(SECUREC_MEM_MAX_LEN);

  736.           auto ret = memcpy_s(static_cast<uint8_t *>(result) + dst_offset, protected_size,

  737.                               static_cast<uint8_t const *>(args.data) + src_offset, size);

  738.           if (ret != EOK) {

  739.             MS_LOG(ERROR) << "Failed to operate the dst memory error-code " << ret;

  740.             return false;

  741.           }

  742.         }

  743.       }

  744.     }

  745.   }

  746.   return true;

  747. }

  748. }  // namespace trans

  749. }  // namespace mindspore