@@ -80,7 +80,7 @@ if (ENABLE_OPEN_SRC) | |||
find_module(error_manager liberror_manager.so ${GE_LIB_PATH}) | |||
find_module(ascend_hal_stub libascend_hal.so ${GE_LIB_PATH}) | |||
find_module(error_manager_static liberror_manager.a ${GE_LIB_PATH}) | |||
find_module(msprofiler_fwk libmsprofiler_fwk.a ${GE_LIB_PATH}) | |||
#find_module(msprofiler_fwk libmsprofiler_fwk.a ${GE_LIB_PATH}) | |||
#find_module(ascendcl_static libascendcl.a ${GE_LIB_PATH}) | |||
else() | |||
find_module(slog libslog.so ${ASCEND_ATC_DIR}) | |||
@@ -92,7 +92,7 @@ if (ENABLE_OPEN_SRC) | |||
find_module(runtime libruntime.so ${ASCEND_RUNTIME_DIR}) | |||
find_module(resource libresource.so ${ASCEND_RUNTIME_DIR}) | |||
find_module(error_manager liberror_manager.so ${ASCEND_RUNTIME_DIR}) | |||
find_module(msprofiler_fwk libmsprofiler_fwk.a ${ASCEND_RUNTIME_DIR}) | |||
#find_module(msprofiler_fwk libmsprofiler_fwk.a ${ASCEND_RUNTIME_DIR}) | |||
find_module(ascend_hal_stub libascend_hal.so ${ASCEND_DRIVER_DIR}/driver) | |||
if(PRODUCT STREQUAL "flr3") | |||
message(FATAL_ERROR "This platform is not supported in train mode, build terminated") | |||
@@ -115,7 +115,7 @@ if (ENABLE_OPEN_SRC) | |||
find_module(ascend_hal_stub libascend_hal.so ${ASCEND_DRIVER_DIR}) | |||
endif() | |||
elseif(PLATFORM STREQUAL "all") | |||
find_module(msprofiler libmsprofiler.a ${ASCEND_DRIVER_COMMON_DIR}) | |||
find_module(msprofiler libmsprofiler.a ${ASCEND_ACL_DIR}) | |||
find_module(hccl libhccl.so ${ASCEND_RUNTIME_DIR}) | |||
find_module(adump_server libadump_server.a ${ASCEND_ACL_DIR}) | |||
find_module(runtime libruntime.so ${ASCEND_ACL_DIR}) | |||
@@ -123,7 +123,7 @@ if (ENABLE_OPEN_SRC) | |||
find_module(resource libresource.so ${ASCEND_ATC_DIR}) | |||
find_module(error_manager liberror_manager.so ${ASCEND_ATC_DIR}) | |||
find_module(error_manager_static liberror_manager.a ${ASCEND_ACL_DIR}) | |||
find_module(msprofiler_fwk libmsprofiler_fwk.a ${ASCEND_ACL_DIR}) | |||
#find_module(msprofiler_fwk libmsprofiler_fwk.a ${ASCEND_RUNTIME_DIR}) | |||
find_module(ascend_hal_stub libascend_hal.so ${ASCEND_DRIVER_DIR}/driver) | |||
#find_module(ascendcl_static libascendcl.a ${ASCEND_ACL_DIR}) | |||
else() | |||
@@ -603,6 +603,21 @@ set(INFER_SRC_LIST | |||
"analyzer/analyzer.cc" | |||
) | |||
if (ENABLE_OPEN_SRC) | |||
file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/msprofiler_fwk_object) | |||
if(EXISTS ${ASCEND_RUNTIME_DIR}/libmsprofiler_fwk.a) | |||
execute_process( | |||
COMMAND ar x ${ASCEND_RUNTIME_DIR}/libmsprofiler_fwk.a | |||
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/msprofiler_fwk_object | |||
) | |||
file(GLOB msprof_file ${CMAKE_CURRENT_BINARY_DIR}/msprofiler_fwk_object/*.o) | |||
else() | |||
file(GENERATE OUTPUT ${CMAKE_BINARY_DIR}/msprofiler_fwk.cc CONTENT "") | |||
set(msprof_file ${CMAKE_BINARY_DIR}/msprofiler_fwk.cc) | |||
endif() | |||
add_library(msprofiler_fwk OBJECT ${msprof_file}) | |||
endif() | |||
if (NOT ENABLE_D AND NOT ENABLE_ACL AND NOT ENABLE_MS_TESTCASES) | |||
############ libge_runner.so ############ | |||
add_library(ge_runner SHARED ${TRAIN_SRC_LIST} ${PROTO_SRCS} ${PROTO_CLIENT_SRCS} $<TARGET_OBJECTS:msprofiler_fwk>) | |||
@@ -0,0 +1,60 @@ | |||
/** | |||
* Copyright 2019-2020 Huawei Technologies Co., Ltd | |||
* | |||
* Licensed under the Apache License, Version 2.0 (the "License"); | |||
* you may not use this file except in compliance with the License. | |||
* You may obtain a copy of the License at | |||
* | |||
* http://www.apache.org/licenses/LICENSE-2.0 | |||
* | |||
* Unless required by applicable law or agreed to in writing, software | |||
* distributed under the License is distributed on an "AS IS" BASIS, | |||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |||
* See the License for the specific language governing permissions and | |||
* limitations under the License. | |||
*/ | |||
#ifndef AICPU_OP_TYPE_LIST_H_ | |||
#define AICPU_OP_TYPE_LIST_H_ | |||
enum OpKernelType { | |||
TF_KERNEL, | |||
CPU_KERNEL | |||
}; | |||
enum ReturnCode { | |||
OP_TYPE_NOT_SUPPORT, | |||
FORMAT_NOT_SUPPORT, | |||
DTYPE_NOT_SUPPORT | |||
}; | |||
#pragma pack(push, 1) | |||
//One byte alignment | |||
struct SysOpInfo { | |||
uint64_t opLen; | |||
uint64_t opType; | |||
OpKernelType kernelsType; | |||
}; | |||
struct OpParamInfo { | |||
uint64_t num; | |||
uint64_t dtypeList; | |||
uint64_t formatList; | |||
}; | |||
struct SysOpCheckInfo { | |||
uint64_t opListNum; | |||
uint64_t offSetLen; | |||
uint64_t sysOpInfoList; | |||
uint64_t opParamInfoList; | |||
}; | |||
struct SysOpCheckResp { | |||
uint64_t opListNum; | |||
bool isWithoutJson; | |||
uint64_t returnCodeList; | |||
uint64_t sysOpInfoList; | |||
uint64_t opParamInfoList; | |||
}; | |||
#pragma pack(pop) | |||
#endif // AICPU_OP_TYPE_LIST_H_ |
@@ -21,13 +21,15 @@ | |||
namespace aicpu { | |||
#pragma pack(push, 1) | |||
struct AicpuParamHead | |||
{ | |||
uint32_t length; // Total length: include cunstom message | |||
uint32_t ioAddrNum; // Input and output address number | |||
uint32_t extInfoLength; // extInfo struct Length | |||
uint64_t extInfoAddr; // extInfo address | |||
} __attribute__ ((packed)); | |||
}; | |||
#pragma pack(pop) | |||
} // namespace aicpu | |||
@@ -13,10 +13,11 @@ | |||
* See the License for the specific language governing permissions and | |||
* limitations under the License. | |||
*/ | |||
#ifndef AICPU_ENGINE_H__ | |||
#define AICPU_ENGINE_H__ | |||
#include <stdint.h> | |||
#ifdef __cplusplus | |||
extern "C" { | |||
#endif | |||
@@ -36,12 +37,23 @@ typedef enum { | |||
/** | |||
* @ingroup aicpu engine | |||
* @brief aeCallInterface: | |||
* a interface to call a function in a op kernfel lib | |||
* a interface to call a function in a op kernfel lib | |||
* @param [in] addr void *, should be STR_KERNEL * format | |||
* @return aeStatus_t | |||
*/ | |||
aeStatus_t aeCallInterface(void *addr); | |||
/** | |||
* @ingroup aicpu engine | |||
* @brief aeBatchLoadKernelSo: | |||
* a interface to load kernel so | |||
* @param [in] loadSoNum load so number | |||
* @param [in] soPaths load so paths | |||
* @param [in] soNames load so names | |||
* @return aeStatus_t | |||
*/ | |||
aeStatus_t aeBatchLoadKernelSo(const uint32_t loadSoNum, const char *soPaths[], const char *soNames[]); | |||
#ifdef __cplusplus | |||
} | |||
#endif | |||
@@ -33,18 +33,22 @@ typedef enum { | |||
FMK_KERNEL_TYPE_RESERVED | |||
} FwkkernelType_t; | |||
#pragma pack(push, 1) | |||
typedef struct { | |||
uint32_t fwkKernelType; // FwkkernelType_t | |||
union { | |||
::aicpu::FWKAdapter::FWKOperateParam fwk_kernel; | |||
} fwkKernelBase; | |||
} __attribute__((packed)) STR_FWK_OP_KERNEL; | |||
} STR_FWK_OP_KERNEL; | |||
#pragma pack(pop) | |||
#pragma pack(push, 1) | |||
struct SessionInfo { | |||
uint64_t sessionId; | |||
uint64_t kernelId; | |||
bool sessFlag; | |||
} __attribute__((packed)); | |||
}; | |||
#pragma pack(pop) | |||
#ifdef __cplusplus | |||
} | |||
@@ -70,6 +70,7 @@ enum FWKExtUpdateAddrType { | |||
FWK_ADPT_UPDATE_INPUT_OUTPUT | |||
}; | |||
#pragma pack(push, 1) | |||
// API Parameter Structure | |||
struct StrFWKKernel { | |||
FWKOperateType opType; | |||
@@ -89,31 +90,39 @@ struct StrFWKKernel { | |||
uint64_t extInfoLen; // extend info total length | |||
uint64_t extInfoAddr; // extend info addr, ExtInfo structure | |||
} __attribute__((packed)); | |||
}; | |||
#pragma pack(pop) | |||
typedef StrFWKKernel FWKOperateParam; | |||
// Extent info ShapeAndType | |||
const uint32_t kMaxShapeDims = 8; | |||
#pragma pack(push, 1) | |||
struct ShapeAndType { | |||
int32_t type; | |||
int64_t dims[kMaxShapeDims]; | |||
} __attribute__((packed)); | |||
}; | |||
#pragma pack(pop) | |||
// Extend info structure for extInfoAddr | |||
const uint32_t kExtInfoHeadSize = 8; | |||
#pragma pack(push, 1) | |||
struct ExtInfo { | |||
int32_t infoType; // extend type | |||
uint32_t infoLen; // length for infoMsg | |||
char infoMsg[0]; // extend value | |||
} __attribute__((packed)); | |||
}; | |||
#pragma pack(pop) | |||
#pragma pack(push, 1) | |||
struct ResultSummary { | |||
uint64_t shape_data_ptr; // shape data addr, need convert to void* | |||
uint64_t shape_data_size; // num of dims | |||
uint64_t raw_data_ptr; // raw data addr, need convert to void* | |||
uint64_t raw_data_size; // size of raw data | |||
} __attribute__((packed)); | |||
}; | |||
#pragma pack(pop) | |||
} // end namespace FWKAdapter | |||
} // namespace aicpu | |||
@@ -22,7 +22,8 @@ | |||
#ifndef HCCL_BASE_H_ | |||
#define HCCL_BASE_H_ | |||
#include <hccl/hccl_types.h> | |||
#include <string> | |||
#ifdef __cplusplus | |||
extern "C" { | |||
#endif // __cplusplus | |||
@@ -95,6 +96,33 @@ typedef void *rtStream_t; | |||
*/ | |||
typedef void *rtModel_t; | |||
struct HcomOperation { | |||
std::string hcclType; | |||
void *inputPtr; | |||
void *outputPtr; | |||
u64 count; | |||
HcclDataType dataType; | |||
HcclReduceOp opType; | |||
u32 root; | |||
HcomOperation() | |||
{ | |||
inputPtr = nullptr; | |||
outputPtr = nullptr; | |||
count = 0; | |||
dataType = HCCL_DATA_TYPE_RESERVED; | |||
opType = HCCL_REDUCE_RESERVED; | |||
root = 0; | |||
} | |||
}; | |||
struct HcomRemoteAccessAddrInfo { | |||
u32 remotetRankID; | |||
u64 remoteAddr; // host embedding table address | |||
u64 localAddr; // device HBM address | |||
u64 length; // Memory Length in Bytes | |||
}; | |||
#ifdef __cplusplus | |||
} | |||
#endif // __cplusplus | |||
@@ -24,145 +24,96 @@ | |||
#include <hccl/base.h> | |||
#include <hccl/hccl_types.h> | |||
#include <functional> | |||
#include <vector> | |||
#ifdef __cplusplus | |||
extern "C" { | |||
#endif // __cplusplus | |||
/** | |||
* @brief Initialize HCOM. | |||
* | |||
* @param rank_table A string identifying the rank table file path, include file name. | |||
* @param identify A string identifying the identify for the rank. | |||
* @return HcclResult | |||
* @see hcom_destroy() | |||
*/ | |||
extern HcclResult hcom_init(const char *rank_table, const char *identify); | |||
/** | |||
* @brief Destroy HCOM | |||
* | |||
* @return HcclResult | |||
* @see hcom_init() | |||
*/ | |||
extern HcclResult hcom_destroy(void); | |||
/** | |||
* @brief Bind the model. | |||
* | |||
* @param model A pointer identifying the model information. | |||
* @param stream A pointer identifying the stream information. | |||
* @return HcclResult | |||
* @see hcom_unbind_model() | |||
*/ | |||
extern HcclResult hcom_bind_model(rtModel_t model, rtStream_t stream); | |||
/** | |||
* @brief Unbind the model. | |||
* @brief Get the rank number in the group. | |||
* | |||
* @param model An pointer identifying the model information. | |||
* @return HcclResult | |||
* @see hcom_unbind_model() | |||
* @param group A string identifying the group name. | |||
* @param rankSize A pointer identifying the rank number. | |||
* @return HcclResult | |||
*/ | |||
extern HcclResult hcom_unbind_model(rtModel_t model); | |||
HcclResult hcom_get_rank_size(const char *group, u32 *rankSize); | |||
/** | |||
* @brief All-gather operator. | |||
* @brief Get the rank number in the group. | |||
* | |||
* @param tag A string identifying the tag of the operator. | |||
* @param inputPtr A pointer identifying the input data address of the operator. | |||
* @param outputPtr A pointer identifying the output data address of the operator. | |||
* @param inputCount An integer(u64) identifying the number of the input data. | |||
* @param dataType The data type of the operator, must be one of the following types: int8, int32, float16, float32. | |||
* @param group A string identifying the group name of ranks participating in the operator. | |||
* @param stream A pointer identifying the stream information. | |||
* @param group A string identifying the group name. | |||
* @param rankSize A pointer identifying the rank number. | |||
* @return HcclResult | |||
*/ | |||
extern HcclResult hcom_all_gather(const char *tag, void *inputPtr, void *outputPtr, u64 inputCount, | |||
HcclDataType dataType, const char *group, rtStream_t stream); | |||
HcclResult HcomGetRankSize(const char *group, u32 *rankSize); | |||
/** | |||
* @brief All-reduce operator. | |||
* @brief Get the rank number of this rank's server within the group. | |||
* | |||
* @param tag A string identifying the tag of the operator. | |||
* @param inputPtr A pointer identifying the input data address of the operator. | |||
* @param outputPtr A pointer identifying the output data address of the operator. | |||
* @param count An integer(u64) identifying the number of the output data. | |||
* @param dataType The data type of the operator, must be one of the following types: int8, int32, float16, float32. | |||
* @param op The reduction type of the operator, must be one of the following types: sum, min, max, prod. | |||
* @param group A string identifying the group name of ranks participating in the operator. | |||
* @param stream A pointer identifying the stream information. | |||
* @param group A string identifying the group name. | |||
* @param localRankSize A pointer identifying the rank number. | |||
* @return HcclResult | |||
*/ | |||
extern HcclResult hcom_all_reduce(const char *tag, void *inputPtr, void *outputPtr, u64 count, | |||
HcclDataType dataType, HcclReduceOp op, const char *group, rtStream_t stream); | |||
HcclResult hcom_get_local_rank_size(const char *group, u32 *localRankSize); | |||
/** | |||
* @brief Broadcast operator. | |||
* @brief Get the rank number of this rank's server within the group. | |||
* | |||
* @param tag A string identifying the tag of the operator. | |||
* @param ptr A pointer identifying the data address of the operator. | |||
* @param count An integer(u64) identifying the number of the data. | |||
* @param dataType The data type of the operator, must be one of the following types: int8, int32, float16, float32. | |||
* @param root An integer(u32) identifying the the root rank in the operator. | |||
* @param group A string identifying the group name of ranks participating in the operator. | |||
* @param stream A pointer identifying the stream information. | |||
* @param group A string identifying the group name. | |||
* @param localRankSize A pointer identifying the rank number. | |||
* @return HcclResult | |||
*/ | |||
extern HcclResult hcom_broadcast(const char *tag, void *ptr, u64 count, HcclDataType dataType, u32 root, | |||
const char *group, rtStream_t stream); | |||
HcclResult HcomGetLocalRankSize(const char *group, u32 *localRankSize); | |||
/** | |||
* @brief Reduce-scatter operator. | |||
* @brief Get the rank id of this rank. | |||
* | |||
* @param tag A string identifying the tag of the operator. | |||
* @param inputPtr A pointer identifying the input data address of the operator. | |||
* @param outputPtr A pointer identifying the output data address of the operator. | |||
* @param count An integer(u64) identifying the number of the data. | |||
* @param dataType The data type of the operator, must be one of the following types: int8, int32, float16, float32. | |||
* @param op The reduction type of the operator, must be one of the following types: sum, min, max, prod. | |||
* @param group A string identifying the group name of ranks participating in the operator. | |||
* @param stream A pointer identifying the stream information. | |||
* @param group A string identifying the group name. | |||
* @param rankId A pointer identifying the rank id. | |||
* @return HcclResult | |||
*/ | |||
extern HcclResult hcom_reduce_scatter(const char *tag, void *inputPtr, void *outputPtr, u64 count, | |||
HcclDataType dataType, HcclReduceOp op, const char *group, rtStream_t stream); | |||
HcclResult hcom_get_rank_id(const char *group, u32 *rankId); | |||
/** | |||
* @brief Get the rank number in the group. | |||
* @brief Get the rank id of this rank. | |||
* | |||
* @param group A string identifying the group name. | |||
* @param rankSize A pointer identifying the rank number. | |||
* @param rankId A pointer identifying the rank id. | |||
* @return HcclResult | |||
*/ | |||
HcclResult hcom_get_rank_size(const char *group, u32 *rankSize); | |||
HcclResult HcomGetRankId(const char *group, u32 *rankId); | |||
/** | |||
* @brief Get the rank number of this rank's server within the group. | |||
* @brief Get the local rank id of this rank's server within the group. | |||
* | |||
* @param group A string identifying the group name. | |||
* @param localRankSize A pointer identifying the rank number. | |||
* @param localRankId A pointer identifying the local rank id. | |||
* @return HcclResult | |||
*/ | |||
HcclResult hcom_get_local_rank_size(const char *group, u32 *localRankSize); | |||
HcclResult hcom_get_local_rank_id(const char *group, u32 *localRankId); | |||
/** | |||
* @brief Get the rank id of this rank. | |||
* @brief Get the local rank id of this rank's server within the group. | |||
* | |||
* @param group A string identifying the group name. | |||
* @param rankId A pointer identifying the rank id. | |||
* @param localRankId A pointer identifying the local rank id. | |||
* @return HcclResult | |||
*/ | |||
HcclResult hcom_get_rank_id(const char *group, u32 *rankId); | |||
HcclResult HcomGetLocalRankId(const char *group, u32 *localRankId); | |||
/** | |||
* @brief Get the local rank id of this rank's server within the group. | |||
* @brief Get the world rank id according to the group rank id. | |||
* | |||
* @param group A string identifying the group name. | |||
* @param localRankId A pointer identifying the local rank id. | |||
* @param groupRank An integer(u32) identifying the group rank id. | |||
* @param worldRank A pointer identifying the world rank id. | |||
* @return HcclResult | |||
*/ | |||
HcclResult hcom_get_local_rank_id(const char *group, u32 *localRankId); | |||
HcclResult hcom_get_world_rank_from_group_rank(const char *group, u32 groupRank, u32 *worldRank); | |||
/** | |||
* @brief Get the world rank id according to the group rank id. | |||
@@ -172,7 +123,7 @@ HcclResult hcom_get_local_rank_id(const char *group, u32 *localRankId); | |||
* @param worldRank A pointer identifying the world rank id. | |||
* @return HcclResult | |||
*/ | |||
HcclResult hcom_get_world_rank_from_group_rank(const char *group, u32 groupRank, u32 *worldRank); | |||
HcclResult HcomGetWorldRankFromGroupRank(const char *group, u32 groupRank, u32 *worldRank); | |||
/** | |||
* @brief Get the group rank id according to the world rank id. | |||
@@ -184,6 +135,16 @@ HcclResult hcom_get_world_rank_from_group_rank(const char *group, u32 groupRank, | |||
*/ | |||
HcclResult hcom_get_group_rank_from_world_rank(u32 worldRank, const char *group, u32 *groupRank); | |||
/** | |||
* @brief Get the group rank id according to the world rank id. | |||
* | |||
* @param worldRank An integer(u32) identifying the world rank id. | |||
* @param group A string identifying the group name. | |||
* @param groupRank A pointer identifying the group rank id. | |||
* @return HcclResult | |||
*/ | |||
HcclResult HcomGetGroupRankFromWorldRank(u32 worldRank, const char *group, u32 *groupRank); | |||
/** | |||
* @brief Create group. | |||
* | |||
@@ -195,60 +156,40 @@ HcclResult hcom_get_group_rank_from_world_rank(u32 worldRank, const char *group, | |||
HcclResult hcom_create_group(const char *group, u32 rankNum, u32 *rankIds); | |||
/** | |||
* @brief Destroy group | |||
* @brief Create group. | |||
* | |||
* @param group A string identifying the group name. | |||
* @param rankNum An integer(u32) identifying the number of ranks in the group. | |||
* @param rankIds A list identifying the ranks in the group. | |||
* @return HcclResult | |||
*/ | |||
HcclResult hcom_destroy_group(const char *group); | |||
HcclResult HcomCreateGroup(const char *group, u32 rankNum, u32 *rankIds); | |||
/** | |||
* @brief Send operator. | |||
* @brief Destroy group | |||
* | |||
* @param tag A string identifying the tag of the operator. | |||
* @param inputPtr A pointer identifying the input data address of the operator. | |||
* @param count An integer(u64) identifying the number of the data. | |||
* @param dataType The data type of the operator, must be one of the following types: int8, int32, float16, float32. | |||
* @param destRank An integer identifying the destination rank. | |||
* @param srTag An integer identifying the send/recv message tag. | |||
* The message will be send by the receive operator with the same "sr_tag". | |||
* @param group A string identifying the group name of ranks participating in the operator. | |||
* @param stream A pointer identifying the stream information. | |||
* @param group A string identifying the group name. | |||
* @return HcclResult | |||
*/ | |||
HcclResult hcom_send(const char *tag, void *inputPtr, u64 count, HcclDataType dataType, | |||
u32 destRank, u32 srTag, const char *group, rtStream_t stream); | |||
HcclResult hcom_destroy_group(const char *group); | |||
/** | |||
* @brief Receive operator. | |||
* @brief Destroy group | |||
* | |||
* @param tag A string identifying the tag of the operator. | |||
* @param outputPtr A pointer identifying the output data address of the operator. | |||
* @param count An integer(u64) identifying the number of the data. | |||
* @param dataType The data type of the operator, must be one of the following types: int8, int32, float16, float32. | |||
* @param srcRank An integer identifying the source rank. | |||
* @param srTag An integer identifying the send/recv message tag. | |||
* The message will be send by the send operator with the same "sr_tag". | |||
* @param group A string identifying the group name of ranks participating in the operator. | |||
* @param stream A pointer identifying the stream information. | |||
* @param group A string identifying the group name. | |||
* @return HcclResult | |||
*/ | |||
HcclResult hcom_receive(const char *tag, void *outputPtr, u64 count, HcclDataType dataType, | |||
u32 srcRank, u32 srTag, const char *group, rtStream_t stream); | |||
HcclResult HcomDestroyGroup(const char *group); | |||
/** | |||
* @brief Get the gradient split strategy with in the group. | |||
* @brief Set the gradient split strategy with in the group, according to gradient index. | |||
* | |||
* @param group A string identifying the group name. | |||
* @param feature A pointer identifying the feature of the model. | |||
* @param maxSegmentNum An integer(u32) identifying the max segments of gradients. | |||
* @param segmentNum A pointer identifying the segments number of gradients. | |||
* @param segmentIdx A list identifying the index of end gradient in each segment. | |||
* @return HcclResult | |||
* @param segmentNum An integer(u32) identifying the segments number of gradients. | |||
* @param IdxList A list identifying the index of end gradient in each segment. | |||
* @return HcclResult | |||
*/ | |||
HcclResult hcom_get_split_strategy(const char *group, const struct model_feature *feature, u32 maxSegmentNum, | |||
u32 *segmentNum, u32 *segmentIdx, GradSplitForceMode force = FORCE_NONE, | |||
OriginalGraphShapeType shapeType = KNOWN_SHAPE); | |||
extern HcclResult hcom_set_split_strategy_by_index(const char *group, u32 segmentNum, const u32 *IdxList); | |||
/** | |||
* @brief Set the gradient split strategy with in the group, according to gradient index. | |||
@@ -258,7 +199,7 @@ HcclResult hcom_get_split_strategy(const char *group, const struct model_feature | |||
* @param IdxList A list identifying the index of end gradient in each segment. | |||
* @return HcclResult | |||
*/ | |||
extern HcclResult hcom_set_split_strategy_by_index(const char *group, u32 segmentNum, const u32 *IdxList); | |||
extern HcclResult HcomSetGradFusionByIndex(const char *group, u32 segmentNum, const u32 *IdxList); | |||
/** | |||
* @brief Set the gradient split strategy with in the group, according to gradient data size. | |||
@@ -270,6 +211,16 @@ extern HcclResult hcom_set_split_strategy_by_index(const char *group, u32 segmen | |||
*/ | |||
extern HcclResult hcom_set_split_strategy_by_size(const char *group, u32 segmentNum, const float *sizeList); | |||
/** | |||
* @brief Set the gradient split strategy with in the group, according to gradient data size. | |||
* | |||
* @param group A string identifying the group name. | |||
* @param segmentNum An integer(u32) identifying the segments number of gradients. | |||
* @param sizeList A list identifying the percent of each segment. | |||
* @return HcclResult | |||
*/ | |||
extern HcclResult HcomSetGradFusionBySize(const char *group, u32 segmentNum, const float *sizeList); | |||
/** | |||
* @brief Register memories and init resources for remote access. | |||
* | |||
@@ -279,6 +230,25 @@ extern HcclResult hcom_set_split_strategy_by_size(const char *group, u32 segment | |||
*/ | |||
extern HcclResult hcom_remote_access_mem_register(const MemRegisterAddr* addrList, u32 count); | |||
/** | |||
* @brief Register memories and init resources for remote access. | |||
* | |||
* @param addrList memory addresses for remote access. | |||
* @param count number of remote memory addresses. | |||
* @return HcclResult | |||
*/ | |||
extern HcclResult HcomRegRemoteAccessMem(const MemRegisterAddr* addrList, u32 count); | |||
HcclResult HcomExecInitialize(); | |||
HcclResult HcomExecFinalize(); | |||
HcclResult HcomExecEnqueueOperation(HcomOperation opInfo, std::function<void(HcclResult status)> callback); | |||
HcclResult HcomExecEnqueueRemoteAccess(const std::string& remoteAccessType, | |||
const std::vector<HcomRemoteAccessAddrInfo>& addrInfos, | |||
std::function<void(HcclResult status)> callback); | |||
#ifdef __cplusplus | |||
} | |||
#endif // __cplusplus | |||
@@ -215,6 +215,10 @@ typedef struct { | |||
#define S_IWRITE S_IWUSR | |||
#endif | |||
#define mm_no_argument no_argument | |||
#define mm_required_argument required_argument | |||
#define mm_optional_argument optional_argument | |||
#define M_FILE_RDONLY O_RDONLY | |||
#define M_FILE_WRONLY O_WRONLY | |||
#define M_FILE_RDWR O_RDWR | |||
@@ -227,6 +231,7 @@ typedef struct { | |||
#define M_BINARY O_RDONLY | |||
#define M_TRUNC O_TRUNC | |||
#define M_IRWXU S_IRWXU | |||
#define M_APPEND O_APPEND | |||
#define M_IN_CREATE IN_CREATE | |||
#define M_IN_CLOSE_WRITE IN_CLOSE_WRITE | |||
@@ -342,17 +347,17 @@ MMPA_FUNC_VISIBILITY INT32 mmCloseSocket(mmSockHandle sockFd); | |||
MMPA_FUNC_VISIBILITY mmSsize_t mmSocketSend(mmSockHandle sockFd, VOID *sendBuf, INT32 sendLen, INT32 sendFlag); | |||
MMPA_FUNC_VISIBILITY mmSsize_t mmSocketRecv(mmSockHandle sockFd, VOID *recvBuf, INT32 recvLen, INT32 recvFlag); | |||
MMPA_FUNC_VISIBILITY INT32 mmSocketSendTo(mmSockHandle sockFd, | |||
VOID *sendMsg, | |||
INT32 sendLen, | |||
UINT32 sendFlag, | |||
const mmSockAddr* addr, | |||
INT32 tolen); | |||
VOID *sendMsg, | |||
INT32 sendLen, | |||
UINT32 sendFlag, | |||
const mmSockAddr* addr, | |||
INT32 tolen); | |||
MMPA_FUNC_VISIBILITY mmSsize_t mmSocketRecvFrom(mmSockHandle sockFd, | |||
VOID *recvBuf, | |||
mmSize recvLen, | |||
UINT32 recvFlag, | |||
mmSockAddr* addr, | |||
mmSocklen_t *FromLen); | |||
VOID *recvBuf, | |||
mmSize recvLen, | |||
UINT32 recvFlag, | |||
mmSockAddr* addr, | |||
mmSocklen_t *FromLen); | |||
MMPA_FUNC_VISIBILITY INT32 mmSAStartup(); | |||
MMPA_FUNC_VISIBILITY INT32 mmSACleanup(); | |||
MMPA_FUNC_VISIBILITY VOID *mmDlopen(const CHAR *fileName, INT32 mode); | |||
@@ -360,7 +365,10 @@ MMPA_FUNC_VISIBILITY INT32 mmDladdr(VOID *addr, mmDlInfo *info); | |||
MMPA_FUNC_VISIBILITY VOID *mmDlsym(VOID *handle, const CHAR *funcName); | |||
MMPA_FUNC_VISIBILITY INT32 mmDlclose(VOID *handle); | |||
MMPA_FUNC_VISIBILITY CHAR *mmDlerror(); | |||
MMPA_FUNC_VISIBILITY INT32 mmCreateAndSetTimer(mmTimer *timerHandle, mmUserBlock_t *timerBlock, UINT milliSecond, UINT period); | |||
MMPA_FUNC_VISIBILITY INT32 mmCreateAndSetTimer(mmTimer *timerHandle, | |||
mmUserBlock_t *timerBlock, | |||
UINT milliSecond, | |||
UINT period); | |||
MMPA_FUNC_VISIBILITY INT32 mmDeleteTimer(mmTimer timerHandle); | |||
MMPA_FUNC_VISIBILITY INT32 mmStatGet(const CHAR *path, mmStat_t *buffer); | |||
MMPA_FUNC_VISIBILITY INT32 mmStat64Get(const CHAR *path, mmStat64_t *buffer); | |||
@@ -408,8 +416,12 @@ MMPA_FUNC_VISIBILITY VOID mmClosePipe(mmPipeHandle pipe[], UINT32 pipeCount); | |||
// Poll related interface | |||
MMPA_FUNC_VISIBILITY mmCompletionHandle mmCreateCompletionPort(); | |||
MMPA_FUNC_VISIBILITY VOID mmCloseCompletionPort(mmCompletionHandle handle); | |||
MMPA_FUNC_VISIBILITY INT32 mmPoll(mmPollfd *fds, INT32 fdCount, INT32 timeout, mmCompletionHandle handleIOCP, | |||
pmmPollData polledData, mmPollBack pollBack); | |||
MMPA_FUNC_VISIBILITY INT32 mmPoll(mmPollfd *fds, | |||
INT32 fdCount, | |||
INT32 timeout, | |||
mmCompletionHandle handleIOCP, | |||
pmmPollData polledData, | |||
mmPollBack pollBack); | |||
MMPA_FUNC_VISIBILITY INT32 mmGetErrorCode(); | |||
MMPA_FUNC_VISIBILITY CHAR *mmGetErrorFormatMessage(mmErrorMsg errnum, CHAR *buf, mmSize size); | |||
MMPA_FUNC_VISIBILITY INT32 mmGetTimeOfDay(mmTimeval *timeVal, mmTimezone *timeZone); | |||
@@ -454,8 +466,11 @@ MMPA_FUNC_VISIBILITY VOID mmSetOpOpt(INT32 mmOptOpt); | |||
MMPA_FUNC_VISIBILITY CHAR *mmGetOptArg(); | |||
MMPA_FUNC_VISIBILITY VOID mmSetOptArg(CHAR *mmOptArg); | |||
MMPA_FUNC_VISIBILITY INT32 mmGetOpt(INT32 argc, char *const *argv, const char *opts); | |||
MMPA_FUNC_VISIBILITY INT32 mmGetOptLong(INT32 argc, char *const *argv, const char *opts, const mmStructOption *longOpts, | |||
INT32 *longIndex); | |||
MMPA_FUNC_VISIBILITY INT32 mmGetOptLong(INT32 argc, | |||
char *const *argv, | |||
const char *opts, | |||
const mmStructOption *longOpts, | |||
INT32 *longIndex); | |||
MMPA_FUNC_VISIBILITY LONG mmLseek(INT32 fd, INT64 offset, INT32 seekFlag); | |||
MMPA_FUNC_VISIBILITY INT32 mmFtruncate(mmProcess fd, UINT32 length); | |||
@@ -521,11 +536,14 @@ MMPA_FUNC_VISIBILITY INT32 mmGetMac(mmMacInfo **list, INT32 *count); | |||
MMPA_FUNC_VISIBILITY INT32 mmGetMacFree(mmMacInfo *list, INT32 count); | |||
MMPA_FUNC_VISIBILITY INT32 mmGetCpuInfo(mmCpuDesc **cpuInfo, INT32 *count); | |||
MMPA_FUNC_VISIBILITY INT32 mmCpuInfoFree(mmCpuDesc *cpuInfo, INT32 count); | |||
MMPA_FUNC_VISIBILITY INT32 mmCreateProcess(const CHAR *fileName, const mmArgvEnv *env, const char *stdoutRedirectFile, | |||
mmProcess *id); | |||
MMPA_FUNC_VISIBILITY INT32 mmCreateTaskWithThreadAttr(mmThread *threadHandle, const mmUserBlock_t *funcBlock, | |||
const mmThreadAttr *threadAttr); | |||
MMPA_FUNC_VISIBILITY INT32 mmCreateProcess(const CHAR *fileName, | |||
const mmArgvEnv *env, | |||
const char *stdoutRedirectFile, | |||
mmProcess *id); | |||
MMPA_FUNC_VISIBILITY INT32 mmCreateTaskWithThreadAttr(mmThread *threadHandle, | |||
const mmUserBlock_t *funcBlock, | |||
const mmThreadAttr *threadAttr); | |||
MMPA_FUNC_VISIBILITY mmFileHandle mmShmOpen(const CHAR *name, INT32 oflag, mmMode_t mode); | |||
MMPA_FUNC_VISIBILITY INT32 mmShmUnlink(const CHAR *name); | |||
MMPA_FUNC_VISIBILITY VOID *mmMmap(mmFd_t fd, mmSize_t size, mmOfft_t offset, mmFd_t *extra, INT32 prot, INT32 flags); | |||
@@ -237,6 +237,11 @@ typedef struct { | |||
} mmThreadAttr; | |||
typedef VOID (*mmPf)(VOID); | |||
#define mm_no_argument 0 | |||
#define mm_required_argument 1 | |||
#define mm_optional_argument 2 | |||
#define M_FILE_RDONLY GENERIC_READ | |||
#define M_FILE_WRONLY GENERIC_WRITE | |||
#define M_FILE_RDWR (GENERIC_READ | GENERIC_WRITE) | |||
@@ -249,6 +254,7 @@ typedef VOID (*mmPf)(VOID); | |||
#define M_CREAT _O_CREAT | |||
#define M_BINARY _O_BINARY | |||
#define M_TRUNC _O_TRUNC | |||
#define M_APPEND _O_APPEND | |||
#define M_IREAD _S_IREAD | |||
#define M_IRUSR _S_IREAD | |||
@@ -18,6 +18,7 @@ | |||
#define __CCE_RUNTIME_BASE_H__ | |||
#include <stdint.h> | |||
#include "toolchain/prof_callback.h" | |||
#if defined(__cplusplus) && !defined(COMPILE_OMG_PACKAGE) | |||
extern "C" { | |||
@@ -32,309 +33,8 @@ extern "C" { | |||
#endif | |||
#endif | |||
/** | |||
* @ingroup dvrt_base | |||
* @brief runtime error numbers. | |||
*/ | |||
typedef enum tagRtError { | |||
RT_ERROR_NONE = 0x0, // success | |||
RT_ERROR_DEVICE_BASE = 0x07010000, | |||
RT_ERROR_DEVICE_NULL, | |||
RT_ERROR_DEVICE_NEW, | |||
RT_ERROR_DEVICE_ID, | |||
RT_ERROR_DEVICE_CHIPTYPE, | |||
RT_ERROR_DEVICE_DEPLOY, | |||
RT_ERROR_DEVICE_RETAIN, | |||
RT_ERROR_DEVICE_PLATFORM, | |||
RT_ERROR_DEVICE_LOADER, | |||
RT_ERROR_DEVICE_LIMIT, | |||
RT_ERROR_DEVICE_PROC_HANG_OUT, | |||
RT_ERROR_DEVICE_POWER_UP_FAIL, | |||
RT_ERROR_DEVICE_POWER_DOWN_FAIL, | |||
RT_ERROR_DEVICE_INVALID, | |||
RT_ERROR_DRV_BASE = 0x07020000, | |||
RT_ERROR_DRV_NULL, | |||
RT_ERROR_DRV_NEW, | |||
RT_ERROR_DRV_MEMORY, | |||
RT_ERROR_DRV_INPUT, | |||
RT_ERROR_DRV_PTRNULL, | |||
RT_ERROR_DRV_OPEN_AICPU, | |||
RT_ERROR_DRV_CLOSE_AICPU, | |||
RT_ERROR_DRV_SYM_AICPU, | |||
RT_ERROR_DRV_OPEN_TSD, | |||
RT_ERROR_DRV_CLOSE_TSD, | |||
RT_ERROR_DRV_SYM_TSD, | |||
RT_ERROR_DRV_SOURCE, | |||
RT_ERROR_DRV_REPORT, | |||
RT_ERROR_DRV_COMMAND, | |||
RT_ERROR_DRV_OCCUPY, | |||
RT_ERROR_DRV_ERR, | |||
RT_ERROR_STREAM_BASE = 0x07030000, | |||
RT_ERROR_STREAM_NULL, | |||
RT_ERROR_STREAM_NEW, | |||
RT_ERROR_STREAM_CONTEXT, | |||
RT_ERROR_STREAM_INVALID, | |||
RT_ERROR_STREAM_MODEL, | |||
RT_ERROR_STREAM_FUSION, | |||
RT_ERROR_STREAM_FULL, | |||
RT_ERROR_STREAM_EMPTY, | |||
RT_ERROR_STREAM_NOT_COMPLETE, | |||
RT_ERROR_STREAM_SYNC, | |||
RT_ERROR_STREAM_NO_CB_REG, | |||
RT_ERROR_STREAM_DUPLICATE, | |||
RT_ERROR_STREAM_NOT_EXIST, | |||
RT_ERROR_SQ_NO_EXIST_SQ_TO_REUSE, | |||
RT_ERROR_SQID_FULL, | |||
RT_ERROR_MODEL_BASE = 0x07040000, | |||
RT_ERROR_MODEL_NULL, | |||
RT_ERROR_MODEL_NEW, | |||
RT_ERROR_MODEL_CONTEXT, | |||
RT_ERROR_MODEL_ENDGRAPH, | |||
RT_ERROR_MODEL_STREAM, | |||
RT_ERROR_MODEL_EXCUTOR, | |||
RT_ERROR_MODEL_SETUP, | |||
RT_ERROR_MODEL_ID, | |||
RT_ERROR_MODEL_EXE_FAILED, | |||
RT_ERROR_END_OF_SEQUENCE, // end of sequence | |||
RT_ERROR_MODEL_EXIT, | |||
RT_ERROR_MODEL_EXIT_STREAM_UNBIND, | |||
RT_ERROR_MODEL_EXIT_ID, | |||
RT_ERROR_MODEL_ABORT_NORMAL, | |||
RT_ERROR_EVENT_BASE = 0x07050000, | |||
RT_ERROR_EVENT_NULL, | |||
RT_ERROR_EVENT_NEW, | |||
RT_ERROR_EVENT_RECORDER_NULL, | |||
RT_ERROR_EVENT_TIMESTAMP_INVALID, | |||
RT_ERROR_EVENT_TIMESTAMP_REVERSAL, | |||
RT_ERROR_EVENT_NOT_COMPLETE, | |||
RT_ERROR_NOTIFY_BASE = 0x07060000, | |||
RT_ERROR_NOTIFY_NULL, | |||
RT_ERROR_NOTIFY_NEW, | |||
RT_ERROR_NOTIFY_TYPE, | |||
RT_ERROR_NOTIFY_NOT_COMPLETE, | |||
RT_ERROR_CONTEXT_BASE = 0x07070000, | |||
RT_ERROR_CONTEXT_NULL, | |||
RT_ERROR_CONTEXT_NEW, | |||
RT_ERROR_CONTEXT_DEL, | |||
RT_ERROR_CONTEXT_DEFAULT_STREAM_NULL, | |||
RT_ERROR_CONTEXT_ONLINE_STREAM_NULL, | |||
RT_ERROR_KERNEL_BASE = 0x07080000, | |||
RT_ERROR_KERNEL_NULL, | |||
RT_ERROR_KERNEL_NEW, | |||
RT_ERROR_KERNEL_LOOKUP, | |||
RT_ERROR_KERNEL_NAME, | |||
RT_ERROR_KERNEL_TYPE, | |||
RT_ERROR_KERNEL_OFFSET, | |||
RT_ERROR_KERNEL_DUPLICATE, | |||
RT_ERROR_KERNEL_UNREGISTERING, | |||
RT_ERROR_PROGRAM_BASE = 0x07090000, | |||
RT_ERROR_PROGRAM_NULL, | |||
RT_ERROR_PROGRAM_NEW, | |||
RT_ERROR_PROGRAM_DATA, | |||
RT_ERROR_PROGRAM_SIZE, | |||
RT_ERROR_PROGRAM_MEM_TYPE, | |||
RT_ERROR_PROGRAM_MACHINE_TYPE, | |||
RT_ERROR_PROGRAM_USEOUT, | |||
RT_ERROR_MODULE_BASE = 0x070a0000, | |||
RT_ERROR_MODULE_NULL, | |||
RT_ERROR_MODULE_NEW, | |||
RT_ERROR_INSTANCE_BASE = 0x070b0000, | |||
RT_ERROR_INSTANCE_NULL, | |||
RT_ERROR_INSTANCE_NEW, | |||
RT_ERROR_INSTANCE_VERSION, | |||
RT_ERROR_API_BASE = 0x070c0000, | |||
RT_ERROR_API_NULL, | |||
RT_ERROR_API_NEW, | |||
RT_ERROR_DATADUMP_BASE = 0x070d0000, | |||
RT_ERROR_DATADUMP_NULL, | |||
RT_ERROR_DATADUMP_NEW, | |||
RT_ERROR_DATADUMP_TIME, | |||
RT_ERROR_DATADUMP_FILE, | |||
RT_ERROR_DATADUMP_ADDRESS, | |||
RT_ERROR_DATADUMP_LOAD_FAILED, | |||
RT_ERROR_DUMP_ADDR_SET_FAILED, | |||
RT_ERROR_PROF_BASE = 0x070e0000, | |||
RT_ERROR_PROF_NULL, | |||
RT_ERROR_PROF_NEW, | |||
RT_ERROR_PROF_START, | |||
RT_ERROR_PROF_DEVICE_MEM, | |||
RT_ERROR_PROF_HOST_MEM, | |||
RT_ERROR_PROF_SET_DIR, | |||
RT_ERROR_PROF_OPER, | |||
RT_ERROR_PROF_FULL, | |||
RT_ERROR_PROF_NAME, | |||
RT_ERROR_PCTRACE_BASE = 0x070f0000, | |||
RT_ERROR_PCTRACE_NULL, | |||
RT_ERROR_PCTRACE_NEW, | |||
RT_ERROR_PCTRACE_TIME, | |||
RT_ERROR_PCTRACE_FILE, | |||
RT_ERROR_TASK_BASE = 0x07100000, | |||
RT_ERROR_TASK_NULL, | |||
RT_ERROR_TASK_NEW, | |||
RT_ERROR_TASK_TYPE, | |||
RT_ERROR_TASK_ALLOCATOR, | |||
RT_ERROR_COMMON_BASE = 0x07110000, | |||
RT_ERROR_INVALID_VALUE, // RT_ERROR_INPUT_INVALID | |||
RT_ERROR_MEMORY_ADDRESS_UNALIGNED, | |||
RT_ERROR_SEC_HANDLE, | |||
RT_ERROR_OS_HANDLE, | |||
RT_ERROR_MUTEX_LOCK, | |||
RT_ERROR_MUTEX_UNLOCK, | |||
RT_ERROR_CALLOC, | |||
RT_ERROR_POOL_RESOURCE, | |||
RT_ERROR_TRANS_ARGS, | |||
RT_ERROR_METADATA, | |||
RT_ERROR_LOST_HEARTBEAT, | |||
RT_ERROR_REPORT_TIMEOUT, | |||
RT_ERROR_FEATURE_NOT_SUPPROT, | |||
RT_ERROR_MEMORY_ALLOCATION, | |||
RT_ERROR_MEMORY_FREE, | |||
RT_ERROR_INVALID_MEMORY_TYPE, | |||
RT_ERROR_DEBUG_BASE = 0x07120000, | |||
RT_ERROR_DEBUG_NULL, | |||
RT_ERROR_DEBUG_NEW, | |||
RT_ERROR_DEBUG_SIGNAL, | |||
RT_ERROR_DEBUG_OPEN, | |||
RT_ERROR_DEBUG_WRITE, | |||
RT_ERROR_DEBUG_REGISTER_FAILED, | |||
RT_ERROR_DEBUG_UNREGISTER_FAILED, | |||
RT_ERROR_ENGINE_BASE = 0x07130000, | |||
RT_ERROR_ENGINE_NULL, | |||
RT_ERROR_ENGINE_NEW, | |||
RT_ERROR_ENGINE_THREAD, | |||
RT_ERROR_LABEL_BASE = 0x07140000, | |||
RT_ERROR_LABEL_NULL, | |||
RT_ERROR_LABEL_NEW, | |||
RT_ERROR_LABEL_CONTEXT, | |||
RT_ERROR_LABEL_STREAM, | |||
RT_ERROR_LABEL_MODEL, | |||
RT_ERROR_LABEL_ALLOCATOR, | |||
RT_ERROR_LABEL_FREE, | |||
RT_ERROR_LABEL_SET, | |||
RT_ERROR_LABEL_ID, | |||
RT_ERROR_TSFW_BASE = 0x07150000, | |||
RT_ERROR_TSFW_UNKNOWN, | |||
RT_ERROR_TSFW_NULL_PTR, | |||
RT_ERROR_TSFW_ILLEGAL_AI_CORE_ID, | |||
RT_ERROR_TSFW_ILLEGAL_PARAM, | |||
RT_ERROR_TSFW_TASK_CMD_QUEUE_FULL, | |||
RT_ERROR_TSFW_TASK_CMD_QUEUE_EMPTY, | |||
RT_ERROR_TSFW_TASK_REPORT_QUEUE_FULL, | |||
RT_ERROR_TSFW_TASK_REPORT_QUEUE_EMPTY, | |||
RT_ERROR_TSFW_TASK_NODE_BUFF_ALL_OCCUPYED, | |||
RT_ERROR_TSFW_TASK_NODE_BUFF_ALL_FREED, | |||
RT_ERROR_TSFW_L2_MEM_INSUFFICIENT_SPACE, | |||
RT_ERROR_TSFW_L2_MALLOC_FAILED, | |||
RT_ERROR_TSFW_DMA_CHANNEL_ALL_OCCUPYED, | |||
RT_ERROR_TSFW_MEMCPY_OP_FAILED, | |||
RT_ERROR_TSFW_BS_SLOT_ALL_OCCUPYED, | |||
RT_ERROR_TSFW_TBS_SLOT_REPEAT_FREE, | |||
RT_ERROR_TSFW_PRIORITY_TASK_LIST_FULL, | |||
RT_ERROR_TSFW_PRIORITY_TASK_LIST_EMPTY, | |||
RT_ERROR_TSFW_NO_STREAM_LIST_NEED_TO_BE_PROCESSED, | |||
RT_ERROR_TSFW_REPEAT_MARK_STREAM_NEED_SERVICE, | |||
RT_ERROR_TSFW_SYS_DMA_CHANNEL_ALL_OCCUPAPYED, | |||
RT_ERROR_TSFW_NO_HBML2TASKNODE_FOUND, | |||
RT_ERROR_TSFW_SQNODE_NODE_SLOT_ALL_OCCUPAPYED, | |||
RT_ERROR_TSFW_CQNODE_NODE_SLOT_ALL_OCCUPAPYED, | |||
RT_ERROR_TSFW_SQNODE_NOT_ENOUGH, | |||
RT_ERROR_TSFW_SQNODE_SLOT_REPEAT_FREE, | |||
RT_ERROR_TSFW_CQNODE_SLOT_REPEAT_FREE, | |||
RT_ERROR_TSFW_CQ_REPORT_FAILED, | |||
RT_ERROR_TSFW_SYS_DMA_RESET_SUCCESS, | |||
RT_ERROR_TSFW_SYS_DMA_RESET_FAILED, | |||
RT_ERROR_TSFW_SYS_DMA_TRNSFER_FAILED, | |||
RT_ERROR_TSFW_SYS_DMA_MEMADDRALIGN_FAILED, | |||
RT_ERROR_TSFW_SYS_DMA_ERROR_QUEUE_FULL, | |||
RT_ERROR_TSFW_SYS_DMA_ERROR_QUEUE_EMPTY, | |||
RT_ERROR_TSFW_TIMER_EVENT_FULL, | |||
RT_ERROR_TSFW_TASK_L2_DESC_ENTRY_NOT_ENOUGH, | |||
RT_ERROR_TSFW_AICORE_TIMEOUT, | |||
RT_ERROR_TSFW_AICORE_EXCEPTION, | |||
RT_ERROR_TSFW_AICORE_TRAP_EXCEPTION, | |||
RT_ERROR_TSFW_AICPU_TIMEOUT, | |||
RT_ERROR_TSFW_SDMA_L2_TO_DDR_MALLOC_FAIL, | |||
RT_ERROR_TSFW_AICPU_EXCEPTION, | |||
RT_ERROR_TSFW_AICPU_DATADUMP_RSP_ERR, | |||
RT_ERROR_TSFW_AICPU_MODEL_RSP_ERR, | |||
RT_ERROR_TSFW_REPEAT_ACTIVE_MODEL_STREAM, | |||
RT_ERROR_TSFW_REPEAT_NOTIFY_WAIT, | |||
RT_ERROR_TSFW_DEBUG_INVALID_SQCQ, | |||
RT_ERROR_TSFW_DEBUG_WRONG_COMMAND_TYPE, | |||
RT_ERROR_TSFW_DEBUG_CMD_PROCESS, | |||
RT_ERROR_TSFW_DEBUG_INVALID_DEVICE_STATUS, | |||
RT_ERROR_TSFW_DEBUG_NOT_IN_DEBUG_STATUS, | |||
RT_ERROR_TSFW_DEBUG_INVALID_TASK_STATUS, | |||
RT_ERROR_TSFW_DEBUG_TASK_EMPTY, | |||
RT_ERROR_TSFW_DEBUG_TASK_FULL, | |||
RT_ERROR_TSFW_DEBUG_TASK_NOT_EXIST, | |||
RT_ERROR_TSFW_DEBUG_AI_CORE_FULL, | |||
RT_ERROR_TSFW_DEBUG_AI_CORE_NOT_EXIST, | |||
RT_ERROR_TSFW_DEBUG_AI_CORE_EXCEPTION, | |||
RT_ERROR_TSFW_DEBUG_AI_CORE_TIMEOUT, | |||
RT_ERROR_TSFW_DEBUG_BREAKPOINT_FULL, | |||
RT_ERROR_TSFW_DEBUG_READ_ERROR, | |||
RT_ERROR_TSFW_DEBUG_WRITE_FAIL, | |||
RT_ERROR_TSFW_QUEUE_FULL, | |||
RT_ERROR_TSFW_QUEUE_EMPTY, | |||
RT_ERROR_TSFW_QUEUE_ALLOC_MEM_FAIL, | |||
RT_ERROR_TSFW_QUEUE_DATA_SIZE_UNMATCH, | |||
RT_ERROR_TSFW_PCIE_DMA_INVLD_CPY_TYPE, | |||
RT_ERROR_TSFW_INVLD_CPY_DIR, | |||
RT_ERROR_TSFW_PCIE_DMA_INVLD_CQ_DES, | |||
RT_ERROR_TSFW_PCIE_DMA_CPY_ERR, | |||
RT_ERROR_TSFW_PCIE_DMA_LNK_CHN_BUSY, | |||
RT_ERROR_TSFW_PROFILE_BUFF_FULL, | |||
RT_ERROR_TSFW_PROFILE_MODE_CONFLICT, | |||
RT_ERROR_TSFW_PROFILE_OTHER_PID_ON, | |||
RT_ERROR_TSFW_SCHD_AIC_TASK_PRELOAD_FAILED, | |||
RT_ERROR_TSFW_TSCPU_CLOSE_FAILED, | |||
RT_ERROR_TSFW_EXPECT_FAIL, | |||
RT_ERROR_TSFW_REPEAT_MODEL_STREAM, | |||
RT_ERROR_TSFW_STREAM_MODEL_UNBIND, | |||
RT_ERROR_TSFW_MODEL_EXE_FAILED, | |||
RT_ERROR_TSFW_IPC_SEND_FAILED, | |||
RT_ERROR_TSFW_IPC_PROC_REG_FAILED, | |||
RT_ERROR_TSFW_STREAM_FULL, | |||
RT_ERROR_TSFW_END_OF_SEQUENCE, | |||
RT_ERROR_TSFW_SWITCH_STREAM_LABEL, | |||
RT_ERROR_TSFW_TRANS_SQE_FAIL, | |||
RT_ERROR_TSFW_RESERVED, | |||
RT_ERROR_SUBSCRIBE_BASE = 0x07160000, | |||
RT_ERROR_SUBSCRIBE_NULL, | |||
RT_ERROR_SUBSCRIBE_NEW, | |||
RT_ERROR_SUBSCRIBE_STREAM, | |||
RT_ERROR_SUBSCRIBE_THREAD, | |||
RT_ERROR_SUBSCRIBE_GROUP, | |||
RT_ERROR_GROUP_BASE = 0x07170000, | |||
RT_ERROR_GROUP_NOT_SET, | |||
RT_ERROR_GROUP_NOT_CREATE, | |||
RT_ERROR_RESERVED = 0x07ff0000, | |||
}rtError_t; | |||
typedef int32_t rtError_t; | |||
static const int32_t RT_ERROR_NONE = 0; // success | |||
/** | |||
* @ingroup dvrt_base | |||
@@ -387,10 +87,20 @@ typedef struct rtExceptionInfo { | |||
uint32_t deviceid; | |||
} rtExceptionInfo; | |||
typedef struct rtTaskFailInfo { | |||
uint32_t taskid; | |||
uint32_t streamid; | |||
uint32_t tid; | |||
uint32_t deviceid; | |||
uint32_t retcode; | |||
} rtTaskFailInfo; | |||
typedef void (*rtErrorCallback)(rtExceptionType); | |||
typedef void (*rtTaskFailCallback)(rtExceptionInfo *exceptionInfo); | |||
typedef void (*rtTaskFailCallbackByModule)(rtTaskFailInfo *exceptionInfo); | |||
typedef void (*rtDeviceStateCallback)(uint32_t devId, bool isOpen); | |||
/** | |||
@@ -447,6 +157,12 @@ RTS_API rtError_t rtProfilerStop(uint64_t profConfig, int32_t numsDev, uint32_t* | |||
*/ | |||
RTS_API rtError_t rtProfilerTrace(uint64_t id, bool notify, uint32_t flags, rtStream_t stream); | |||
/** | |||
* @ingroup profiling_base | |||
* @brief ts set profiling reporter callback. | |||
*/ | |||
RTS_API rtError_t rtSetMsprofReporterCallback(MsprofReporterCallback callback); | |||
/** | |||
* @ingroup dvrt_base | |||
* @brief Returns the last error from a runtime call. | |||
@@ -485,6 +201,16 @@ RTS_API rtError_t rtSetTaskFailCallback(rtTaskFailCallback callback); | |||
*/ | |||
RTS_API rtError_t rtRegDeviceStateCallback(const char *regName, rtDeviceStateCallback callback); | |||
/** | |||
* @ingroup dvrt_base | |||
* @brief register callback for fail task | |||
* @param [in] uniName unique register name, can't be null | |||
* @param [in] callback fail task callback function | |||
* @param [out] NA | |||
* @return RT_ERROR_NONE for ok | |||
*/ | |||
RTS_API rtError_t rtRegTaskFailCallbackByModule(const char *moduleName, rtTaskFailCallbackByModule callback); | |||
/** | |||
* @ingroup dvrt_base | |||
* @brief notify handle. | |||
@@ -121,14 +121,6 @@ typedef struct tagRtMemoryConfig { | |||
typedef struct tagRtPlatformConfig { uint32_t platformConfig; } rtPlatformConfig_t; | |||
/** | |||
* @ingroup | |||
* @brief get platform | |||
* @param [in] platForm | |||
* @return platForm | |||
*/ | |||
RTS_API rtError_t rtGetPlatformConfig(rtPlatformConfig_t *platForm); | |||
/** | |||
* @ingroup | |||
* @brief get AI core count | |||
@@ -169,13 +161,6 @@ RTS_API rtError_t rtGetAiCoreMemoryRates(rtAiCoreMemoryRates_t *aiCoreMemoryRate | |||
*/ | |||
RTS_API rtError_t rtGetMemoryConfig(rtMemoryConfig_t *memoryConfig); | |||
/** | |||
* @ingroup | |||
* @brief set platform in gen ctx | |||
* @param [in] platForm | |||
* @return RT_ERROR_NONE for ok, errno for failed | |||
*/ | |||
RTS_API rtError_t rtSetPlatformType(rtPlatformType_t platformType); | |||
/** | |||
* @ingroup | |||
@@ -185,6 +170,14 @@ RTS_API rtError_t rtSetPlatformType(rtPlatformType_t platformType); | |||
*/ | |||
RTS_API rtError_t rtMemGetL2Info(rtStream_t stream, void **ptr, uint32_t *size); | |||
/** | |||
* @ingroup | |||
* @brief get runtime version. The version is returned as (1000 major + 10 minor). For example, RUNTIME 9.2 would be represented by 9020. | |||
* @param [out] runtimeVersion | |||
* @return RT_ERROR_NONE for ok | |||
* @return RT_ERROR_INVALID_VALUE for error input | |||
*/ | |||
RTS_API rtError_t rtGetRuntimeVersion(uint32_t *runtimeVersion); | |||
#if defined(__cplusplus) && !defined(COMPILE_OMG_PACKAGE) | |||
} | |||
#endif | |||
@@ -330,12 +330,12 @@ RTS_API rtError_t rtGetPairDevicesInfo(uint32_t devId, uint32_t otherDevId, int3 | |||
FEATURE_TYPE_MEMCPY = 0, | |||
FEATURE_TYPE_RSV, | |||
} rtFeatureType_t; | |||
* @param [in] infoType info type | |||
* @param [in] featureInfo info type | |||
typedef enum tagMemcpyInfo { | |||
MEMCPY_INFO_SUPPORT_ZEROCOPY = 0, | |||
MEMCPY_INFO _RSV, | |||
} rtMemcpyInfo_t; | |||
* @param [out] value the capability info | |||
* @param [out] value the capability info RT_CAPABILITY_SUPPORT or RT_CAPABILITY_NOT_SUPPORT | |||
* @return RT_ERROR_NONE for ok | |||
*/ | |||
RTS_API rtError_t rtGetRtCapability(rtFeatureType_t featureType, int32_t featureInfo, int64_t *value); | |||
@@ -28,4 +28,4 @@ | |||
#include "rt_model.h" | |||
#include "stream.h" | |||
#endif // __CCE_RUNTIME_RT_H__ | |||
#endif // __CCE_RUNTIME_RT_H__ |
@@ -34,9 +34,16 @@ using TDT_StatusT = uint32_t; | |||
typedef uint32_t TDT_StatusT; | |||
#endif | |||
#define LINUX 0 | |||
#define WINDOWS 1 | |||
#ifndef TDT_LIB_EXPORT | |||
#if(TARGET_SYSTEM_NAME == WINDOWS) | |||
#define TDT_LIB_EXPORT __declspec(dllexport) | |||
#else | |||
#define TDT_LIB_EXPORT __attribute__((visibility("default"))) | |||
#endif | |||
#endif | |||
/** | |||
* @ingroup tdt status. | |||
* | |||
@@ -23,6 +23,7 @@ | |||
#include <mutex> | |||
#include "tdt/status.h" | |||
#include "tdt/data_common.h" | |||
#include "toolchain/prof_callback.h" | |||
#ifdef __cplusplus | |||
extern "C" { | |||
@@ -37,7 +38,7 @@ extern "C" { | |||
* Used for the Framework process to communicate with the TSDDaemon process, | |||
* and notify TSD to complete the initialization of other processes | |||
* | |||
* @param phyDeviceId [IN] type #unsigned int. Physical device ID | |||
* @param logicDeviceId [IN] type #unsigned int. Logic device ID | |||
* @param rankSize [IN] type #unsigned int. The rankSize of the training. | |||
* The default value is 1. When rankSize is greater than 1, | |||
* HCCP will be pulled to perform set communication related operations. | |||
@@ -49,7 +50,7 @@ extern "C" { | |||
* @li tsd_client.h: Header file where the interface declaration is located. | |||
* @li data_common.h: Header file where 'TDT_StatusT' defined | |||
*/ | |||
TDT_LIB_EXPORT TDT_StatusT TsdOpen(const uint32_t phyDeviceId, const uint32_t rankSize); | |||
TDT_LIB_EXPORT TDT_StatusT TsdOpen(const uint32_t logicDeviceId, const uint32_t rankSize); | |||
/** | |||
* @ingroup Close | |||
@@ -67,7 +68,7 @@ TDT_LIB_EXPORT TDT_StatusT TsdOpen(const uint32_t phyDeviceId, const uint32_t ra | |||
* @li tsd_client.h: Header file where the interface declaration is located. | |||
* @li data_common.h: Header file where 'TDT_StatusT' defined | |||
*/ | |||
TDT_LIB_EXPORT TDT_StatusT TsdClose(const uint32_t phyDeviceId); | |||
TDT_LIB_EXPORT TDT_StatusT TsdClose(const uint32_t logicDeviceId); | |||
/** | |||
* @ingroup UpdateProfilingMode | |||
@@ -85,7 +86,26 @@ TDT_LIB_EXPORT TDT_StatusT TsdClose(const uint32_t phyDeviceId); | |||
* @li tsd_client.h: Header file where the interface declaration is located. | |||
* @li data_common.h: Header file where 'TDT_StatusT' defined | |||
*/ | |||
TDT_LIB_EXPORT TDT_StatusT UpdateProfilingMode(const uint32_t phyDeviceId, const uint32_t flag); | |||
TDT_LIB_EXPORT TDT_StatusT UpdateProfilingMode(const uint32_t logicDeviceId, const uint32_t flag); | |||
/** | |||
* @ingroup TsdSetMsprofReporterCallback | |||
* @brief 用于推理场景下设置aicpu的profilng的callback函数 | |||
* | |||
* @par Function | |||
* 设置offline模式下aicpu_sd进程的profiling的callback函数 | |||
* | |||
* @param callback [IN] type #MsprofReporterCallback. 回调函数 | |||
* @retval TDT_OK Success | |||
* @retval OtherValues Failure | |||
* | |||
* @par Dependency | |||
* @li libtsdclient.so: Library to which the interface belongs. | |||
* @li tsd_client.h: Header file where the interface declaration is located. | |||
* @li data_common.h: Header file where 'TDT_StatusT' defined | |||
* @li prof_callback.h: Headerfile where 'MsprofReporterCallback' defined | |||
*/ | |||
TDT_LIB_EXPORT TDT_StatusT TsdSetMsprofReporterCallback(MsprofReporterCallback callback); | |||
/** | |||
* @ingroup CreateCmdParameterObj | |||
@@ -0,0 +1,135 @@ | |||
/** | |||
* Copyright 2020-2020 Huawei Technologies Co., Ltd | |||
* | |||
* Licensed under the Apache License, Version 2.0 (the "License"); | |||
* you may not use this file except in compliance with the License. | |||
* You may obtain a copy of the License at | |||
* | |||
* http://www.apache.org/licenses/LICENSE-2.0 | |||
* | |||
* Unless required by applicable law or agreed to in writing, software | |||
* distributed under the License is distributed on an "AS IS" BASIS, | |||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |||
* See the License for the specific language governing permissions and | |||
* limitations under the License. | |||
* | |||
* @file prof_callback.h | |||
* @brief declaraion of profiling callbacks | |||
*/ | |||
#ifndef MSPROFILER_PROF_CALLBACK_H_ | |||
#define MSPROFILER_PROF_CALLBACK_H_ | |||
#ifdef __cplusplus | |||
extern "C" { | |||
#endif // __cplusplus | |||
#include "stddef.h" | |||
#include "stdint.h" | |||
/** | |||
* @name MsprofErrorCode | |||
* @brief error code | |||
*/ | |||
enum MsprofErrorCode { | |||
MSPROF_ERROR_NONE = 0, | |||
MSPROF_ERROR_MEM_NOT_ENOUGH, | |||
MSPROF_ERROR_GET_ENV, | |||
MSPROF_ERROR_CONFIG_INVALID, | |||
MSPROF_ERROR_ACL_JSON_OFF, | |||
MSPROF_ERROR, | |||
}; | |||
#define MSPROF_ENGINE_MAX_TAG_LEN (31) | |||
/** | |||
* @name ReporterData | |||
* @brief struct of data to report | |||
*/ | |||
struct ReporterData { | |||
char tag[MSPROF_ENGINE_MAX_TAG_LEN + 1]; // the sub-type of the module, data with different tag will be writen | |||
int deviceId; // the index of device | |||
size_t dataLen; // the length of send data | |||
unsigned char *data; // the data content | |||
}; | |||
/** | |||
* @name MsprofReporterModuleId | |||
* @brief module id of data to report | |||
*/ | |||
enum MsprofReporterModuleId { | |||
MSPROF_MODULE_DATA_PREPROCESS = 0, // DATA_PREPROCESS | |||
MSPROF_MODULE_HCCL, // HCCL | |||
MSPROF_MODULE_ACL, // AclModule | |||
MSPROF_MODULE_FRAMEWORK, // Framework | |||
MSPROF_MODULE_RUNTIME // runtime | |||
}; | |||
/** | |||
* @name MsprofReporterCallbackType | |||
* @brief reporter callback request type | |||
*/ | |||
enum MsprofReporterCallbackType { | |||
MSPROF_REPORTER_REPORT = 0, // report data | |||
MSPROF_REPORTER_INIT, // init reporter | |||
MSPROF_REPORTER_UNINIT, // uninit reporter | |||
}; | |||
/** | |||
* @name MsprofReporterCallback | |||
* @brief callback to start reporter/stop reporter/report date | |||
* @param moduleId [IN] enum MsprofReporterModuleId | |||
* @param type [IN] enum MsprofReporterCallbackType | |||
* @param data [IN] callback data (nullptr on INTI/UNINIT) | |||
* @param len [IN] callback data size (0 on INIT/UNINIT) | |||
* @return enum MsprofErrorCode | |||
*/ | |||
typedef int32_t (*MsprofReporterCallback)(uint32_t moduleId, uint32_t type, void *data, uint32_t len); | |||
#define MSPROF_OPTIONS_DEF_LEN_MAX (2048) | |||
/** | |||
* @name MsprofGeOptions | |||
* @brief struct of MSPROF_CTRL_INIT_GE_OPTIONS | |||
*/ | |||
struct MsprofGeOptions { | |||
char jobId[MSPROF_OPTIONS_DEF_LEN_MAX]; | |||
char options[MSPROF_OPTIONS_DEF_LEN_MAX]; | |||
}; | |||
/** | |||
* @name MsprofCtrlCallbackType | |||
* @brief ctrl callback request type | |||
*/ | |||
enum MsprofCtrlCallbackType { | |||
MSPROF_CTRL_INIT_ACL_ENV = 0, // start profiling with acl env | |||
MSPROF_CTRL_INIT_ACL_JSON, // start profiling with acl.json | |||
MSPROF_CTRL_INIT_GE_OPTIONS, // start profiling with ge env and options | |||
MSPROF_CTRL_FINALIZE // stop profiling | |||
}; | |||
/** | |||
* @name MsprofCtrlCallback | |||
* @brief callback to start/stop profiling | |||
* @param type [IN] enum MsprofCtrlCallbackType | |||
* @param data [IN] callback data | |||
* @param len [IN] callback data size | |||
* @return enum MsprofErrorCode | |||
*/ | |||
typedef int32_t (*MsprofCtrlCallback)(uint32_t type, void *data, uint32_t len); | |||
/** | |||
* @name MsprofSetDeviceCallback | |||
* @brief callback to notify set/reset device | |||
* @param devId [IN] device id | |||
* @param isOpenDevice [IN] true: set device, false: reset device | |||
*/ | |||
typedef void (*MsprofSetDeviceCallback)(uint32_t devId, bool isOpenDevice); | |||
#ifdef __cplusplus | |||
} | |||
#endif | |||
#endif // MSPROFILER_PROF_CALLBACK_H_ |
@@ -16,7 +16,17 @@ | |||
#ifndef MSPROF_ENGINE_PROF_REPORTER_H_ | |||
#define MSPROF_ENGINE_PROF_REPORTER_H_ | |||
#ifndef OS_TYPE | |||
#define OS_TYPE 0 | |||
#endif // OS_TYPE | |||
#if (OS_TYPE != LINUX) | |||
#define MSVP_PROF_API __declspec(dllexport) | |||
#else | |||
#define MSVP_PROF_API __attribute__((visibility("default"))) | |||
#endif | |||
#include "prof_callback.h" | |||
/** | |||
* @file prof_reporter.h | |||
@@ -25,20 +35,6 @@ | |||
*/ | |||
namespace Msprof { | |||
namespace Engine { | |||
/// the max tag length | |||
#define MSPROF_ENGINE_MAX_TAG_LEN (31) | |||
/** | |||
* @ingroup reporter | |||
* @brief struct ReporterData | |||
* the sturct of the data send to libmsprof | |||
*/ | |||
struct ReporterData { | |||
char tag[MSPROF_ENGINE_MAX_TAG_LEN + 1]; ///< the sub-type of the module, data with different tag will be writen | |||
int deviceId; ///< the physical id of device | |||
size_t dataLen; ///< the length of send data | |||
unsigned char *data; ///< the data content | |||
}; | |||
/** | |||
* @ingroup reporter | |||
* @brief class Reporter | |||
@@ -86,4 +82,4 @@ class MSVP_PROF_API Reporter { | |||
} // namespace Engine | |||
} // namespace Msprof | |||
#endif // MSPROF_ENGINE_PROF_REPORTER_H_ | |||
#endif // MSPROF_ENGINE_PROF_REPORTER_H_ |
@@ -18,7 +18,9 @@ | |||
#define D_SYSLOG_H_ | |||
#ifdef __cplusplus | |||
#ifndef LOG_CPP | |||
extern "C" { | |||
#endif | |||
#endif // __cplusplus | |||
#ifndef LINUX | |||
@@ -105,6 +107,7 @@ extern "C" { | |||
#define SECURITY_LOG_MASK (0x00100000) | |||
#define RUN_LOG_MASK (0x01000000) | |||
#define OPERATION_LOG_MASK (0x10000000) | |||
#define RESERVERD_LENGTH 52 | |||
typedef struct tagDCODE { | |||
const char *cName; | |||
@@ -116,6 +119,18 @@ typedef struct tagKV { | |||
char *value; | |||
} KeyValue; | |||
typedef enum { | |||
APPLICATION = 0, | |||
SYSTEM | |||
} ProcessType; | |||
typedef struct { | |||
ProcessType type; | |||
unsigned int pid; | |||
unsigned int deviceId; | |||
char reserved[RESERVERD_LENGTH]; | |||
} LogAttr; | |||
/** | |||
* @ingroup slog | |||
* | |||
@@ -228,6 +243,14 @@ DLL_EXPORT int dlog_setlevel(int moduleId, int level, int enableEvent); | |||
*/ | |||
DLL_EXPORT int CheckLogLevel(int moduleId, int logLevel); | |||
/** | |||
* @ingroup slog | |||
* @brief DlogSetAttr: set log attr, default pid is 0, default device id is 0, default process type is APPLICATION | |||
* @param [in]logAttr: attr info, include pid(must be larger than 0), process type and device id(chip ID) | |||
* @return: 0: SUCCEED, others: FAILED | |||
*/ | |||
DLL_EXPORT int DlogSetAttr(LogAttr logAttr); | |||
/** | |||
* @ingroup slog | |||
* @brief dlog_error: print error log | |||
@@ -367,6 +390,8 @@ void DlogInner(int moduleId, int level, const char *fmt, ...); | |||
void DlogWithKVInner(int moduleId, int level, KeyValue *pstKVArray, int kvNum, const char *fmt, ...); | |||
#ifdef __cplusplus | |||
#ifndef LOG_CPP | |||
} | |||
#endif // LOG_CPP | |||
#endif // __cplusplus | |||
#endif // D_SYSLOG_H_ |