rectify error codes

pull/987/head
lichun 4 years ago
parent 435795139f
commit 2249f2804f

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

@ -162,7 +162,7 @@ Status FormatTransferC1hwncoc0Hwcn::TransFormat(const TransArgs &args, TransResu
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) {
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)

@ -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) {
auto c0 = GetCubeSizeByDataType(data_type);
if (c0 < 0) {
return UNSUPPORTED;
return ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID;
}
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,
std::vector<int64_t> &dst_shape) {
if (!CheckShapeValid(src_shape, kDhwcnDimsNum)) {
return PARAM_INVALID;
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
}
auto d = src_shape.at(kDhwcnD);
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,
std::vector<int64_t> &dst_shape) {
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) {
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)

@ -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) {
auto c0 = GetCubeSizeByDataType(data_type);
if (c0 < 0) {
return UNSUPPORTED;
return ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID;
}
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,
std::vector<int64_t> &dst_shape) {
if (!CheckShapeValid(src_shape, kDhwncDimsNum)) {
return PARAM_INVALID;
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
}
auto d = src_shape.at(kDhwncD);
auto h = src_shape.at(kDhwncH);
@ -164,14 +164,14 @@ Status FormatTransferDhwncFractalZ3DTranspose::TransShape(Format src_format, con
DataType data_type, Format dst_format,
std::vector<int64_t> &dst_shape) {
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) {
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)

@ -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(src_shape[kNdDimIndexN]);
if (!IsShapeValid(dst_shape)) {
GELOGE(PARAM_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str());
return PARAM_INVALID;
GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str());
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
}
return SUCCESS;
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 - kNdDimCountBackwardsW]);
if (!IsShapeValid(dst_shape)) {
GELOGE(PARAM_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str());
return PARAM_INVALID;
GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str());
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
}
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,
Format dst_format, ShapeVector &dst_shape) {
if (!IsDataTypeSupport(data_type) || !CheckShape(src_format, src_shape)) {
GELOGE(PARAM_INVALID, "Trans format from %s to %s, src shape %s, data type %s is not supported",
if (!IsDataTypeSupport(data_type)) {
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(),
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;
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) {
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());
return UNSUPPORTED;
return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
}
REGISTER_FORMAT_TRANSFER(FormatTransferFractalNz, FORMAT_ND, FORMAT_FRACTAL_NZ)

@ -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) {
auto c0 = GetCubeSizeByDataType(data_type);
if (c0 < 0) {
return UNSUPPORTED;
return ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID;
}
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(c0);
if (!IsShapeValid(dst_shape)) {
GELOGE(PARAM_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str());
return PARAM_INVALID;
GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID, "Failed to check dst shape %s",
ShapeToString(dst_shape).c_str());
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
}
return SUCCESS;
}
Status TransShapeNchwToFz(const std::vector<int64_t> &src_shape, DataType data_type, std::vector<int64_t> &dst_shape) {
if (!CheckShapeValid(src_shape, kNchwDimsNum)) {
return PARAM_INVALID;
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
}
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) {
if (!CheckShapeValid(src_shape, kHwcnDimsNum)) {
return PARAM_INVALID;
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
}
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) {
if (!CheckShapeValid(src_shape, kNhwcDimsNum)) {
return PARAM_INVALID;
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
}
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,
Format dst_format, std::vector<int64_t> &dst_shape) {
if (CheckDataTypeSupport(data_type) != SUCCESS) {
return UNSUPPORTED;
return ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID;
}
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 UNSUPPORTED;
return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
}
REGISTER_FORMAT_TRANSFER(FormatTransferFractalZ, FORMAT_NCHW, FORMAT_FRACTAL_Z)

