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

rectify error codes

Browse Source
pull/987/head
lichun 4 years ago
parent 435795139f
commit 2249f2804f
38 changed files with 267 additions and 192 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_DUMP_GET_TENSOR_SIZE_FAILED, "Get output size filed");
return PARAM_INVALID; return ACL_ERROR_GE_DUMP_GET_TENSOR_SIZE_FAILED;
} }
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_DUMP_GET_TENSOR_SIZE_FAILED, "Get output size filed");
return PARAM_INVALID; return ACL_ERROR_GE_DUMP_GET_TENSOR_SIZE_FAILED;
} }
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_DUMP_PROTOBUF_SERIALIZE_FAILED, "Protobuf serialize failed, proto_size is %zu", proto_size);
return FAILED; return ACL_ERROR_GE_DUMP_PROTOBUF_SERIALIZE_FAILED;
} }
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_CHECK_RTS_RETURN_VALUE_FAILED,
"Check device_id failed, device_id = %d, which should be not less than 0.",
device_id);
return ACL_ERROR_GE_CHECK_RTS_RETURN_VALUE_FAILED;
} }
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;
} }

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;

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_INIT_ALLOCATOR_FAILED;
} }
} }
} }

2
ge/graph/manager/rdma_pool_allocator.cc
Unescape View File

@ -51,7 +51,7 @@ RdmaPoolAllocator::RdmaPoolAllocator(rtMemType_t memory_type)
Status RdmaPoolAllocator::Initialize() { Status RdmaPoolAllocator::Initialize() {
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;
} }

29
ge/hybrid/node_executor/aicpu/aicpu_ext_info.cc
Unescape View File

