zzy34407230
/
mindspore2022
Not watched
1
0
Fork 0
Code
Releases 22 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: a8d81c8b7b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a8d81c8b7b'
${ noResults }
mindspore2022/mindspore/ccsrc/common/trans.cc

1003 lines
37 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 "session/anf_runtime_algorithm.h"

  24. #include "kernel/kernel.h"

  25. #include "device/convert_tensor_utils.h"

  26. #include "utils/convert_utils.h"

  27. #include "utils/log_adapter.h"

  28. #include "utils/utils.h"

  29. 

  30. namespace mindspore {

  31. namespace trans {

  32. namespace {

  33. std::vector<size_t> PaddingShapeTo4dByDefault(const std::vector<size_t> &shape) {

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

  35.   switch (shape.size()) {

  36.     case 0:

  37.       return shape_4d;

  38.     case 1:

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

  40.       break;

  41.     case 2:

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

  43.       shape_4d[2] = shape[1];

  44.       break;

  45.     case 3:

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

  47.       shape_4d[2] = shape[1];

  48.       shape_4d[3] = shape[2];

  49.       break;

  50.     case 4:

  51.       std::copy(shape.begin(), shape.end(), shape_4d.begin());

  52.       break;

  53.     default:

  54.       MS_LOG(EXCEPTION) << "Unexpect shape size = " << shape.size();

  55.   }

  56.   return shape_4d;

  57. }

  58. }  // namespace

  59. const size_t kNchwDims = 4;

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

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

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

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

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

  65. 

  66. template <typename T>

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

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

  69. }

  70. 

  71. enum DataTypeTransMode {

  72.   FROM_FLOAT_TO_FLOAT16,

  73.   FROM_FLOAT_TO_INT32,

  74.   FROM_FLOAT16_TO_FLOAT,

  75.   FROM_FLOAT16_TO_INT32,

  76.   FROM_INT32_TO_FLOAT,

  77.   FROM_INT32_TO_FLOAT16,

  78.   FROM_INT32_TO_UINT8,

  79.   FROM_INT32_TO_INT8,

  80.   FROM_UINT8_TO_FLOAT,

  81.   FROM_UINT8_TO_INT32,

  82.   FROM_INT8_TO_FLOAT,

  83.   FROM_INT8_TO_INT32,

  84.   FROM_INT64_TO_INT32,

  85.   FROM_UINT16_TO_INT32,

  86. };

  87. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  103. 

  104. void CheckMemSize(const TypeIdArgs &args) {

  105.   auto src_type_size = TypeIdSize(args.host_data_type);

  106.   auto dst_type_size = TypeIdSize(args.device_data_type);

  107.   if (src_type_size < 1 || dst_type_size < 1) {

  108.     MS_LOG(EXCEPTION) << "Invalid src or dst data type.";

  109.   }

  110.   if (args.data_size / src_type_size != args.host_shape_size) {

  111.     MS_LOG(EXCEPTION) << "Invalid src or dst data size.";

  112.   }

  113. }

  114. 

  115. template <typename SrcT, typename DstT>

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

  117.   CheckMemSize(args);

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

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

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

  121.   }

  122. }

  123. 

  124. template <typename SrcT>

  125. void TransDataSrc2Fp16(const TypeIdArgs &args, void *dst, const size_t data_size) {

  126.   CheckMemSize(args);

  127.   auto src_data = static_cast<const SrcT *>(args.data);

  128.   auto half_data = static_cast<Eigen::half *>(dst);

  129.   for (size_t i = 0; i < data_size; i++) {

  130.     half_data[i] = Eigen::half(src_data[i]);

  131.   }

  132. }

  133. 

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

  135.   switch (mode) {

  136.     case FROM_FLOAT_TO_FLOAT16:

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

  138.       break;

  139.     case FROM_INT32_TO_FLOAT16:

  140.       TransDataSrc2Fp16<int32_t>(args, dst, data_size);

  141.       break;

  142.     case FROM_FLOAT16_TO_FLOAT:

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

  144.       break;

  145.     case FROM_FLOAT_TO_INT32:

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

  147.       break;

  148.     case FROM_FLOAT16_TO_INT32:

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

  150.       break;

  151.     case FROM_INT32_TO_FLOAT:

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

  153.       break;

  154.     case FROM_INT32_TO_INT8:

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

  156.       break;

  157.     case FROM_INT32_TO_UINT8:

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

  159.       break;

  160.     case FROM_UINT8_TO_INT32:

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

  162.       break;

  163.     case FROM_UINT8_TO_FLOAT:

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

  165.       break;

  166.     case FROM_INT8_TO_FLOAT:

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

  168.       break;

  169.     case FROM_INT8_TO_INT32:

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

  171.       break;

  172.     case FROM_INT64_TO_INT32:

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

  174.       break;

  175.     case FROM_UINT16_TO_INT32:

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

  177.       break;

  178.     default:

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

  180.       return false;

  181.   }

  182.   return true;

  183. }

  184. 

  185. size_t CubeSizeByType(const TypeId data_type) {

  186.   const size_t default_error = 0;

  187.   auto dt_size = TypeIdSize(data_type);

  188.   if (dt_size < 1) {

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

  190.     return default_error;

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

  192.     return kCubeSize * 2;

  193.   }

  194.   return kCubeSize;

  195. }

  196. 

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

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

  199.   return product;

  200. }

  201. 

  202. size_t TypeIdSize(const TypeId data_type) {

  203.   const size_t unsupported_type_error = 0;

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

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

  206.     return iter->second;

  207.   }

  208.   return unsupported_type_error;

  209. }

  210. 

  211. bool IsNeedPadding(const std::string &format, const size_t shape_size) {

  212.   if (shape_size == 0) {

  213.     return false;

  214.   }

  215.   if (format == kOpFormat_DEFAULT || format == kOpFormat_FRAC_NZ) {

  216.     return false;

  217.   } else if (shape_size < 4) {

  218.     return true;

  219.   }

  220.   return false;

  221. }

  222. 

  223. std::vector<int> GetRuntimePaddingShape(const AnfNodePtr &node, size_t index) {

  224.   std::vector<int> shape;

  225.   std::vector<size_t> host_shape;

  226.   if (node->isa<ValueNode>()) {

  227.     auto value_node = node->cast<ValueNodePtr>();

  228.     auto node_value = value_node->value();

  229.     auto tensor = node_value->cast<tensor::TensorPtr>();

  230.     if (tensor == nullptr) {

  231.       MS_LOG(EXCEPTION) << " the node[ " << node->DebugString() << "]'s cannot convert ";

  232.     }

  233.     auto shape_temp = tensor->shape();

  234.     (void)std::transform(shape_temp.begin(), shape_temp.end(), std::back_inserter(host_shape), IntToSize);

  235.     if (host_shape.empty()) {

  236.       host_shape.push_back(1);

  237.     }

  238.   } else {

  239.     host_shape = AnfAlgo::GetOutputInferShape(node, index);

  240.   }

  241.   if (trans::IsNeedPadding(AnfAlgo::GetOutputFormat(node, 0), host_shape.size())) {

  242.     host_shape = trans::PaddingShapeTo4d(host_shape, AnfAlgo::GetOutputReshapeType(node, 0));

  243.   }

  244.   std::transform(host_shape.begin(), host_shape.end(), std::back_inserter(shape), SizeToInt);

  245.   return shape;

  246. }

  247. 

  248. std::vector<size_t> PaddingShapeTo4d(const std::vector<size_t> &shape, const std::vector<kernel::Axis> &padding_axis) {

  249.   if (padding_axis.empty() || shape.size() != padding_axis.size()) {

  250.     return PaddingShapeTo4dByDefault(shape);

  251.   }

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

  253.   for (size_t index = 0; index < padding_axis.size(); index++) {

  254.     shape_4d[padding_axis[index]] = shape[index];

  255.   }

  256.   return shape_4d;

  257. }

  258. 

  259. namespace {

  260. bool CheckDims(const std::vector<size_t> &shape) {

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

  262.     MS_LOG(ERROR) << "Host shape dims shoud be 4";

  263.     return false;

  264.   }

  265.   return true;

  266. }

  267. 

  268. std::vector<size_t> NchwDeviceShape(const std::vector<size_t> &shape) {

  269.   if (!CheckDims(shape)) {

  270.     MS_LOG(EXCEPTION) << "Check dims failed.";

  271.   }

  272.   return shape;

  273. }

  274. 

  275. std::vector<size_t> NhwcDeviceShape(const std::vector<size_t> &shape) {

  276.   if (!CheckDims(shape)) {

  277.     MS_LOG(EXCEPTION) << "Ccheck dims failed.";

  278.   }

  279.   std::vector<size_t> device_shape;

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

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

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

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

  284.   return device_shape;

  285. }

  286. 

  287. std::vector<size_t> HwchDeviceShape(const std::vector<size_t> &shape) {

  288.   if (!CheckDims(shape)) {

  289.     MS_LOG(EXCEPTION) << "Check dims failed.";

  290.   }

  291.   std::vector<size_t> device_shape;

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

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

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

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

  296.   return device_shape;

  297. }

  298. 

  299. std::vector<size_t> FracZDeviceShape(const std::vector<size_t> &shape) {

  300.   if (!CheckDims(shape)) {

  301.     MS_LOG(EXCEPTION) << "Check dims failed.";

  302.   }

  303.   std::vector<size_t> device_shape;

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

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

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

  307.   device_shape.push_back(cout16 / kCubeSize);

  308.   device_shape.push_back(kCubeSize);

  309.   device_shape.push_back(kCubeSize);

  310.   return device_shape;

  311. }

  312. 

  313. std::vector<size_t> Nc1hwc0DeviceShape(const std::vector<size_t> &shape) {

  314.   if (!CheckDims(shape)) {

  315.     MS_LOG(EXCEPTION) << "Check dims failed.";

  316.   }

  317.   std::vector<size_t> device_shape;

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

  319.   size_t C0 = kCubeSize;

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

  321.   device_shape.push_back(C1);

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

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

  324.   device_shape.push_back(C0);

  325.   return device_shape;

  326. }

  327. 

  328. std::vector<size_t> C1hwncoc0DeviceShape(const std::vector<size_t> &shape) {

  329.   if (!CheckDims(shape)) {

  330.     MS_LOG(EXCEPTION) << "Check dims failed.";

  331.   }

  332.   std::vector<size_t> device_shape;

  333.   device_shape.push_back((shape[1] - 1) / kCubeSize + 1);

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

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

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

  337.   device_shape.push_back(kCubeSize);

  338.   device_shape.push_back(kCubeSize);

  339.   return device_shape;

  340. }

  341. }  // namespace

  342. 

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

  344.   using DeviceShapeTransfer = std::function<std::vector<size_t>(const std::vector<size_t> &)>;

  345.   const std::map<std::string, DeviceShapeTransfer> device_shape_map{

  346.     {kOpFormat_NCHW, NchwDeviceShape},       {kOpFormat_NHWC, NhwcDeviceShape},

  347.     {kOpFormat_HWCN, HwchDeviceShape},       {kOpFormat_FRAC_Z, FracZDeviceShape},

  348.     {kOpFormat_NC1HWC0, Nc1hwc0DeviceShape}, {kOpFormat_C1HWNCoC0, C1hwncoc0DeviceShape},

  349.   };

  350. 

  351.   if (format == kOpFormat_ND || format == kOpFormat_DEFAULT) {

  352.     return shape;

  353.   }

  354.   auto temp_shape = shape;

  355.   std::vector<size_t> device_shape;

  356.   if (format == kOpFormat_FRAC_NZ) {

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

  358.       MS_LOG(EXCEPTION) << "Format" << format << " is not support shape " << shape.size();

  359.     } else {

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

  361.     }

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

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

  364.     device_shape.push_back(w1);

  365.     device_shape.push_back(h1);

  366.     device_shape.push_back(kCubeSize);

  367.     device_shape.push_back(kCubeSize);

  368.     return device_shape;

  369.   }

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

  371.     MS_LOG(WARNING) << "Get Device Shape using a shape size is less than 4 ,should be Padding shape by Default firstly";

  372.     temp_shape = PaddingShapeTo4dByDefault(shape);

  373.   }

  374.   auto iter = device_shape_map.find(format);

  375.   if (iter != device_shape_map.end()) {

  376.     return iter->second(temp_shape);

  377.   }

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

  379. }

  380. 

  381. bool CheckArgs(const FormatArgs &args, size_t *size, size_t *total_size) {

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

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

  384.     return false;

  385.   }

  386.   *size = TypeIdSize(args.src_data_type);

  387.   if (*size < 1) {

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

  389.     return false;

  390.   }

  391.   *total_size = ShapeSize(args.device_shape) * (*size);

  392.   if (*total_size != args.device_size) {

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

  394.     return false;

  395.   }

  396.   return true;

  397. }

  398. 

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

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

  401.                 << TypeIdLabel(args.device_data_type);

  402.   MS_EXCEPTION_IF_NULL(result);

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

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

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

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

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

  408.     return false;

  409.   }

  410.   auto trans_mode = iter->second;

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

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

  413.     return false;

  414.   }

  415.   return true;

  416. }

  417. 

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

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

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

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

  422.     return false;

  423.   }

  424.   if (args.device_format == kOpFormat_FRAC_Z) {

  425.     return NchwToFracZ(args, result);

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

  427.     return NchwToFracNz(args, result);

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

  429.     return NchwToNc1hwc0(args, result);

  430.   } else if (args.device_format == kOpFormat_C1HWNCoC0) {

  431.     return NchwToC1hwncoc0(args, result);

  432.   }

  433.   return true;

  434. }

  435. 

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

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

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

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

  440.     return false;

  441.   }

  442.   if (args.device_format == kOpFormat_FRAC_Z) {

  443.     return FracZToNchw(args, result);

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

  445.     return FracNzToNchw(args, result);

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

  447.     return Nc1hwc0ToNchw(args, result);

  448.   } else if (args.device_format == kOpFormat_C1HWNCoC0) {

  449.     return C1hwncoc0ToNchw(args, result);

  450.   }

  451.   return true;

  452. }

  453. 

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

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

  456.   MS_EXCEPTION_IF_NULL(result);

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

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

  459.     return false;

  460.   }

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

  462.   if (size < 1) {

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

  464.     return false;

  465.   }

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

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

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

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

  470. 

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

  472.   if (c0 < 1) {

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

  474.     return false;

  475.   }

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

  477.   size_t hw = h * w;

  478.   size_t chw = c * hw;

  479.   size_t hwc0 = hw * c0;

  480.   size_t nchw = n * chw;

  481. 

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

  483.   size_t vf_cnt = c1 * hw;

  484.   size_t fractal_ele_cnt = c0 * kCubeSize;

  485.   size_t total_ele_cnt = hf_cnt * vf_cnt * fractal_ele_cnt;

  486. 

  487.   size_t dst_size = total_ele_cnt * size;

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

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

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

  491.     return false;

  492.   }

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

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

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

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

  497.       auto src_n_offset = hfi * chw * kCubeSize;

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

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

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

  501.         auto src_row_offset = src_f_offset + row * hw;

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

  503.           auto src_ni = hfi * kCubeSize + col;

  504.           auto src_offset = src_row_offset + chw * col;

  505. 

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

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

  508.           auto offset = idx * size;

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

  510.                                   ? dst_size - offset

  511.                                   : static_cast<size_t>(SECUREC_MEM_MAX_LEN);

  512.           errno_t ret;

  513.           if (need_pad_zero) {

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

  515.           } else {

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

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

  518.           }

  519.           if (ret != 0) {

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

  521.             return false;

  522.           }

  523.         }

  524.       }

  525.     }

  526.   }

  527.   return true;

  528. }

  529. 

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

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

  532.   MS_EXCEPTION_IF_NULL(result);

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

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

  535.     return false;

  536.   }

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

  538.   if (size < 1) {

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

  540.     return false;

  541.   }

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

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

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

  545.     return false;

  546.   }

  547. 

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

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

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

  551. 

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

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

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

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

  556. 

  557.   size_t nc = ni * n0;

  558.   size_t ncc0 = nc * c0;

  559.   size_t wncc0 = w * ncc0;

  560.   size_t hwncc0 = h * wncc0;

  561.   size_t hw = h * w;

  562.   size_t chw = c * hw;

  563. 

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

  565.     size_t n_head_addr = n_idx * chw;

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

  567.       size_t c_head_addr = n_head_addr + c_idx * hw;

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

  569.         size_t h_head_addr = c_head_addr + h_idx * w;

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

  571.           size_t dst_idx = h_head_addr + w_idx;

  572.           size_t c1_idx = c_idx / c0;

  573.           size_t c0_idx = c_idx % c0;

  574.           size_t nc_idx = n_idx;

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

  576.           auto src_offset = src_idx * size;

  577.           auto dst_offset = dst_idx * size;

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

  579.                                   ? total_size - dst_offset

  580.                                   : static_cast<size_t>(SECUREC_MEM_MAX_LEN);

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

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

  583.           if (ret != EOK) {

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

  585.             return false;

  586.           }

  587.         }

  588.       }

  589.     }

  590.   }

  591.   return true;

  592. }

  593. 

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

  595.   MS_EXCEPTION_IF_NULL(hw_shape);

  596.   if (host_shape.empty()) {

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

  598.     return false;

  599.   }

  600.   switch (host_shape.size()) {

  601.     case 1:

  602.       hw_shape->push_back(1);

  603.       hw_shape->push_back(1);

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

  605.       return true;

  606.     default:

  607.       auto size = host_shape.size();

  608.       if (size < 2) {

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

  610.         return false;

  611.       }

  612.       size_t times = 1;

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

  614.         times *= host_shape[i];

  615.       }

  616.       hw_shape->push_back(times);

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

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

  619.       return true;

  620.   }

  621. }

  622. 

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

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

  625.   MS_EXCEPTION_IF_NULL(result);

  626.   std::vector<size_t> hw_shape;

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

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

  629.     return false;

  630.   }

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

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

  633.     return false;

  634.   }

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

  636.   if (size < 1) {

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

  638.     return false;

  639.   }

  640. 

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

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

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

  644.     return false;

  645.   }

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

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

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

  649.   auto hw = h * w;

  650. 

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

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

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

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

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

  656.   auto h1h0w0 = h1 * h0 * w0;

  657.   auto w1h1h0w0 = w1 * h1h0w0;

  658.   auto num_w1 = w / w0;

  659. 

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

  661.     auto times_head = times_idx * w1h1h0w0;

  662.     auto src_times_head = times_idx * hw;

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

  664.       auto h1h0_head = times_head + h1h0_idx * w0;

  665.       auto src_h_head = src_times_head + h1h0_idx * w;

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

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

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

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

  670.                                 ? dst_size - dst_offset

  671.                                 : static_cast<size_t>(SECUREC_MEM_MAX_LEN);

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

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

  674.         if (cp_ret != EOK) {

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

  676.           return false;

  677.         }

  678.       }

  679.       auto w1_head = num_w1 * w0;

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

  681.         auto src_w_idx = w1_head + w0_idx;

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

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

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

  685.                                 ? dst_size - dst_offset

  686.                                 : static_cast<size_t>(SECUREC_MEM_MAX_LEN);

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

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

  689.         if (cp_ret != EOK) {

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

  691.           return false;

  692.         }

  693.       }

  694.     }

  695.   }

  696.   return true;

  697. }

  698. 

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

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

  701.   MS_EXCEPTION_IF_NULL(result);

  702.   std::vector<size_t> hw_shape;

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

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

  705.     return false;

  706.   }

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

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

  709.     return false;

  710.   }

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

  712.   if (size < 1) {

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

  714.     return false;

  715.   }

  716. 

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

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

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

  720.     return false;

  721.   }

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

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

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

  725.   auto hw = h * w;

  726. 

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

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

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

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

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

  732.   auto h1h0w0 = h1 * h0 * w0;

  733.   auto w1h1h0w0 = w1 * h1h0w0;

  734.   auto num_w1 = w / w0;

  735. 

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

  737.     auto times_head = times_idx * w1h1h0w0;

  738.     auto src_times_head = times_idx * hw;

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

  740.       auto h1h0_head = times_head + h1h0_idx * w0;

  741.       auto src_h_head = src_times_head + h1h0_idx * w;

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

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

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

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

  746.                                 ? dst_size - dst_offset

  747.                                 : static_cast<size_t>(SECUREC_MEM_MAX_LEN);

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

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

  750.         if (cp_ret != EOK) {

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

  752.           return false;

  753.         }

  754.       }

  755.       auto w1_head = num_w1 * w0;

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

  757.         auto src_w_idx = w1_head + w0_idx;

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

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

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

  761.                                 ? dst_size - dst_offset

  762.                                 : static_cast<size_t>(SECUREC_MEM_MAX_LEN);

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

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

  765.         if (cp_ret != EOK) {

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

  767.           return false;

  768.         }

  769.       }

  770.     }

  771.   }

  772.   return true;

  773. }

  774. 

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

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

  777.   MS_EXCEPTION_IF_NULL(result);

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

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

  780.     return false;

  781.   }

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

  783.   if (size < 1) {

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

  785.     return false;

  786.   }

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

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

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

  790.     return false;

  791.   }

  792. 

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

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

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

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

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

  798.   if (c0 < 1) {

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

  800.     return false;

  801.   }

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

  803.   size_t hw = h * w;

  804.   size_t chw = c * hw;

  805.   size_t c1hwc0 = c1 * hw * c0;

  806.   size_t wc0 = w * c0;

  807. 

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

  809.     size_t n_head_addr = n_idx * c1hwc0;

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

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

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

  813.         size_t h_head_addr = c1_head_addr + h_idx * wc0;

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

  815.           size_t w_head_addr = h_head_addr + w_idx * c0;

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

  817.             size_t dst_index = c0_idx + w_head_addr;

  818.             size_t dst_offset = dst_index * size;

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

  820.                                     ? total_size - dst_offset

  821.                                     : static_cast<size_t>(SECUREC_MEM_MAX_LEN);

  822.             size_t c_idx = c0_idx + c1_idx * c0;

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

  824.             auto src_offset = src_idx * size;

  825. 

  826.             if (c_idx < c) {

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

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

  829.               if (ret != EOK) {

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

  831.                 return false;

  832.               }

  833.             } else {

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

  835.               if (ret != EOK) {

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

  837.                 return false;

  838.               }

  839.             }

  840.           }

  841.         }

  842.       }

  843.     }

  844.   }

  845.   return true;

  846. }

  847. 

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

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

  850.   MS_EXCEPTION_IF_NULL(result);

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

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

  853.     return false;

  854.   }

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

  856.   if (size < 1) {

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

  858.     return false;

  859.   }

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

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

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

  863.     return false;

  864.   }

  865. 

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

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

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

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

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

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

  872. 

  873.   size_t hw = h * w;

  874.   size_t chw = c * hw;

  875.   size_t wc0 = w * c0;

  876.   size_t hwc0 = h * wc0;

  877.   size_t c1hwc0 = c1 * hwc0;

  878. 

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

  880.     size_t n_head_addr = n_idx * chw;

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

  882.       size_t c_head_addr = n_head_addr + c_idx * hw;

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

  884.         size_t h_head_addr = c_head_addr + h_idx * w;

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

  886.           size_t dst_idx = h_head_addr + w_idx;

  887.           size_t c1_idx = c_idx / c0;

  888.           size_t c0_idx = c_idx % c0;

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

  890.           auto src_offset = src_idx * size;

  891.           auto dst_offset = dst_idx * size;

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

  893.                                   ? total_size - dst_offset

  894.                                   : static_cast<size_t>(SECUREC_MEM_MAX_LEN);

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

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

  897.           if (ret != EOK) {

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

  899.             return false;

  900.           }

  901.         }

  902.       }

  903.     }

  904.   }

  905.   return true;

  906. }

  907. 

  908. bool NchwToC1hwncoc0(const FormatArgs &args, void *result) {

  909.   // trans nchw to c1hwncoc0

  910.   MS_LOG(DEBUG) << "Trans format from nchw to c1hwncoc0.";

  911.   MS_EXCEPTION_IF_NULL(result);

  912.   size_t size = 0;

  913.   size_t total_size = 0;

  914.   if (!CheckArgs(args, &size, &total_size)) {

  915.     MS_LOG(ERROR) << "Check args failed.";

  916.     return false;

  917.   }

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

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

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

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

  922.   auto c1 = args.device_shape[0];

  923.   auto co = args.device_shape[4];

  924.   auto c0 = args.device_shape[5];

  925.   for (size_t c1_i = 0; c1_i < c1; c1_i++) {

  926.     for (size_t h_i = 0; h_i < h; h_i++) {

  927.       for (size_t w_i = 0; w_i < w; w_i++) {

  928.         for (size_t n_i = 0; n_i < n; n_i++) {

  929.           for (size_t co_i = 0; co_i < co; co_i++) {

  930.             for (size_t c0_i = 0; c0_i < c0; c0_i++) {

  931.               size_t dst_offset = (c1_i * h * w * n * co * c0 + h_i * w * n * co * c0 + w_i * n * co * c0 +

  932.                                    n_i * co * c0 + co_i * c0 + c0_i) *

  933.                                   size;

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

  935.                                         ? total_size - dst_offset

  936.                                         : static_cast<size_t>(SECUREC_MEM_MAX_LEN);

  937.               size_t c_i = c0_i + c1_i * c0;

  938.               size_t src_offset = (n_i * c * h * w + c_i * h * w + h_i * w + w_i) * size;

  939.               errno_t ret;

  940.               if (c_i < c && c0_i == co_i) {

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

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

  943.               } else {

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

  945.               }

  946.               if (ret != EOK) {

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

  948.                 return false;

  949.               }

  950.             }

  951.           }

  952.         }

  953.       }

  954.     }

  955.   }

  956.   return true;

  957. }

  958. 

  959. bool C1hwncoc0ToNchw(const FormatArgs &args, void *result) {

  960.   // trans c1hwncoc0 to nchw

  961.   MS_LOG(DEBUG) << "Trans format from c1hwncoc0 to nchw";

  962.   MS_EXCEPTION_IF_NULL(result);

  963.   size_t size = 0;

  964.   size_t total_size = 0;

  965.   if (!CheckArgs(args, &size, &total_size)) {

  966.     MS_LOG(ERROR) << "Check args failed.";

  967.     return false;

  968.   }

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

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

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

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

  973.   auto co = args.device_shape[4];

  974.   auto c0 = args.device_shape[5];

  975.   for (size_t n_i = 0; n_i < n; n_i++) {

  976.     for (size_t c_i = 0; c_i < c; c_i++) {

  977.       for (size_t h_i = 0; h_i < h; h_i++) {

  978.         for (size_t w_i = 0; w_i < w; w_i++) {

  979.           size_t dst_offset = (n_i * c * h * w + c_i * h * w + h_i * w + w_i) * size;

  980.           size_t c1_i = c_i / kCubeSize;

  981.           size_t c0_i = c_i % kCubeSize;

  982.           size_t co_i = c0_i;

  983.           size_t src_offset = (c1_i * h * w * n * co * c0 + h_i * w * n * co * c0 + w_i * n * co * c0 + n_i * co * c0 +

  984.                                co_i * c0 + c0_i) *

  985.                               size;

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

  987.                                     ? total_size - dst_offset

  988.                                     : static_cast<size_t>(SECUREC_MEM_MAX_LEN);

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

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

  991.           if (ret != EOK) {

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

  993.             return false;

  994.           }

  995.         }

  996.       }

  997.     }

  998.   }

  999.   return true;

  1000. }

  1001. }  // namespace trans

  1002. }  // namespace mindspore