@ -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(src_shape[kNdDimIndexN]);
if (!IsShapeValid(dst_shape)) {
GELOGE(PARAM_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str());
return PARAM_INVALID;
GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID, "Failed to check dst shape %s",
ShapeToString(dst_shape).c_str());
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
}
return SUCCESS;
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 - kNdDimCountBackwardsW]);
if (!IsShapeValid(dst_shape)) {
GELOGE(PARAM_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str());
return PARAM_INVALID;
GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID, "Failed to check dst shape %s",
ShapeToString(dst_shape).c_str());
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
}
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,
Format dst_format, ShapeVector &dst_shape) {
if (!IsDataTypeSupport(data_type) || !CheckShape(src_format, src_shape)) {
GELOGE(PARAM_INVALID, "Not support trans format from %s to %s, src shape %s, data type %s",
if (!IsDataTypeSupport(data_type)) {
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(),
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;
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) {
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());
return UNSUPPORTED;
return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
}
REGISTER_FORMAT_TRANSFER(FormatTransferFractalZz, FORMAT_ND, FORMAT_FRACTAL_ZZ)

@ -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,
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");
return UNSUPPORTED;
return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
}
REGISTER_FORMAT_TRANSFER(FormatTransferFracZHwcn, FORMAT_FRACTAL_Z, FORMAT_HWCN)

@ -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,
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");
return UNSUPPORTED;
return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
}
REGISTER_FORMAT_TRANSFER(FormatTransferFracZNchw, FORMAT_FRACTAL_Z, FORMAT_NCHW)

@ -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);
if (!CheckShapeValid(dst_shape, kC1hwncoc0DimsNum)) {
GELOGE(PARAM_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str());
return PARAM_INVALID;
GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID, "Failed to check dst shape %s",
ShapeToString(dst_shape).c_str());
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
}
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) {
if (src_format == FORMAT_HWCN && CheckDataTypeSupported(data_type)) {
if (!CheckShapeValid(src_shape, kHwcnDimsNum)) {
GELOGE(PARAM_INVALID, "Failed to check src shape %s", ShapeToString(src_shape).c_str());
return PARAM_INVALID;
GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID, "Failed to check src shape %s",
ShapeToString(src_shape).c_str());
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
}
return TransShapeHwcnToC1hwncoc0(data_type, src_shape, dst_shape);
} else if (src_format != FORMAT_HWCN) {
return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
} else {
return UNSUPPORTED;
return ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID;
}
}

@ -157,7 +157,7 @@ Status FormatTransferNc1hwc0Nhwc::TransFormat(const TransArgs &args, TransResult
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) {
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)

@ -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) {
auto c0 = GetCubeSizeByDataType(data_type);
if (c0 < 0) {
return UNSUPPORTED;
return ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID;
}
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);
if (!IsShapeValid(dst_shape)) {
GELOGE(PARAM_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str());
return PARAM_INVALID;
GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID, "Failed to check dst shape %s",
ShapeToString(dst_shape).c_str());
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
}
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,
std::vector<int64_t> &dst_shape) {
if (!CheckShapeValid(src_shape, kNchwDimsNum)) {
return PARAM_INVALID;
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
}
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,
DataType data_type, Format dst_format, std::vector<int64_t> &dst_shape) {
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) {
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)

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

@ -34,8 +34,8 @@ Status TransShapeNhwcToNc1hwc0(const std::vector<int64_t> &src_shape, DataType d
std::vector<int64_t> &dst_shape) {
int64_t c0 = GetCubeSizeByDataType(data_type);
if (c0 <= 0) {
GELOGE(PARAM_INVALID, "Failed to get cube size, the data type is invalid");
return PARAM_INVALID;
GELOGE(ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID, "Failed to get cube size, the data type is invalid");
return ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID;
}
dst_shape.clear();
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(c0);
if (!CheckShapeValid(dst_shape, kNc1hwc0DimsNum)) {
GELOGE(PARAM_INVALID, "Failed to check dst shape %s", ShapeToString(dst_shape).c_str());
return PARAM_INVALID;
GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID, "Failed to check dst shape %s",
ShapeToString(dst_shape).c_str());
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
}
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) {
if (src_format == FORMAT_NHWC && CheckDataTypeSupported(data_type)) {
if (!CheckShapeValid(src_shape, kNhwcDimsNum)) {
GELOGE(PARAM_INVALID, "Failed to check src shape %s", ShapeToString(src_shape).c_str());
return PARAM_INVALID;
GELOGE(ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID, "Failed to check src shape %s",
ShapeToString(src_shape).c_str());
return ACL_ERROR_GE_TRANSSHAPE_SHAPE_INVALID;
}
return TransShapeNhwcToNc1hwc0(src_shape, data_type, dst_shape);
} else if (src_format != FORMAT_NHWC) {
return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
} else {
return UNSUPPORTED;
return ACL_ERROR_GE_TRANSSHAPE_DATATYPE_INVALID;
}
}

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