@ -29,8 +29,9 @@ constexpr int64_t kDimEndFlag = INT64_MIN;
Status AicpuExtInfoHandler::Parse(const std::string &ext_info) { Status AicpuExtInfoHandler::Parse(const std::string &ext_info) {
GELOGI("Node[%s] parse ext info start.", node_name_.c_str()); GELOGI("Node[%s] parse ext info start.", node_name_.c_str());
if (ext_info.empty()) { if (ext_info.empty()) {
GELOGE(PARAM_INVALID, "Node[%s] parse ext info failed as ext info is empty.", node_name_.c_str()); GELOGE(ACL_ERROR_GE_PARAM_INVALID, "Node[%s] parse ext info failed as ext info is empty.",
return PARAM_INVALID; node_name_.c_str());
return ACL_ERROR_GE_PARAM_INVALID;
} }
ext_info_len_ = ext_info.size(); ext_info_len_ = ext_info.size();
@ -38,8 +39,8 @@ Status AicpuExtInfoHandler::Parse(const std::string &ext_info) {
GE_CHECK_NOTNULL(ext_info_); GE_CHECK_NOTNULL(ext_info_);
if (memcpy_s(ext_info_.get(), ext_info_len_, ext_info.c_str(), ext_info.size()) != EOK) { if (memcpy_s(ext_info_.get(), ext_info_len_, ext_info.c_str(), ext_info.size()) != EOK) {
GELOGE(FAILED, "[%s] Failed to coy ext info", node_name_.c_str()); GELOGE(ACL_ERROR_GE_MEMORY_OPERATE_FAILED, "[%s] Failed to coy ext info", node_name_.c_str());
return FAILED; return ACL_ERROR_GE_MEMORY_OPERATE_FAILED;
} }
input_shape_and_type_.clear(); input_shape_and_type_.clear();
@ -72,7 +73,7 @@ Status AicpuExtInfoHandler::Parse(const std::string &ext_info) {
offset += aicpu_ext_info->infoLen; offset += aicpu_ext_info->infoLen;
} }
GE_CHK_BOOL_RET_STATUS(offset == ext_info_len_, PARAM_INVALID, GE_CHK_BOOL_RET_STATUS(offset == ext_info_len_, ACL_ERROR_GE_PARAM_INVALID,
"Node[%s] ext_info format error, parse not reach end, offset=%zu, ext_info_len=%zu.", "Node[%s] ext_info format error, parse not reach end, offset=%zu, ext_info_len=%zu.",
node_name_.c_str(), offset, ext_info_len_); node_name_.c_str(), offset, ext_info_len_);
GELOGI("Node[%s] parse ext info end.", node_name_.c_str()); GELOGI("Node[%s] parse ext info end.", node_name_.c_str());
@ -80,13 +81,13 @@ Status AicpuExtInfoHandler::Parse(const std::string &ext_info) {
} }
Status AicpuExtInfoHandler::ParseExtShapeType(AicpuExtInfo *aicpu_ext_info) { Status AicpuExtInfoHandler::ParseExtShapeType(AicpuExtInfo *aicpu_ext_info) {
GE_CHK_BOOL_RET_STATUS(aicpu_ext_info->infoLen == sizeof(int32_t), PARAM_INVALID, GE_CHK_BOOL_RET_STATUS(aicpu_ext_info->infoLen == sizeof(int32_t), ACL_ERROR_GE_PARAM_INVALID,
"Node[%s] parse ext shape type failed as infoLen must be %zu but %u.", "Node[%s] parse ext shape type failed as infoLen must be %zu but %u.",
node_name_.c_str(), sizeof(int32_t), aicpu_ext_info->infoLen); node_name_.c_str(), sizeof(int32_t), aicpu_ext_info->infoLen);
auto type = reinterpret_cast<const int32_t *>(aicpu_ext_info->infoMsg); auto type = reinterpret_cast<const int32_t *>(aicpu_ext_info->infoMsg);
GE_CHK_BOOL_RET_STATUS(*type == unknown_type_, PARAM_INVALID, GE_CHK_BOOL_RET_STATUS(*type == unknown_type_, ACL_ERROR_GE_PARAM_INVALID,
"Node[%s] parse ext shape type failed as need %d but %d.", "Node[%s] parse ext shape type failed as need %d but %d.",
node_name_.c_str(), unknown_type_, *type); node_name_.c_str(), unknown_type_, *type);
GELOGI("Node[%s] parse ext shape type success infoLen=%u.", node_name_.c_str(), aicpu_ext_info->infoLen); GELOGI("Node[%s] parse ext shape type success infoLen=%u.", node_name_.c_str(), aicpu_ext_info->infoLen);
@ -95,7 +96,7 @@ Status AicpuExtInfoHandler::ParseExtShapeType(AicpuExtInfo *aicpu_ext_info) {
Status AicpuExtInfoHandler::ParseExtInputShape(AicpuExtInfo *aicpu_ext_info) { Status AicpuExtInfoHandler::ParseExtInputShape(AicpuExtInfo *aicpu_ext_info) {
auto need_len = input_num_ * sizeof(AicpuShapeAndType); auto need_len = input_num_ * sizeof(AicpuShapeAndType);
GE_CHK_BOOL_RET_STATUS(aicpu_ext_info->infoLen == need_len, PARAM_INVALID, GE_CHK_BOOL_RET_STATUS(aicpu_ext_info->infoLen == need_len, ACL_ERROR_GE_PARAM_INVALID,
"Node[%s] parse ext input shape failed as infoLen must be " "Node[%s] parse ext input shape failed as infoLen must be "
"input_num[%u]*sizeof(ShapeAndType)[%zu] but %u.", "input_num[%u]*sizeof(ShapeAndType)[%zu] but %u.",
node_name_.c_str(), input_num_, sizeof(AicpuShapeAndType), aicpu_ext_info->infoLen); node_name_.c_str(), input_num_, sizeof(AicpuShapeAndType), aicpu_ext_info->infoLen);
@ -116,7 +117,7 @@ Status AicpuExtInfoHandler::ParseExtOutputShape(AicpuExtInfo *aicpu_ext_info) {
return SUCCESS; return SUCCESS;
} }
auto need_len = output_num_ * sizeof(AicpuShapeAndType); auto need_len = output_num_ * sizeof(AicpuShapeAndType);
GE_CHK_BOOL_RET_STATUS(aicpu_ext_info->infoLen == need_len, PARAM_INVALID, GE_CHK_BOOL_RET_STATUS(aicpu_ext_info->infoLen == need_len, ACL_ERROR_GE_PARAM_INVALID,
"Node[%s] parse ext output shape failed as infoLen must be " "Node[%s] parse ext output shape failed as infoLen must be "
"output_num[%u]*sizeof(ShapeAndType)[%zu] but %u.", "output_num[%u]*sizeof(ShapeAndType)[%zu] but %u.",
node_name_.c_str(), output_num_, sizeof(AicpuShapeAndType), aicpu_ext_info->infoLen); node_name_.c_str(), output_num_, sizeof(AicpuShapeAndType), aicpu_ext_info->infoLen);
@ -130,7 +131,7 @@ Status AicpuExtInfoHandler::ParseExtOutputShape(AicpuExtInfo *aicpu_ext_info) {
} }
Status AicpuExtInfoHandler::ParseExtSessionInfo(AicpuExtInfo *aicpu_ext_info) { Status AicpuExtInfoHandler::ParseExtSessionInfo(AicpuExtInfo *aicpu_ext_info) {
GE_CHK_BOOL_RET_STATUS(aicpu_ext_info->infoLen == sizeof(AicpuSessionInfo), PARAM_INVALID, GE_CHK_BOOL_RET_STATUS(aicpu_ext_info->infoLen == sizeof(AicpuSessionInfo), ACL_ERROR_GE_PARAM_INVALID,
"Node[%s] parse ext session info failed as infoLen must be %zu but %u.", "Node[%s] parse ext session info failed as infoLen must be %zu but %u.",
node_name_.c_str(), sizeof(SessionInfo), aicpu_ext_info->infoLen); node_name_.c_str(), sizeof(SessionInfo), aicpu_ext_info->infoLen);
@ -173,7 +174,7 @@ Status AicpuExtInfoHandler::UpdateInputShapeAndType(uint32_t input_index, const
} }
Status AicpuExtInfoHandler::UpdateOutputShapeAndType(uint32_t output_index, const GeTensorDesc &output_desc) { Status AicpuExtInfoHandler::UpdateOutputShapeAndType(uint32_t output_index, const GeTensorDesc &output_desc) {
GE_CHK_BOOL_RET_STATUS((unknown_type_ != DEPEND_COMPUTE), INTERNAL_ERROR, GE_CHK_BOOL_RET_STATUS((unknown_type_ != DEPEND_COMPUTE), ACL_ERROR_GE_INTERNAL_ERROR,
"Node[%s] is depend compute is no need update output shape and type by ext.", "Node[%s] is depend compute is no need update output shape and type by ext.",
node_name_.c_str()); node_name_.c_str());
GE_CHECK_LE(output_index, output_num_); GE_CHECK_LE(output_index, output_num_);
@ -183,7 +184,7 @@ Status AicpuExtInfoHandler::UpdateOutputShapeAndType(uint32_t output_index, cons
if (unknown_type_ == DEPEND_SHAPE_RANGE) { if (unknown_type_ == DEPEND_SHAPE_RANGE) {
std::vector<std::pair<int64_t, int64_t>> range; std::vector<std::pair<int64_t, int64_t>> range;
auto range_ret = output_desc.GetShapeRange(range); auto range_ret = output_desc.GetShapeRange(range);
GE_CHK_BOOL_RET_STATUS(range_ret == GRAPH_SUCCESS, INTERNAL_ERROR, GE_CHK_BOOL_RET_STATUS(range_ret == GRAPH_SUCCESS, ACL_ERROR_GE_INTERNAL_ERROR,
"Node[%s] is shape range type but get GetShapeRange failed, ret=%u.", "Node[%s] is shape range type but get GetShapeRange failed, ret=%u.",
node_name_.c_str(), range_ret); node_name_.c_str(), range_ret);
for (size_t k = 0; k < range.size(); ++k) { for (size_t k = 0; k < range.size(); ++k) {
@ -210,9 +211,9 @@ Status AicpuExtInfoHandler::UpdateShapeAndType(const GeShape &shape, DataType da
AicpuShapeAndType *shape_and_type) { AicpuShapeAndType *shape_and_type) {
auto dim_num = shape.GetDimNum(); auto dim_num = shape.GetDimNum();
if (dim_num > aicpu::FWKAdapter::kMaxShapeDims) { if (dim_num > aicpu::FWKAdapter::kMaxShapeDims) {
GELOGE(PARAM_INVALID, "Update shape and type failed, as dim_num %zu is over max shape dims %u.", GELOGE(ACL_ERROR_GE_PARAM_INVALID, "Update shape and type failed, as dim_num %zu is over max shape dims %u.",
dim_num, aicpu::FWKAdapter::kMaxShapeDims); dim_num, aicpu::FWKAdapter::kMaxShapeDims);
return PARAM_INVALID; return ACL_ERROR_GE_PARAM_INVALID;
} }
size_t index = 0; size_t index = 0;
for (; index < dim_num; ++index) { for (; index < dim_num; ++index) {

7
ge/single_op/single_op.cc
Unescape View File

@ -57,9 +57,10 @@ Status ProfilingTaskInfo(OpTask *op_task, const string &shape_type) {
std::vector<TaskDescInfo> task_desc_info; std::vector<TaskDescInfo> task_desc_info;
uint32_t task_id = 0; uint32_t task_id = 0;
uint32_t stream_id = 0; uint32_t stream_id = 0;
if (rtGetTaskIdAndStreamID(&task_id, &stream_id) != RT_ERROR_NONE) { auto rt_ret = rtGetTaskIdAndStreamID(&task_id, &stream_id);
GELOGE(ACL_ERROR_GE_PARAM_INVALID, "Get task_id and stream_id failed."); if (rt_ret != RT_ERROR_NONE) {
return ACL_ERROR_GE_PARAM_INVALID; GELOGE(rt_ret, "Get task_id and stream_id failed.");
return RT_ERROR_TO_GE_STATUS(rt_ret);
} }
TaskDescInfo tmp_task_desc_info; TaskDescInfo tmp_task_desc_info;

2
ge/single_op/single_op_manager.cc
Unescape View File

@ -141,7 +141,7 @@ Status SingleOpManager::GetResourceId(rtStream_t stream, uintptr_t &resource_id)
auto rt_err = rtCtxGetCurrent(&rt_cur_ctx); auto rt_err = rtCtxGetCurrent(&rt_cur_ctx);
if (rt_err != RT_ERROR_NONE) { if (rt_err != RT_ERROR_NONE) {
GELOGE(rt_err, "get current context failed, runtime result is %d", static_cast<int>(rt_err)); GELOGE(rt_err, "get current context failed, runtime result is %d", static_cast<int>(rt_err));
return rt_err; return RT_ERROR_TO_GE_STATUS(rt_err);
} }
// use current context as resource key instead // use current context as resource key instead
GELOGI("use context as resource key instead when default stream"); GELOGI("use context as resource key instead when default stream");

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

Write Preview
Loading…
Cancel
Save