m53297601
/
graphengine
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

!987 rectify error codes

Browse Source 
From: @lichun30
Reviewed-by: 
Signed-off-by:
pull/987/MERGE
mindspore-ci-bot 4 years ago committed by Gitee
parent dd85b0a116 f1fd01422a
commit e01821f7b6
50 changed files with 384 additions and 219 deletions
Show Stats Download Patch File Download Diff File

66
ge/common/dump/dump_op.cc
Unescape View File

@ -99,8 +99,8 @@ Status DumpOp::DumpOutput(aicpu::dump::Task &task) {
} }
int64_t output_size = 0; int64_t output_size = 0;
if (TensorUtils::GetTensorSizeInBytes(output_descs.at(i), output_size) != SUCCESS) { if (TensorUtils::GetTensorSizeInBytes(output_descs.at(i), output_size) != SUCCESS) {
GELOGE(PARAM_INVALID, "Get output size filed"); GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "Get output size filed");
return PARAM_INVALID; return ACL_ERROR_GE_INTERNAL_ERROR;
} }
GELOGD("Get output size in lanch dump op is %ld", output_size); GELOGD("Get output size in lanch dump op is %ld", output_size);
output.set_size(output_size); output.set_size(output_size);
@ -126,8 +126,8 @@ Status DumpOp::DumpInput(aicpu::dump::Task &task) {
} }
int64_t input_size = 0; int64_t input_size = 0;
if (TensorUtils::GetTensorSizeInBytes(input_descs.at(i), input_size) != SUCCESS) { if (TensorUtils::GetTensorSizeInBytes(input_descs.at(i), input_size) != SUCCESS) {
GELOGE(PARAM_INVALID, "Get output size filed"); GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "Get output size filed");
return PARAM_INVALID; return ACL_ERROR_GE_INTERNAL_ERROR;
} }
GELOGD("Get input size in lanch dump op is %ld", input_size); GELOGD("Get input size in lanch dump op is %ld", input_size);
input.set_size(input_size); input.set_size(input_size);
@ -151,31 +151,31 @@ Status DumpOp::ExecutorDumpOp(aicpu::dump::OpMappingInfo &op_mapping_info) {
size_t proto_size = op_mapping_info.ByteSizeLong(); size_t proto_size = op_mapping_info.ByteSizeLong();
bool ret = op_mapping_info.SerializeToString(&proto_msg); bool ret = op_mapping_info.SerializeToString(&proto_msg);
if (!ret || proto_size == 0) { if (!ret || proto_size == 0) {
GELOGE(FAILED, "Protobuf serialize failed,proto_size is %zu", proto_size); GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "Protobuf serialize failed, proto_size is %zu", proto_size);
return FAILED; return ACL_ERROR_GE_INTERNAL_ERROR;
} }
rtError_t rt_ret = rtMalloc(&proto_dev_mem_, proto_size, RT_MEMORY_HBM); rtError_t rt_ret = rtMalloc(&proto_dev_mem_, proto_size, RT_MEMORY_HBM);
if (rt_ret != RT_ERROR_NONE) { if (rt_ret != RT_ERROR_NONE) {
GELOGE(RT_FAILED, "Call rtMalloc failed, ret: 0x%X", rt_ret); GELOGE(rt_ret, "Call rtMalloc failed, ret: 0x%X", rt_ret);
return RT_FAILED; return RT_ERROR_TO_GE_STATUS(rt_ret);
} }
rt_ret = rtMemcpy(proto_dev_mem_, proto_size, proto_msg.c_str(), proto_size, RT_MEMCPY_HOST_TO_DEVICE); rt_ret = rtMemcpy(proto_dev_mem_, proto_size, proto_msg.c_str(), proto_size, RT_MEMCPY_HOST_TO_DEVICE);
if (rt_ret != RT_ERROR_NONE) { if (rt_ret != RT_ERROR_NONE) {
GELOGE(RT_FAILED, "Call rtMemcpy failed, ret: 0x%X", rt_ret); GELOGE(rt_ret, "Call rtMemcpy failed, ret: 0x%X", rt_ret);
return RT_FAILED; return RT_ERROR_TO_GE_STATUS(rt_ret);
} }
rt_ret = rtMalloc(&proto_size_dev_mem_, sizeof(size_t), RT_MEMORY_HBM); rt_ret = rtMalloc(&proto_size_dev_mem_, sizeof(size_t), RT_MEMORY_HBM);
if (rt_ret != RT_ERROR_NONE) { if (rt_ret != RT_ERROR_NONE) {
GELOGE(RT_FAILED, "Call rtMalloc failed, ret: 0x%X", rt_ret); GELOGE(rt_ret, "Call rtMalloc failed, ret: 0x%X", rt_ret);
return RT_FAILED; return RT_ERROR_TO_GE_STATUS(rt_ret);
} }
rt_ret = rtMemcpy(proto_size_dev_mem_, sizeof(size_t), &proto_size, sizeof(size_t), RT_MEMCPY_HOST_TO_DEVICE); rt_ret = rtMemcpy(proto_size_dev_mem_, sizeof(size_t), &proto_size, sizeof(size_t), RT_MEMCPY_HOST_TO_DEVICE);
if (rt_ret != RT_ERROR_NONE) { if (rt_ret != RT_ERROR_NONE) {
GELOGE(RT_FAILED, "Call rtMemcpy failed, ret: 0x%X", rt_ret); GELOGE(rt_ret, "Call rtMemcpy failed, ret: 0x%X", rt_ret);
return RT_FAILED; return RT_ERROR_TO_GE_STATUS(rt_ret);
} }
constexpr int32_t io_addr_num = 2; constexpr int32_t io_addr_num = 2;
@ -193,8 +193,8 @@ Status DumpOp::ExecutorDumpOp(aicpu::dump::OpMappingInfo &op_mapping_info) {
nullptr, // no need smDesc nullptr, // no need smDesc
stream_); stream_);
if (rt_ret != RT_ERROR_NONE) { if (rt_ret != RT_ERROR_NONE) {
GELOGE(RT_FAILED, "Call rtCpuKernelLaunch failed,rt_ret:0x%X", rt_ret); GELOGE(rt_ret, "Call rtCpuKernelLaunch failed,rt_ret:0x%X", rt_ret);
return rt_ret; return RT_ERROR_TO_GE_STATUS(rt_ret);
} }
GELOGI("Kernel launch dump op success"); GELOGI("Kernel launch dump op success");
return SUCCESS; return SUCCESS;
@ -204,9 +204,15 @@ Status DumpOp::LaunchDumpOp() {
GELOGI("Start to launch dump op %s", op_desc_->GetName().c_str()); GELOGI("Start to launch dump op %s", op_desc_->GetName().c_str());
int32_t device_id = 0; int32_t device_id = 0;
rtError_t rt_ret = rtGetDevice(&device_id); rtError_t rt_ret = rtGetDevice(&device_id);
if (rt_ret != RT_ERROR_NONE || device_id < 0) { if (rt_ret != RT_ERROR_NONE) {
GELOGE(RT_FAILED, "Call rtGetDevice failed, ret = 0x%X, device_id = %d.", rt_ret, device_id); GELOGE(rt_ret, "Call rtGetDevice failed, ret = 0x%X, device_id = %d.", rt_ret, device_id);
return RT_FAILED; return RT_ERROR_TO_GE_STATUS(rt_ret);
}
if (device_id < 0) {
GELOGE(ACL_ERROR_GE_INTERNAL_ERROR,
"Check device_id failed, device_id = %d, which should be not less than 0.",
device_id);
return ACL_ERROR_GE_INTERNAL_ERROR;
} }
aicpu::dump::OpMappingInfo op_mapping_info; aicpu::dump::OpMappingInfo op_mapping_info;
auto dump_path = dump_properties_.GetDumpPath() + std::to_string(device_id) + "/"; auto dump_path = dump_properties_.GetDumpPath() + std::to_string(device_id) + "/";
@ -232,29 +238,31 @@ Status DumpOp::LaunchDumpOp() {
task.mutable_op()->set_op_name(op_desc_->GetName()); task.mutable_op()->set_op_name(op_desc_->GetName());
task.mutable_op()->set_op_type(op_desc_->GetType()); task.mutable_op()->set_op_type(op_desc_->GetType());
if (dump_properties_.GetDumpMode() == kDumpOutput) { if (dump_properties_.GetDumpMode() == kDumpOutput) {
if (DumpOutput(task) != SUCCESS) { auto ret = DumpOutput(task);
GELOGE(FAILED, "Dump output failed"); if (ret != SUCCESS) {
return FAILED; GELOGE(ret, "Dump output failed");
return ret;
} }
op_mapping_info.mutable_task()->Add(std::move(task)); op_mapping_info.mutable_task()->Add(std::move(task));
} }
if (dump_properties_.GetDumpMode() == kDumpInput) { if (dump_properties_.GetDumpMode() == kDumpInput) {
if (DumpInput(task) != SUCCESS) { auto ret = DumpInput(task);
GELOGE(FAILED, "Dump input failed"); if (ret != SUCCESS) {
return FAILED; GELOGE(ret, "Dump input failed");
return ret;
} }
op_mapping_info.mutable_task()->Add(std::move(task)); op_mapping_info.mutable_task()->Add(std::move(task));
} }
if (dump_properties_.GetDumpMode() == kDumpAll) { if (dump_properties_.GetDumpMode() == kDumpAll) {
auto ret = DumpOutput(task); auto ret = DumpOutput(task);
if (ret != SUCCESS) { if (ret != SUCCESS) {
GELOGE(FAILED, "Dump output failed when in dumping all"); GELOGE(ret, "Dump output failed when in dumping all");
return FAILED; return ret;
} }
ret = DumpInput(task); ret = DumpInput(task);
if (ret != SUCCESS) { if (ret != SUCCESS) {
GELOGE(FAILED, "Dump input failed when in dumping all"); GELOGE(ret, "Dump input failed when in dumping all");
return FAILED; return ret;
} }
op_mapping_info.mutable_task()->Add(std::move(task)); op_mapping_info.mutable_task()->Add(std::move(task));
} }

2
ge/common/formats/format_transfers/format_transfer_c1hwncoc0_hwcn.cc
Unescape View File

@ -162,7 +162,7 @@ Status FormatTransferC1hwncoc0Hwcn::TransFormat(const TransArgs &args, TransResu
Status FormatTransferC1hwncoc0Hwcn::TransShape(Format src_format, const std::vector<int64_t> &src_shape, Status FormatTransferC1hwncoc0Hwcn::TransShape(Format src_format, const std::vector<int64_t> &src_shape,
DataType data_type, Format dst_format, std::vector<int64_t> &dst_shape) { DataType data_type, Format dst_format, std::vector<int64_t> &dst_shape) {
GELOGD("The shape derivation from C1HWNCoC0 to HWCN is not unique. Trans shape in this direction is not supported"); GELOGD("The shape derivation from C1HWNCoC0 to HWCN is not unique. Trans shape in this direction is not supported");
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
} }
REGISTER_FORMAT_TRANSFER(FormatTransferC1hwncoc0Hwcn, FORMAT_C1HWNCoC0, FORMAT_HWCN) REGISTER_FORMAT_TRANSFER(FormatTransferC1hwncoc0Hwcn, FORMAT_C1HWNCoC0, FORMAT_HWCN)

8
ge/common/formats/format_transfers/format_transfer_dhwcn_fracz3D.cc
Unescape View File

@ -32,7 +32,7 @@ Status TransShapeToFz(int64_t d, int64_t n, int64_t c, int64_t h, int64_t w, Dat
std::vector<int64_t> &dst_shape) { std::vector<int64_t> &dst_shape) {
auto c0 = GetCubeSizeByDataType(data_type); auto c0 = GetCubeSizeByDataType(data_type);
if (c0 < 0) { if (c0 < 0) {
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID;
} }
auto c1 = Ceil(c, c0); auto c1 = Ceil(c, c0);
@ -50,7 +50,7 @@ Status TransShapeToFz(int64_t d, int64_t n, int64_t c, int64_t h, int64_t w, Dat
Status TransShapeDhwckToFz3D(const std::vector<int64_t> &src_shape, DataType data_type, Status TransShapeDhwckToFz3D(const std::vector<int64_t> &src_shape, DataType data_type,
std::vector<int64_t> &dst_shape) { std::vector<int64_t> &dst_shape) {
if (!CheckShapeValid(src_shape, kDhwcnDimsNum)) { if (!CheckShapeValid(src_shape, kDhwcnDimsNum)) {
return PARAM_INVALID; return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
} }
auto d = src_shape.at(kDhwcnD); auto d = src_shape.at(kDhwcnD);
auto h = src_shape.at(kDhwcnH); auto h = src_shape.at(kDhwcnH);
@ -163,14 +163,14 @@ Status FormatTransferDhwcnFractalZ3D::TransShape(Format src_format, const std::v
DataType data_type, Format dst_format, DataType data_type, Format dst_format,
std::vector<int64_t> &dst_shape) { std::vector<int64_t> &dst_shape) {
if (CheckDataTypeSupport(data_type) != SUCCESS) { if (CheckDataTypeSupport(data_type) != SUCCESS) {
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID;
} }
if (src_format == FORMAT_DHWCN && dst_format == FORMAT_FRACTAL_Z_3D) { if (src_format == FORMAT_DHWCN && dst_format == FORMAT_FRACTAL_Z_3D) {
return TransShapeDhwckToFz3D(src_shape, data_type, dst_shape); return TransShapeDhwckToFz3D(src_shape, data_type, dst_shape);
} }
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
} }
REGISTER_FORMAT_TRANSFER(FormatTransferDhwcnFractalZ3D, FORMAT_DHWCN, FORMAT_FRACTAL_Z_3D) REGISTER_FORMAT_TRANSFER(FormatTransferDhwcnFractalZ3D, FORMAT_DHWCN, FORMAT_FRACTAL_Z_3D)

8
ge/common/formats/format_transfers/format_transfer_dhwnc_fracz3D_transpose.cc
Unescape View File

@ -32,7 +32,7 @@ Status TransShapeToFz(int64_t d, int64_t n, int64_t c, int64_t h, int64_t w, Dat
std::vector<int64_t> &dst_shape) { std::vector<int64_t> &dst_shape) {
auto c0 = GetCubeSizeByDataType(data_type); auto c0 = GetCubeSizeByDataType(data_type);
if (c0 < 0) { if (c0 < 0) {
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID;
} }
auto c1 = Ceil(c, c0); auto c1 = Ceil(c, c0);
@ -50,7 +50,7 @@ Status TransShapeToFz(int64_t d, int64_t n, int64_t c, int64_t h, int64_t w, Dat
Status TransShapeDhwncToFz3DTranspose(const std::vector<int64_t> &src_shape, DataType data_type, Status TransShapeDhwncToFz3DTranspose(const std::vector<int64_t> &src_shape, DataType data_type,
std::vector<int64_t> &dst_shape) { std::vector<int64_t> &dst_shape) {
if (!CheckShapeValid(src_shape, kDhwncDimsNum)) { if (!CheckShapeValid(src_shape, kDhwncDimsNum)) {
return PARAM_INVALID; return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
} }
auto d = src_shape.at(kDhwncD); auto d = src_shape.at(kDhwncD);
auto h = src_shape.at(kDhwncH); auto h = src_shape.at(kDhwncH);
@ -164,14 +164,14 @@ Status FormatTransferDhwncFractalZ3DTranspose::TransShape(Format src_format, con
DataType data_type, Format dst_format, DataType data_type, Format dst_format,
std::vector<int64_t> &dst_shape) { std::vector<int64_t> &dst_shape) {
if (CheckDataTypeSupport(data_type) != SUCCESS) { if (CheckDataTypeSupport(data_type) != SUCCESS) {
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID;
} }
if (src_format == FORMAT_DHWNC && dst_format == FORMAT_FRACTAL_Z_3D_TRANSPOSE) { if (src_format == FORMAT_DHWNC && dst_format == FORMAT_FRACTAL_Z_3D_TRANSPOSE) {
return TransShapeDhwncToFz3DTranspose(src_shape, data_type, dst_shape); return TransShapeDhwncToFz3DTranspose(src_shape, data_type, dst_shape);
} }
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
} }
REGISTER_FORMAT_TRANSFER(FormatTransferDhwncFractalZ3DTranspose, FORMAT_DHWNC, FORMAT_FRACTAL_Z_3D_TRANSPOSE) REGISTER_FORMAT_TRANSFER(FormatTransferDhwncFractalZ3DTranspose, FORMAT_DHWNC, FORMAT_FRACTAL_Z_3D_TRANSPOSE)

24
ge/common/formats/format_transfers/format_transfer_fractal_nz.cc
Unescape View File

@ -87,8 +87,8 @@ Status TransShapeToFracNz(const ShapeVector &src_shape, DataType data_type, Shap
hw_shape.push_back(DIM_DEFAULT_VALUE); hw_shape.push_back(DIM_DEFAULT_VALUE);
hw_shape.push_back(src_shape[kNdDimIndexN]); hw_shape.push_back(src_shape[kNdDimIndexN]);
if (!IsShapeValid(dst_shape)) { if (!IsShapeValid(dst_shape)) {
GELOGE(PARAM_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str()); GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str());
return PARAM_INVALID; return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
} }
return SUCCESS; return SUCCESS;
default: default:
@ -106,8 +106,8 @@ Status TransShapeToFracNz(const ShapeVector &src_shape, DataType data_type, Shap
hw_shape.push_back(src_shape[size - kNdDimCountBackwardsWH]); hw_shape.push_back(src_shape[size - kNdDimCountBackwardsWH]);
hw_shape.push_back(src_shape[size - kNdDimCountBackwardsW]); hw_shape.push_back(src_shape[size - kNdDimCountBackwardsW]);
if (!IsShapeValid(dst_shape)) { if (!IsShapeValid(dst_shape)) {
GELOGE(PARAM_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str()); GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str());
return PARAM_INVALID; return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
} }
return SUCCESS; return SUCCESS;
} }
@ -299,11 +299,19 @@ Status FormatTransferFractalNz::TransFormat(const TransArgs &args, TransResult &
Status FormatTransferFractalNz::TransShape(Format src_format, const ShapeVector &src_shape, DataType data_type, Status FormatTransferFractalNz::TransShape(Format src_format, const ShapeVector &src_shape, DataType data_type,
Format dst_format, ShapeVector &dst_shape) { Format dst_format, ShapeVector &dst_shape) {
if (!IsDataTypeSupport(data_type) || !CheckShape(src_format, src_shape)) { if (!IsDataTypeSupport(data_type)) {
GELOGE(PARAM_INVALID, "Trans format from %s to %s, src shape %s, data type %s is not supported", GELOGE(ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID,
"Trans format from %s to %s, src shape %s, data type %s is not supported",
TypeUtils::FormatToSerialString(src_format).c_str(), TypeUtils::FormatToSerialString(dst_format).c_str(), TypeUtils::FormatToSerialString(src_format).c_str(), TypeUtils::FormatToSerialString(dst_format).c_str(),
ShapeToString(src_shape).c_str(), TypeUtils::DataTypeToSerialString(data_type).c_str()); ShapeToString(src_shape).c_str(), TypeUtils::DataTypeToSerialString(data_type).c_str());
return PARAM_INVALID; return ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID;
}
if (!CheckShape(src_format, src_shape)) {
GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID,
"Trans format from %s to %s, src shape %s, data type %s is not supported",
TypeUtils::FormatToSerialString(src_format).c_str(), TypeUtils::FormatToSerialString(dst_format).c_str(),
ShapeToString(src_shape).c_str(), TypeUtils::DataTypeToSerialString(data_type).c_str());
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
} }
ShapeVector hw_shape; ShapeVector hw_shape;
return TransShapeToFracNz(src_shape, data_type, dst_shape, hw_shape); return TransShapeToFracNz(src_shape, data_type, dst_shape, hw_shape);
@ -334,7 +342,7 @@ Status FormatTransferFractalNzND::TransShape(Format src_format, const ShapeVecto
Format dst_format, ShapeVector &dst_shape) { Format dst_format, ShapeVector &dst_shape) {
GELOGD("The shape derivation from %s to %s is not unique. Trans shape is not supported", GELOGD("The shape derivation from %s to %s is not unique. Trans shape is not supported",
TypeUtils::FormatToSerialString(src_format).c_str(), TypeUtils::FormatToSerialString(dst_format).c_str()); TypeUtils::FormatToSerialString(src_format).c_str(), TypeUtils::FormatToSerialString(dst_format).c_str());
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
} }
REGISTER_FORMAT_TRANSFER(FormatTransferFractalNz, FORMAT_ND, FORMAT_FRACTAL_NZ) REGISTER_FORMAT_TRANSFER(FormatTransferFractalNz, FORMAT_ND, FORMAT_FRACTAL_NZ)

17
ge/common/formats/format_transfers/format_transfer_fractal_z.cc
Unescape View File

@ -42,7 +42,7 @@ Status CheckDataTypeSupport(DataType data_type) { return GetSizeByDataType(data_
Status TransShapeToFz(int64_t n, int64_t c, int64_t h, int64_t w, DataType data_type, std::vector<int64_t> &dst_shape) { Status TransShapeToFz(int64_t n, int64_t c, int64_t h, int64_t w, DataType data_type, std::vector<int64_t> &dst_shape) {
auto c0 = GetCubeSizeByDataType(data_type); auto c0 = GetCubeSizeByDataType(data_type);
if (c0 < 0) { if (c0 < 0) {
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID;
} }
auto c1 = Ceil(c, c0); auto c1 = Ceil(c, c0);
@ -54,15 +54,16 @@ Status TransShapeToFz(int64_t n, int64_t c, int64_t h, int64_t w, DataType data_
dst_shape.push_back(kNiSize); dst_shape.push_back(kNiSize);
dst_shape.push_back(c0); dst_shape.push_back(c0);
if (!IsShapeValid(dst_shape)) { if (!IsShapeValid(dst_shape)) {
GELOGE(PARAM_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str()); GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID, "Failed to check dst shape %s",
return PARAM_INVALID; ShapeToString(dst_shape).c_str());
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
} }
return SUCCESS; return SUCCESS;
} }
Status TransShapeNchwToFz(const std::vector<int64_t> &src_shape, DataType data_type, std::vector<int64_t> &dst_shape) { Status TransShapeNchwToFz(const std::vector<int64_t> &src_shape, DataType data_type, std::vector<int64_t> &dst_shape) {
if (!CheckShapeValid(src_shape, kNchwDimsNum)) { if (!CheckShapeValid(src_shape, kNchwDimsNum)) {
return PARAM_INVALID; return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
} }
auto n = src_shape.at(kNchwN); auto n = src_shape.at(kNchwN);
@ -74,7 +75,7 @@ Status TransShapeNchwToFz(const std::vector<int64_t> &src_shape, DataType data_t
Status TransShapeHwcnToFz(const std::vector<int64_t> &src_shape, DataType data_type, std::vector<int64_t> &dst_shape) { Status TransShapeHwcnToFz(const std::vector<int64_t> &src_shape, DataType data_type, std::vector<int64_t> &dst_shape) {
if (!CheckShapeValid(src_shape, kHwcnDimsNum)) { if (!CheckShapeValid(src_shape, kHwcnDimsNum)) {
return PARAM_INVALID; return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
} }
auto h = src_shape.at(kHwcnH); auto h = src_shape.at(kHwcnH);
@ -87,7 +88,7 @@ Status TransShapeHwcnToFz(const std::vector<int64_t> &src_shape, DataType data_t
Status TransShapeNhwcToFz(const std::vector<int64_t> &src_shape, DataType data_type, std::vector<int64_t> &dst_shape) { Status TransShapeNhwcToFz(const std::vector<int64_t> &src_shape, DataType data_type, std::vector<int64_t> &dst_shape) {
if (!CheckShapeValid(src_shape, kNhwcDimsNum)) { if (!CheckShapeValid(src_shape, kNhwcDimsNum)) {
return PARAM_INVALID; return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
} }
auto n = src_shape.at(kNhwcN); auto n = src_shape.at(kNhwcN);
@ -369,7 +370,7 @@ Status FormatTransferFractalZ::TransFormat(const TransArgs &args, TransResult &r
Status FormatTransferFractalZ::TransShape(Format src_format, const std::vector<int64_t> &src_shape, DataType data_type, Status FormatTransferFractalZ::TransShape(Format src_format, const std::vector<int64_t> &src_shape, DataType data_type,
Format dst_format, std::vector<int64_t> &dst_shape) { Format dst_format, std::vector<int64_t> &dst_shape) {
if (CheckDataTypeSupport(data_type) != SUCCESS) { if (CheckDataTypeSupport(data_type) != SUCCESS) {
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID;
} }
if (src_format == FORMAT_NHWC && dst_format == FORMAT_FRACTAL_Z) { if (src_format == FORMAT_NHWC && dst_format == FORMAT_FRACTAL_Z) {
@ -382,7 +383,7 @@ Status FormatTransferFractalZ::TransShape(Format src_format, const std::vector<i
return TransShapeNchwToFz(src_shape, data_type, dst_shape); return TransShapeNchwToFz(src_shape, data_type, dst_shape);
} }
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
} }
REGISTER_FORMAT_TRANSFER(FormatTransferFractalZ, FORMAT_NCHW, FORMAT_FRACTAL_Z) REGISTER_FORMAT_TRANSFER(FormatTransferFractalZ, FORMAT_NCHW, FORMAT_FRACTAL_Z)

26
ge/common/formats/format_transfers/format_transfer_fractal_zz.cc
Unescape View File

@ -86,8 +86,9 @@ Status TransShapeToFracZz(const ShapeVector &src_shape, DataType data_type, Shap
hw_shape.push_back(DIM_DEFAULT_VALUE); hw_shape.push_back(DIM_DEFAULT_VALUE);
hw_shape.push_back(src_shape[kNdDimIndexN]); hw_shape.push_back(src_shape[kNdDimIndexN]);
if (!IsShapeValid(dst_shape)) { if (!IsShapeValid(dst_shape)) {
GELOGE(PARAM_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str()); GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID, "Failed to check dst shape %s",
return PARAM_INVALID; ShapeToString(dst_shape).c_str());
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
} }
return SUCCESS; return SUCCESS;
default: default:
@ -105,8 +106,9 @@ Status TransShapeToFracZz(const ShapeVector &src_shape, DataType data_type, Shap
hw_shape.push_back(src_shape[size - kNdDimCountBackwardsWH]); hw_shape.push_back(src_shape[size - kNdDimCountBackwardsWH]);
hw_shape.push_back(src_shape[size - kNdDimCountBackwardsW]); hw_shape.push_back(src_shape[size - kNdDimCountBackwardsW]);
if (!IsShapeValid(dst_shape)) { if (!IsShapeValid(dst_shape)) {
GELOGE(PARAM_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str()); GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID, "Failed to check dst shape %s",
return PARAM_INVALID; ShapeToString(dst_shape).c_str());
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
} }
return SUCCESS; return SUCCESS;
} }
@ -311,11 +313,19 @@ Status FormatTransferFractalZz::TransFormat(const TransArgs &args, TransResult &
Status FormatTransferFractalZz::TransShape(Format src_format, const ShapeVector &src_shape, DataType data_type, Status FormatTransferFractalZz::TransShape(Format src_format, const ShapeVector &src_shape, DataType data_type,
Format dst_format, ShapeVector &dst_shape) { Format dst_format, ShapeVector &dst_shape) {
if (!IsDataTypeSupport(data_type) || !CheckShape(src_format, src_shape)) { if (!IsDataTypeSupport(data_type)) {
GELOGE(PARAM_INVALID, "Not support trans format from %s to %s, src shape %s, data type %s", GELOGE(ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID,
"Not support trans format from %s to %s, src shape %s, data type %s",
TypeUtils::FormatToSerialString(src_format).c_str(), TypeUtils::FormatToSerialString(dst_format).c_str(), TypeUtils::FormatToSerialString(src_format).c_str(), TypeUtils::FormatToSerialString(dst_format).c_str(),
ShapeToString(src_shape).c_str(), TypeUtils::DataTypeToSerialString(data_type).c_str()); ShapeToString(src_shape).c_str(), TypeUtils::DataTypeToSerialString(data_type).c_str());
return PARAM_INVALID; return ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID;
}
if (!CheckShape(src_format, src_shape)) {
GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID,
"Not support trans format from %s to %s, src shape %s, data type %s",
TypeUtils::FormatToSerialString(src_format).c_str(), TypeUtils::FormatToSerialString(dst_format).c_str(),
ShapeToString(src_shape).c_str(), TypeUtils::DataTypeToSerialString(data_type).c_str());
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
} }
ShapeVector hw_shape; ShapeVector hw_shape;
return TransShapeToFracZz(src_shape, data_type, dst_shape, hw_shape); return TransShapeToFracZz(src_shape, data_type, dst_shape, hw_shape);
@ -346,7 +356,7 @@ Status FormatTransferFractalZzND::TransShape(Format src_format, const ShapeVecto
Format dst_format, ShapeVector &dst_shape) { Format dst_format, ShapeVector &dst_shape) {
GELOGD("The shape derivation from %s to %s is not unique. Trans shape is not supported", GELOGD("The shape derivation from %s to %s is not unique. Trans shape is not supported",
TypeUtils::FormatToSerialString(src_format).c_str(), TypeUtils::FormatToSerialString(dst_format).c_str()); TypeUtils::FormatToSerialString(src_format).c_str(), TypeUtils::FormatToSerialString(dst_format).c_str());
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
} }
REGISTER_FORMAT_TRANSFER(FormatTransferFractalZz, FORMAT_ND, FORMAT_FRACTAL_ZZ) REGISTER_FORMAT_TRANSFER(FormatTransferFractalZz, FORMAT_ND, FORMAT_FRACTAL_ZZ)

2
ge/common/formats/format_transfers/format_transfer_fracz_hwcn.cc
Unescape View File

@ -161,7 +161,7 @@ Status FormatTransferFracZHwcn::TransFormat(const TransArgs &args, TransResult &
Status FormatTransferFracZHwcn::TransShape(Format src_format, const std::vector<int64_t> &src_shape, DataType data_type, Status FormatTransferFracZHwcn::TransShape(Format src_format, const std::vector<int64_t> &src_shape, DataType data_type,
Format dst_format, std::vector<int64_t> &dst_shape) { Format dst_format, std::vector<int64_t> &dst_shape) {
GELOGD("The shape derivation from FracZ to HWCN is not unique. Trans shape in this direction is not supported"); GELOGD("The shape derivation from FracZ to HWCN is not unique. Trans shape in this direction is not supported");
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
} }
REGISTER_FORMAT_TRANSFER(FormatTransferFracZHwcn, FORMAT_FRACTAL_Z, FORMAT_HWCN) REGISTER_FORMAT_TRANSFER(FormatTransferFracZHwcn, FORMAT_FRACTAL_Z, FORMAT_HWCN)

2
ge/common/formats/format_transfers/format_transfer_fracz_nchw.cc
Unescape View File

@ -160,7 +160,7 @@ Status FormatTransferFracZNchw::TransFormat(const TransArgs &args, TransResult &
Status FormatTransferFracZNchw::TransShape(Format src_format, const std::vector<int64_t> &src_shape, DataType data_type, Status FormatTransferFracZNchw::TransShape(Format src_format, const std::vector<int64_t> &src_shape, DataType data_type,
Format dst_format, std::vector<int64_t> &dst_shape) { Format dst_format, std::vector<int64_t> &dst_shape) {
GELOGD("The shape derivation from FracZ to NCHW is not unique. Trans shape in this direction is not supported"); GELOGD("The shape derivation from FracZ to NCHW is not unique. Trans shape in this direction is not supported");
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
} }
REGISTER_FORMAT_TRANSFER(FormatTransferFracZNchw, FORMAT_FRACTAL_Z, FORMAT_NCHW) REGISTER_FORMAT_TRANSFER(FormatTransferFracZNchw, FORMAT_FRACTAL_Z, FORMAT_NCHW)

14
ge/common/formats/format_transfers/format_transfer_hwcn_c1hwncoc0.cc
Unescape View File

@ -43,8 +43,9 @@ Status TransShapeHwcnToC1hwncoc0(const DataType &data_type, const std::vector<in
dst_shape.push_back(cube_size); dst_shape.push_back(cube_size);
dst_shape.push_back(cube_size); dst_shape.push_back(cube_size);
if (!CheckShapeValid(dst_shape, kC1hwncoc0DimsNum)) { if (!CheckShapeValid(dst_shape, kC1hwncoc0DimsNum)) {
GELOGE(PARAM_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str()); GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID, "Failed to check dst shape %s",
return PARAM_INVALID; ShapeToString(dst_shape).c_str());
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
} }
return SUCCESS; return SUCCESS;
} }
@ -197,12 +198,15 @@ Status FormatTransferHwcnC1hwncoc0::TransShape(Format src_format, const std::vec
DataType data_type, Format dst_format, std::vector<int64_t> &dst_shape) { DataType data_type, Format dst_format, std::vector<int64_t> &dst_shape) {
if (src_format == FORMAT_HWCN && CheckDataTypeSupported(data_type)) { if (src_format == FORMAT_HWCN && CheckDataTypeSupported(data_type)) {
if (!CheckShapeValid(src_shape, kHwcnDimsNum)) { if (!CheckShapeValid(src_shape, kHwcnDimsNum)) {
GELOGE(PARAM_INVALID, "Failed to check src shape %s", ShapeToString(src_shape).c_str()); GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID, "Failed to check src shape %s",
return PARAM_INVALID; ShapeToString(src_shape).c_str());
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
} }
return TransShapeHwcnToC1hwncoc0(data_type, src_shape, dst_shape); return TransShapeHwcnToC1hwncoc0(data_type, src_shape, dst_shape);
} else if (src_format != FORMAT_HWCN) {
return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
} else { } else {
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID;
} }
} }

2
ge/common/formats/format_transfers/format_transfer_nc1hwc0_nhwc.cc
Unescape View File

@ -157,7 +157,7 @@ Status FormatTransferNc1hwc0Nhwc::TransFormat(const TransArgs &args, TransResult
Status FormatTransferNc1hwc0Nhwc::TransShape(Format src_format, const std::vector<int64_t> &src_shape, Status FormatTransferNc1hwc0Nhwc::TransShape(Format src_format, const std::vector<int64_t> &src_shape,
DataType data_type, Format dst_format, std::vector<int64_t> &dst_shape) { DataType data_type, Format dst_format, std::vector<int64_t> &dst_shape) {
GELOGD("The shape derivation from NC1HWC0 to NHWC is not unique. Trans shape in this direction is not supported"); GELOGD("The shape derivation from NC1HWC0 to NHWC is not unique. Trans shape in this direction is not supported");
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
} }
REGISTER_FORMAT_TRANSFER(FormatTransferNc1hwc0Nhwc, FORMAT_NC1HWC0, FORMAT_NHWC) REGISTER_FORMAT_TRANSFER(FormatTransferNc1hwc0Nhwc, FORMAT_NC1HWC0, FORMAT_NHWC)

13
ge/common/formats/format_transfers/format_transfer_nchw_fz_c04.cc
Unescape View File

@ -45,7 +45,7 @@ Status CheckDataTypeSupport(DataType data_type) { return GetSizeByDataType(data_
Status TransShape(int64_t n, int64_t c, int64_t h, int64_t w, DataType data_type, std::vector<int64_t> &dst_shape) { Status TransShape(int64_t n, int64_t c, int64_t h, int64_t w, DataType data_type, std::vector<int64_t> &dst_shape) {
auto c0 = GetCubeSizeByDataType(data_type); auto c0 = GetCubeSizeByDataType(data_type);
if (c0 < 0) { if (c0 < 0) {
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID;
} }
auto chw = c * h * w; auto chw = c * h * w;
@ -59,8 +59,9 @@ Status TransShape(int64_t n, int64_t c, int64_t h, int64_t w, DataType data_type
dst_shape.push_back(c0); dst_shape.push_back(c0);
if (!IsShapeValid(dst_shape)) { if (!IsShapeValid(dst_shape)) {
GELOGE(PARAM_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str()); GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID, "Failed to check dst shape %s",
return PARAM_INVALID; ShapeToString(dst_shape).c_str());
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
} }
return SUCCESS; return SUCCESS;
} }
@ -68,7 +69,7 @@ Status TransShape(int64_t n, int64_t c, int64_t h, int64_t w, DataType data_type
Status TransShapeNchwToFzC04(const std::vector<int64_t> &src_shape, DataType data_type, Status TransShapeNchwToFzC04(const std::vector<int64_t> &src_shape, DataType data_type,
std::vector<int64_t> &dst_shape) { std::vector<int64_t> &dst_shape) {
if (!CheckShapeValid(src_shape, kNchwDimsNum)) { if (!CheckShapeValid(src_shape, kNchwDimsNum)) {
return PARAM_INVALID; return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
} }
auto n = src_shape.at(kNchwN); auto n = src_shape.at(kNchwN);
@ -293,13 +294,13 @@ Status FormatTransferNchwToFZC04::TransFormat(const TransArgs &args, TransResult
Status FormatTransferNchwToFZC04::TransShape(Format src_format, const std::vector<int64_t> &src_shape, Status FormatTransferNchwToFZC04::TransShape(Format src_format, const std::vector<int64_t> &src_shape,
DataType data_type, Format dst_format, std::vector<int64_t> &dst_shape) { DataType data_type, Format dst_format, std::vector<int64_t> &dst_shape) {
if (CheckDataTypeSupport(data_type) != SUCCESS) { if (CheckDataTypeSupport(data_type) != SUCCESS) {
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID;
} }
if (src_format == FORMAT_NCHW && dst_format == FORMAT_FRACTAL_Z_C04) { if (src_format == FORMAT_NCHW && dst_format == FORMAT_FRACTAL_Z_C04) {
return TransShapeNchwToFzC04(src_shape, data_type, dst_shape); return TransShapeNchwToFzC04(src_shape, data_type, dst_shape);
} }
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
} }
REGISTER_FORMAT_TRANSFER(FormatTransferNchwToFZC04, FORMAT_NCHW, FORMAT_FRACTAL_Z_C04) REGISTER_FORMAT_TRANSFER(FormatTransferNchwToFZC04, FORMAT_NCHW, FORMAT_FRACTAL_Z_C04)

16
ge/common/formats/format_transfers/format_transfer_nchw_nc1hwc0.cc
Unescape View File

@ -32,12 +32,13 @@ Status TransShapeNchwToNc1hwc0(const std::vector<int64_t> &src_shape, DataType d
std::vector<int64_t> &dst_shape) { std::vector<int64_t> &dst_shape) {
int64_t c0 = GetCubeSizeByDataType(data_type); int64_t c0 = GetCubeSizeByDataType(data_type);
if (c0 <= 0) { if (c0 <= 0) {
GELOGE(PARAM_INVALID, "Failed to get cube size, the data type is invalid"); GELOGE(ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID, "Failed to get cube size, the data type is invalid");
return PARAM_INVALID; return ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID;
} }
if (!CheckShapeValid(src_shape, kNchwDimsNum)) { if (!CheckShapeValid(src_shape, kNchwDimsNum)) {
GELOGE(PARAM_INVALID, "Failed to check src shape %s", ShapeToString(src_shape).c_str()); GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID, "Failed to check src shape %s",
return PARAM_INVALID; ShapeToString(src_shape).c_str());
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
} }
dst_shape.clear(); dst_shape.clear();
dst_shape.push_back(src_shape.at(kNchwN)); dst_shape.push_back(src_shape.at(kNchwN));
@ -46,8 +47,9 @@ Status TransShapeNchwToNc1hwc0(const std::vector<int64_t> &src_shape, DataType d
dst_shape.push_back(src_shape.at(kNchwW)); dst_shape.push_back(src_shape.at(kNchwW));
dst_shape.push_back(c0); dst_shape.push_back(c0);
if (!CheckShapeValid(dst_shape, kNc1hwc0DimsNum)) { if (!CheckShapeValid(dst_shape, kNc1hwc0DimsNum)) {
GELOGE(PARAM_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str()); GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID, "Failed to check dst shape %s",
return PARAM_INVALID; ShapeToString(dst_shape).c_str());
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
} }
return SUCCESS; return SUCCESS;
} }
@ -193,7 +195,7 @@ Status FormatTransferNchwNc1hwc0::TransShape(Format src_format, const std::vecto
if (src_format == FORMAT_NCHW) { if (src_format == FORMAT_NCHW) {
return TransShapeNchwToNc1hwc0(src_shape, data_type, dst_shape); return TransShapeNchwToNc1hwc0(src_shape, data_type, dst_shape);
} else { } else {
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
} }
} }

18
ge/common/formats/format_transfers/format_transfer_nhwc_nc1hwc0.cc
Unescape View File

@ -34,8 +34,8 @@ Status TransShapeNhwcToNc1hwc0(const std::vector<int64_t> &src_shape, DataType d
std::vector<int64_t> &dst_shape) { std::vector<int64_t> &dst_shape) {
int64_t c0 = GetCubeSizeByDataType(data_type); int64_t c0 = GetCubeSizeByDataType(data_type);
if (c0 <= 0) { if (c0 <= 0) {
GELOGE(PARAM_INVALID, "Failed to get cube size, the data type is invalid"); GELOGE(ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID, "Failed to get cube size, the data type is invalid");
return PARAM_INVALID; return ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID;
} }
dst_shape.clear(); dst_shape.clear();
dst_shape.push_back(src_shape.at(kNhwcN)); dst_shape.push_back(src_shape.at(kNhwcN));
@ -44,8 +44,9 @@ Status TransShapeNhwcToNc1hwc0(const std::vector<int64_t> &src_shape, DataType d
dst_shape.push_back(src_shape.at(kNhwcW)); dst_shape.push_back(src_shape.at(kNhwcW));
dst_shape.push_back(c0); dst_shape.push_back(c0);
if (!CheckShapeValid(dst_shape, kNc1hwc0DimsNum)) { if (!CheckShapeValid(dst_shape, kNc1hwc0DimsNum)) {
GELOGE(PARAM_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str()); GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID, "Failed to check dst shape %s",
return PARAM_INVALID; ShapeToString(dst_shape).c_str());
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
} }
return SUCCESS; return SUCCESS;
} }
@ -189,12 +190,15 @@ Status FormatTransferNhwcNc1hwc0::TransShape(Format src_format, const std::vecto
DataType data_type, Format dst_format, std::vector<int64_t> &dst_shape) { DataType data_type, Format dst_format, std::vector<int64_t> &dst_shape) {
if (src_format == FORMAT_NHWC && CheckDataTypeSupported(data_type)) { if (src_format == FORMAT_NHWC && CheckDataTypeSupported(data_type)) {
if (!CheckShapeValid(src_shape, kNhwcDimsNum)) { if (!CheckShapeValid(src_shape, kNhwcDimsNum)) {
GELOGE(PARAM_INVALID, "Failed to check src shape %s", ShapeToString(src_shape).c_str()); GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID, "Failed to check src shape %s",
return PARAM_INVALID; ShapeToString(src_shape).c_str());
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
} }
return TransShapeNhwcToNc1hwc0(src_shape, data_type, dst_shape); return TransShapeNhwcToNc1hwc0(src_shape, data_type, dst_shape);
} else if (src_format != FORMAT_NHWC) {
return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
} else { } else {
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID;
} }
} }

10
ge/common/formats/format_transfers/format_transfer_transpose.cc
Unescape View File

@ -211,16 +211,16 @@ Status GetPermByForamt(Format src_format, Format dst_format, std::vector<int64_t
std::string error = "Failed to trans shape, do not support transpose from format " + std::string error = "Failed to trans shape, do not support transpose from format " +
FmtToStr(TypeUtils::FormatToSerialString(src_format)) + " to " + FmtToStr(TypeUtils::FormatToSerialString(src_format)) + " to " +
FmtToStr(TypeUtils::FormatToSerialString(dst_format)); FmtToStr(TypeUtils::FormatToSerialString(dst_format));
GE_ERRORLOG_AND_ERRORMSG(UNSUPPORTED, error.c_str()); GE_ERRORLOG_AND_ERRORMSG(ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID, error.c_str());
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
} }
auto iter = dst_iter->second.find(dst_format); auto iter = dst_iter->second.find(dst_format);
if (iter == dst_iter->second.end()) { if (iter == dst_iter->second.end()) {
std::string error = "Failed to trans shape, do not support transpose from format " + std::string error = "Failed to trans shape, do not support transpose from format " +
FmtToStr(TypeUtils::FormatToSerialString(src_format)) + " to " + FmtToStr(TypeUtils::FormatToSerialString(src_format)) + " to " +
FmtToStr(TypeUtils::FormatToSerialString(dst_format)); FmtToStr(TypeUtils::FormatToSerialString(dst_format));
GE_ERRORLOG_AND_ERRORMSG(UNSUPPORTED, error.c_str()); GE_ERRORLOG_AND_ERRORMSG(ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID, error.c_str());
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
} }
perm = iter->second; perm = iter->second;
return SUCCESS; return SUCCESS;
@ -244,7 +244,7 @@ Status FormatTransferTranspose::TransShape(Format src_format, const std::vector<
std::vector<int64_t> perm_arg; std::vector<int64_t> perm_arg;
GE_CHK_STATUS_RET_NOLOG(GetPermByForamt(src_format, dst_format, perm_arg)); GE_CHK_STATUS_RET_NOLOG(GetPermByForamt(src_format, dst_format, perm_arg));
if (!IsShapeArgValid(src_shape, perm_arg)) { if (!IsShapeArgValid(src_shape, perm_arg)) {
return PARAM_INVALID; return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
} }
dst_shape = TransShapeByPerm(src_shape, perm_arg); dst_shape = TransShapeByPerm(src_shape, perm_arg);
return SUCCESS; return SUCCESS;

4
ge/common/formats/formats.cc
Unescape View File

@ -64,8 +64,8 @@ GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY Status TransShape(Format src_form
std::string error = "Failed to trans data from format " + std::string error = "Failed to trans data from format " +
FmtToStr(TypeUtils::FormatToSerialString(args.src_format)) + " to " + FmtToStr(TypeUtils::FormatToSerialString(args.src_format)) + " to " +
FmtToStr(TypeUtils::FormatToSerialString(args.dst_format)); FmtToStr(TypeUtils::FormatToSerialString(args.dst_format));
GE_ERRORLOG_AND_ERRORMSG(UNSUPPORTED, error.c_str()); GE_ERRORLOG_AND_ERRORMSG(ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID, error.c_str());
return UNSUPPORTED; return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
} }
return transfer->TransShape(src_format, src_shape, data_type, dst_format, dst_shape); return transfer->TransShape(src_format, src_shape, data_type, dst_format, dst_shape);

9
ge/common/ge/plugin_manager.cc
Unescape View File

@ -93,7 +93,7 @@ Status PluginManager::LoadSo(const string &path, const vector<string> &func_chec
std::vector<std::string> path_vec; std::vector<std::string> path_vec;
SplitPath(path, path_vec); SplitPath(path, path_vec);
for (const auto &single_path : path_vec) { for (const auto &single_path : path_vec) {
GE_IF_BOOL_EXEC(single_path.length() >= MMPA_MAX_PATH, GELOGE(GE_PLGMGR_PATH_INVALID, GE_IF_BOOL_EXEC(single_path.length() >= MMPA_MAX_PATH, GELOGE(ACL_ERROR_GE_PLGMGR_PATH_INVALID,
"The shared library file path is too long!"); "The shared library file path is too long!");
continue); continue);
// load break when number of loaded so reach maximum // load break when number of loaded so reach maximum
@ -125,7 +125,8 @@ Status PluginManager::LoadSo(const string &path, const vector<string> &func_chec
GE_IF_BOOL_EXEC(error == nullptr, error = ""); GE_IF_BOOL_EXEC(error == nullptr, error = "");
ErrorManager::GetInstance().ATCReportErrMessage("E19012", {"function", "reason"}, ErrorManager::GetInstance().ATCReportErrMessage("E19012", {"function", "reason"},
{"mmDlopen", "shared library path is " + FmtToStr(file_path_dlopen) + ". Errormessage" + FmtToStr(error)}); {"mmDlopen", "shared library path is " + FmtToStr(file_path_dlopen) + ". Errormessage" + FmtToStr(error)});
GELOGE(GE_PLGMGR_PATH_INVALID, "Failed to dlopen the shared library path[%s]. Errormessage[%s]!", GELOGE(ACL_ERROR_GE_PLGMGR_PATH_INVALID,
"Failed to dlopen the shared library path[%s]. Errormessage[%s]!",
file_path_dlopen.c_str(), error); file_path_dlopen.c_str(), error);
continue; continue;
} }
@ -138,8 +139,8 @@ Status PluginManager::LoadSo(const string &path, const vector<string> &func_chec
ErrorManager::GetInstance().ATCReportErrMessage("E19012", {"function", "reason"}, ErrorManager::GetInstance().ATCReportErrMessage("E19012", {"function", "reason"},
{"mmDlsym", FmtToStr(func_name) + " is skipped since function" + {"mmDlsym", FmtToStr(func_name) + " is skipped since function" +
FmtToStr(func_name) + " is not existed!"}); FmtToStr(func_name) + " is not existed!"});
GELOGE(GE_PLGMGR_PATH_INVALID, "%s is skipped since function %s is not existed!", func_name.c_str(), GELOGE(ACL_ERROR_GE_PLGMGR_PATH_INVALID, "%s is skipped since function %s is not existed!",
func_name.c_str()); func_name.c_str(), func_name.c_str());
is_valid = false; is_valid = false;
break; break;
} }

22
ge/common/helper/model_helper.cc
Unescape View File

@ -479,8 +479,8 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::LoadModel(c
Status status = ge::DavinciModelParser::ParseModelContent(model_data, model_addr_tmp_, model_len_tmp_); Status status = ge::DavinciModelParser::ParseModelContent(model_data, model_addr_tmp_, model_len_tmp_);
if (status != SUCCESS) { if (status != SUCCESS) {
GELOGE(status, "Parse model content failed!"); GELOGE(ACL_ERROR_GE_PARAM_INVALID, "Parse model content failed!");
return status; return ACL_ERROR_GE_PARAM_INVALID;
} }
file_header_ = reinterpret_cast<ModelFileHeader *>(model_data.model_data); file_header_ = reinterpret_cast<ModelFileHeader *>(model_data.model_data);
@ -517,8 +517,8 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::LoadRootMod
} }
if (is_assign_model_) { if (is_assign_model_) {
GELOGE(GE_EXEC_LOAD_MODEL_REPEATED, "Model helper has already loaded!"); GELOGE(ACL_ERROR_GE_EXEC_LOAD_MODEL_REPEATED, "Model helper has already loaded!");
return GE_EXEC_LOAD_MODEL_REPEATED; return ACL_ERROR_GE_EXEC_LOAD_MODEL_REPEATED;
} }
if (ReleaseLocalModelData() != SUCCESS) { if (ReleaseLocalModelData() != SUCCESS) {
@ -528,8 +528,8 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelHelper::LoadRootMod
Status status = ge::DavinciModelParser::ParseModelContent(model_data, model_addr_tmp_, model_len_tmp_); Status status = ge::DavinciModelParser::ParseModelContent(model_data, model_addr_tmp_, model_len_tmp_);
if (status != SUCCESS) { if (status != SUCCESS) {
GELOGE(status, "Parse model content failed!"); GELOGE(ACL_ERROR_GE_PARAM_INVALID, "Parse model content failed!");
return status; return ACL_ERROR_GE_PARAM_INVALID;
} }
file_header_ = reinterpret_cast<ModelFileHeader *>(model_data.model_data); file_header_ = reinterpret_cast<ModelFileHeader *>(model_data.model_data);
@ -609,7 +609,7 @@ Status ModelHelper::GenerateGeRootModel(OmFileLoadHelper &om_load_helper) {
GeModelPtr cur_model = ge::MakeShared<ge::GeModel>(); GeModelPtr cur_model = ge::MakeShared<ge::GeModel>();
Status ret = LoadModelData(om_load_helper, cur_model, mode_index); Status ret = LoadModelData(om_load_helper, cur_model, mode_index);
if (ret != SUCCESS) { if (ret != SUCCESS) {
return GE_EXEC_LOAD_MODEL_PARTITION_FAILED; return ACL_ERROR_GE_EXEC_LOAD_MODEL_PARTITION_FAILED;
} }
if (is_first_model) { if (is_first_model) {
@ -622,22 +622,22 @@ Status ModelHelper::GenerateGeRootModel(OmFileLoadHelper &om_load_helper) {
ret = LoadWeights(om_load_helper, cur_model, mode_index); ret = LoadWeights(om_load_helper, cur_model, mode_index);
if (ret != SUCCESS) { if (ret != SUCCESS) {
return GE_EXEC_LOAD_WEIGHT_PARTITION_FAILED; return ACL_ERROR_GE_EXEC_LOAD_WEIGHT_PARTITION_FAILED;
} }
ret = LoadTBEKernelStore(om_load_helper, cur_model, mode_index); ret = LoadTBEKernelStore(om_load_helper, cur_model, mode_index);
if (ret != SUCCESS) { if (ret != SUCCESS) {
return GE_EXEC_LOAD_KERNEL_PARTITION_FAILED; return ACL_ERROR_GE_EXEC_LOAD_KERNEL_PARTITION_FAILED;
} }
ret = LoadCustAICPUKernelStore(om_load_helper, cur_model, mode_index); ret = LoadCustAICPUKernelStore(om_load_helper, cur_model, mode_index);
if (ret != SUCCESS) { if (ret != SUCCESS) {
return GE_EXEC_LOAD_KERNEL_PARTITION_FAILED; return ACL_ERROR_GE_EXEC_LOAD_KERNEL_PARTITION_FAILED;
} }
ret = LoadTask(om_load_helper, cur_model, mode_index); ret = LoadTask(om_load_helper, cur_model, mode_index);
if (ret != SUCCESS) { if (ret != SUCCESS) {
return GE_EXEC_LOAD_TASK_PARTITION_FAILED; return ACL_ERROR_GE_EXEC_LOAD_TASK_PARTITION_FAILED;
} }
root_model_->SetSubgraphInstanceNameToModel(cur_model->GetName(), cur_model); root_model_->SetSubgraphInstanceNameToModel(cur_model->GetName(), cur_model);
} }

2
ge/common/model_parser/base.cc
Unescape View File

@ -34,7 +34,7 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status ModelParserBase::LoadFro
ge::ModelData &model_data) { ge::ModelData &model_data) {
std::string real_path = RealPath(model_path); std::string real_path = RealPath(model_path);
if (real_path.empty()) { if (real_path.empty()) {
GELOGE(GE_EXEC_MODEL_PATH_INVALID, "Model file path '%s' is invalid", model_path); GELOGE(ACL_ERROR_GE_EXEC_MODEL_PATH_INVALID, "Model file path '%s' is invalid", model_path);
return ACL_ERROR_GE_EXEC_MODEL_PATH_INVALID; return ACL_ERROR_GE_EXEC_MODEL_PATH_INVALID;
} }

2
ge/executor/ge_executor.cc
Unescape View File

@ -226,7 +226,7 @@ Status GeExecutor::Initialize() {
} }
GE_CHK_STATUS_RET(OpsKernelBuilderManager::Instance().Initialize({}, false), GE_CHK_STATUS_RET(OpsKernelBuilderManager::Instance().Initialize({}, false),
"Failed to initialize OpsKernelBuilders"); "Failed to initialize OpsKernelBuilders.");
// Start profiling // Start profiling
Options profiling_options; Options profiling_options;

3
ge/graph/load/model_manager/davinci_model.cc
Unescape View File

@ -621,6 +621,7 @@ void DavinciModel::OpDebugUnRegister() {
// initialize op sequence and call initialization function of each op respectively // initialize op sequence and call initialization function of each op respectively
Status DavinciModel::Init(void *dev_ptr, size_t mem_size, void *weight_ptr, size_t weight_size) { Status DavinciModel::Init(void *dev_ptr, size_t mem_size, void *weight_ptr, size_t weight_size) {
// validating params // validating params
GELOGI("Priority is %d", priority_);
GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(priority_ < 0 || priority_ > 7, return PARAM_INVALID, GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(priority_ < 0 || priority_ > 7, return PARAM_INVALID,
"Priority must between 0-7, now is %d", priority_); "Priority must between 0-7, now is %d", priority_);
GE_CHK_BOOL_RET_STATUS(ge_model_ != nullptr, PARAM_INVALID, "GeModel is null."); GE_CHK_BOOL_RET_STATUS(ge_model_ != nullptr, PARAM_INVALID, "GeModel is null.");
@ -1816,7 +1817,7 @@ Status DavinciModel::InitAippInfo(uint32_t index, const OpDescPtr &op_desc) {
domi::AippOpParams aipp_params; domi::AippOpParams aipp_params;
GeAttrValue::NAMED_ATTRS aipp_attr; GeAttrValue::NAMED_ATTRS aipp_attr;
GE_CHK_BOOL_RET_STATUS(AttrUtils::GetNamedAttrs(op_desc, ATTR_NAME_AIPP, aipp_attr), GE_AIPP_NOT_EXIST, GE_CHK_BOOL_RET_STATUS(AttrUtils::GetNamedAttrs(op_desc, ATTR_NAME_AIPP, aipp_attr), ACL_ERROR_GE_AIPP_NOT_EXIST,
"Data node do not contain param aipp!"); "Data node do not contain param aipp!");
GE_CHK_STATUS_RET(OpUtils::ConvertAippParams(aipp_attr, &aipp_params), "get aipp params failed"); GE_CHK_STATUS_RET(OpUtils::ConvertAippParams(aipp_attr, &aipp_params), "get aipp params failed");
GELOGI("node data: %s, type: %s, current index: %u, current node related input rank: %u", GELOGI("node data: %s, type: %s, current index: %u, current node related input rank: %u",

2
ge/graph/load/model_manager/model_manager.cc
Unescape View File

@ -1428,7 +1428,7 @@ Status ModelManager::GetModelMemAndWeightSize(const ModelData &model, size_t &me
uint8_t *model_data = nullptr; uint8_t *model_data = nullptr;
uint32_t model_len = 0; uint32_t model_len = 0;
Status ret = DavinciModelParser::ParseModelContent(model, model_data, model_len); Status ret = DavinciModelParser::ParseModelContent(model, model_data, model_len);
GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(ret != SUCCESS, return ret, "parse model content failed!"); GE_CHK_BOOL_TRUE_EXEC_WITH_LOG(ret != SUCCESS, return ACL_ERROR_GE_PARAM_INVALID, "parse model content failed!");
OmFileLoadHelper om_file_helper; OmFileLoadHelper om_file_helper;
ret = om_file_helper.Init(model_data, model_len); ret = om_file_helper.Init(model_data, model_len);

6
ge/graph/manager/graph_caching_allocator.cc
Unescape View File

@ -100,14 +100,14 @@ Status CachingAllocator::Initialize(uint32_t device_id) {
} }
auto bin_ptr = new (std::nothrow) BlockBin(BlockComparator); auto bin_ptr = new (std::nothrow) BlockBin(BlockComparator);
if (bin_ptr == nullptr) { if (bin_ptr == nullptr) {
GELOGE(ge::FAILED, "Alloc BlockBin failed."); GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "Alloc BlockBin failed.");
return ge::FAILED; return ACL_ERROR_GE_MEMORY_ALLOCATION;
} }
free_block_bins_[i] = bin_ptr; free_block_bins_[i] = bin_ptr;
} }
memory_allocator_ = MemManager::Instance(memory_type_); memory_allocator_ = MemManager::Instance(memory_type_);
if (memory_allocator_ == nullptr) { if (memory_allocator_ == nullptr) {
return ge::FAILED; return ACL_ERROR_GE_INTERNAL_ERROR;
} }
return ge::SUCCESS; return ge::SUCCESS;
} }

38
ge/graph/manager/graph_mem_allocator.cc
Unescape View File

@ -64,9 +64,10 @@ uint8_t *MemoryAllocator::MallocMemory(const string &purpose, size_t memory_size
Status MemoryAllocator::FreeMemory(uint8_t *memory_addr, uint32_t device_id) const { Status MemoryAllocator::FreeMemory(uint8_t *memory_addr, uint32_t device_id) const {
GELOGI("MemoryAllocator::FreeMemory device_id = %u", device_id); GELOGI("MemoryAllocator::FreeMemory device_id = %u", device_id);
if (rtFree(memory_addr) != RT_ERROR_NONE) { auto rtRet = rtFree(memory_addr);
GELOGE(ge::INTERNAL_ERROR, "MemoryAllocator::MallocMemory device_id = %u", device_id); if (rtRet != RT_ERROR_NONE) {
return ge::INTERNAL_ERROR; GELOGE(rtRet, "MemoryAllocator::MallocMemory device_id = %u", device_id);
return RT_ERROR_TO_GE_STATUS(rtRet);
} }
memory_addr = nullptr; memory_addr = nullptr;
return ge::SUCCESS; return ge::SUCCESS;
@ -168,31 +169,36 @@ Status MemManager::Initialize(const std::vector<rtMemType_t> &memory_type) {
memory_allocator_map_[index] = memory_allocator; memory_allocator_map_[index] = memory_allocator;
GELOGI("Create MemoryAllocator memory type[%u] success.", index); GELOGI("Create MemoryAllocator memory type[%u] success.", index);
} else { } else {
GELOGE(ge::INTERNAL_ERROR, "Alloc MemoryAllocator failed."); GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "Alloc MemoryAllocator failed.");
} }
} else { } else {
memory_allocator = it->second; memory_allocator = it->second;
} }
if (memory_allocator == nullptr) { if (memory_allocator == nullptr) {
GELOGE(ge::INTERNAL_ERROR, "Create MemoryAllocator failed."); GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "Create MemoryAllocator failed.");
return ge::INTERNAL_ERROR; return ACL_ERROR_GE_MEMORY_ALLOCATION;
} else { } else {
memory_allocator->Initialize(0); memory_allocator->Initialize(0);
} }
} }
if (InitAllocator(memory_type, caching_allocator_map_) != SUCCESS) { auto ret = InitAllocator(memory_type, caching_allocator_map_);
GELOGE(ge::INTERNAL_ERROR, "Create CachingAllocator failed."); if (ret != SUCCESS) {
return ge::INTERNAL_ERROR; GELOGE(ret, "Create CachingAllocator failed.");
return ret;
} }
if (InitAllocator(memory_type, rdma_allocator_map_) != SUCCESS) {
GELOGE(ge::INTERNAL_ERROR, "Create RdmaAllocator failed."); ret = InitAllocator(memory_type, rdma_allocator_map_);
return ge::INTERNAL_ERROR; if (ret != SUCCESS) {
GELOGE(ret, "Create RdmaAllocator failed.");
return ret;
} }
if (InitAllocator(memory_type, host_allocator_map_) != SUCCESS) {
GELOGE(ge::INTERNAL_ERROR, "Create HostMemAllocator failed."); ret = InitAllocator(memory_type, host_allocator_map_);
return ge::INTERNAL_ERROR; if (ret != SUCCESS) {
GELOGE(ret, "Create HostMemAllocator failed.");
return ret;
} }
return SUCCESS; return SUCCESS;
} }
@ -229,7 +235,7 @@ MemoryAllocator *MemManager::GetMemoryAllocator(rtMemType_t memory_type) {
// Usually impossible // Usually impossible
if (memory_allocator == nullptr) { if (memory_allocator == nullptr) {
GELOGE(ge::INTERNAL_ERROR, "GetMemoryAllocator failed, memory type is %u.", memory_type); GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "GetMemoryAllocator failed, memory type is %u.", memory_type);
static MemoryAllocator default_memory_allocator(RT_MEMORY_RESERVED); static MemoryAllocator default_memory_allocator(RT_MEMORY_RESERVED);
return &default_memory_allocator; return &default_memory_allocator;
} }

8
ge/graph/manager/graph_mem_allocator.h
Unescape View File

@ -192,18 +192,18 @@ class MemManager {
allocate_map[index] = allocator; allocate_map[index] = allocator;
GELOGI("Create Allocator memory type[%u] success.", index); GELOGI("Create Allocator memory type[%u] success.", index);
} else { } else {
GELOGE(INTERNAL_ERROR, "Alloc Allocator failed."); GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "Alloc Allocator failed.");
} }
} else { } else {
allocator = it->second; allocator = it->second;
} }
if (allocator == nullptr) { if (allocator == nullptr) {
GELOGE(INTERNAL_ERROR, "Create Allocator failed."); GELOGE(ACL_ERROR_GE_MEMORY_ALLOCATION, "Create Allocator failed.");
return INTERNAL_ERROR; return ACL_ERROR_GE_MEMORY_ALLOCATION;
} else { } else {
if (allocator->Initialize() != SUCCESS) { if (allocator->Initialize() != SUCCESS) {
return INTERNAL_ERROR; return ACL_ERROR_GE_INTERNAL_ERROR;
} }
} }
} }

Some files were not shown because too many files have changed in this diff Show More

Write Preview
Loading…
Cancel
Save