@ -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 " +
FmtToStr(TypeUtils::FormatToSerialString(args.src_format)) + " to " +
FmtToStr(TypeUtils::FormatToSerialString(args.dst_format));
GE_ERRORLOG_AND_ERRORMSG(UNSUPPORTED, error.c_str());
return UNSUPPORTED;
GE_ERRORLOG_AND_ERRORMSG(ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID, error.c_str());
return ACL_ERROR_GE_TRANSSHAPE_FORMAT_INVALID;
}
return transfer->TransShape(src_format, src_shape, data_type, dst_format, dst_shape);

@ -93,7 +93,7 @@ Status PluginManager::LoadSo(const string &path, const vector<string> &func_chec
std::vector<std::string> path_vec;
SplitPath(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!");
continue);
// 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 = "");
ErrorManager::GetInstance().ATCReportErrMessage("E19012", {"function", "reason"},
{"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);
continue;
}
@ -138,8 +139,8 @@ Status PluginManager::LoadSo(const string &path, const vector<string> &func_chec
ErrorManager::GetInstance().ATCReportErrMessage("E19012", {"function", "reason"},
{"mmDlsym", FmtToStr(func_name) + " is skipped since function" +
FmtToStr(func_name) + " is not existed!"});
GELOGE(GE_PLGMGR_PATH_INVALID, "%s is skipped since function %s is not existed!", func_name.c_str(),
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());
is_valid = false;
break;
}

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

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

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

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

@ -51,7 +51,7 @@ RdmaPoolAllocator::RdmaPoolAllocator(rtMemType_t memory_type)
Status RdmaPoolAllocator::Initialize() {
memory_allocator_ = MemManager::Instance(memory_type_);
if (memory_allocator_ == nullptr) {
return ge::FAILED;
return ACL_ERROR_GE_INTERNAL_ERROR;
}
return ge::SUCCESS;
}

@ -29,8 +29,9 @@ constexpr int64_t kDimEndFlag = INT64_MIN;
Status AicpuExtInfoHandler::Parse(const std::string &ext_info) {
GELOGI("Node[%s] parse ext info start.", node_name_.c_str());
if (ext_info.empty()) {
GELOGE(PARAM_INVALID, "Node[%s] parse ext info failed as ext info is empty.", node_name_.c_str());
return PARAM_INVALID;
GELOGE(ACL_ERROR_GE_PARAM_INVALID, "Node[%s] parse ext info failed as ext info is empty.",
node_name_.c_str());
return ACL_ERROR_GE_PARAM_INVALID;
}
ext_info_len_ = ext_info.size();
@ -38,8 +39,8 @@ Status AicpuExtInfoHandler::Parse(const std::string &ext_info) {
GE_CHECK_NOTNULL(ext_info_);
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());
return FAILED;
GELOGE(ACL_ERROR_GE_MEMORY_OPERATE_FAILED, "[%s] Failed to coy ext info", node_name_.c_str());
return ACL_ERROR_GE_MEMORY_OPERATE_FAILED;
}
input_shape_and_type_.clear();
@ -72,7 +73,7 @@ Status AicpuExtInfoHandler::Parse(const std::string &ext_info) {
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_name_.c_str(), offset, ext_info_len_);
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) {
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_name_.c_str(), sizeof(int32_t), aicpu_ext_info->infoLen);
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_name_.c_str(), unknown_type_, *type);
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) {
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 "
"input_num[%u]*sizeof(ShapeAndType)[%zu] but %u.",
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;
}
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 "
"output_num[%u]*sizeof(ShapeAndType)[%zu] but %u.",
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) {
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_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) {
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_name_.c_str());
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) {
std::vector<std::pair<int64_t, int64_t>> 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_name_.c_str(), range_ret);
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) {
auto dim_num = shape.GetDimNum();
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);
return PARAM_INVALID;
return ACL_ERROR_GE_PARAM_INVALID;
}
size_t index = 0;
for (; index < dim_num; ++index) {

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

@ -141,7 +141,7 @@ Status SingleOpManager::GetResourceId(rtStream_t stream, uintptr_t &resource_id)
auto rt_err = rtCtxGetCurrent(&rt_cur_ctx);
if (rt_err != RT_ERROR_NONE) {
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
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

Loading…
Cancel
Save