1 Star 0 Fork 146

镇亮/acl

forked from CANN/acl 
加入 Gitee
与超过 1200万 开发者一起发现、参与优秀开源项目,私有仓库也完全免费 :)
免费加入
文件
克隆/下载
profiling_manager.cpp 7.68 KB
一键复制 编辑 原始数据 按行查看 历史
/**
* @file profiling_manager.cpp
*
* Copyright (C) Huawei Technologies Co., Ltd. 2019-2020. All Rights Reserved.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*/
#include "profiling_manager.h"
#include <thread>
#include <cstring>
#include <sstream>
#include <securec.h>
#include "framework/common/ge_format_util.h"
#include "framework/common/profiling_definitions.h"
#include "mmpa/mmpa_api.h"
#include "acl/acl_rt.h"
#include "common/log_inner.h"
namespace {
const std::string ACL_PROFILING_MODULE = "AclModule";
}
namespace acl {
AclProfilingManager::AclProfilingManager() {}
AclProfilingManager::~AclProfilingManager() {}
AclProfilingManager &AclProfilingManager::GetInstance()
{
static AclProfilingManager profilingManager;
return profilingManager;
}
aclError AclProfilingManager::Init()
{
const std::lock_guard<std::mutex> lk(mutex_);
if (reporterCallback_ == nullptr) {
ACL_LOG_INNER_ERROR("[Check][ReporterCallback]prof reporter hasn't registered yet");
return ACL_ERROR_PROFILING_FAILURE;
}
const int32_t result = reporterCallback_(static_cast<uint32_t>(MSPROF_MODULE_ACL),
static_cast<uint32_t>(MSPROF_REPORTER_INIT), nullptr, 0U);
if (result != 0) {
ACL_LOG_INNER_ERROR("[Init][ProfEngine]init acl profiling engine failed, result = %d", result);
return ACL_ERROR_PROFILING_FAILURE;
}
isProfiling_ = true;
return ACL_SUCCESS;
}
aclError AclProfilingManager::UnInit()
{
const std::lock_guard<std::mutex> lk(mutex_);
if (reporterCallback_ == nullptr) {
ACL_LOG_INNER_ERROR("[Check][ReporterCallback]prof reporter hasn't registered yet");
return ACL_ERROR_PROFILING_FAILURE;
}
const int32_t result = reporterCallback_(static_cast<uint32_t>(MSPROF_MODULE_ACL),
static_cast<uint32_t>(MSPROF_REPORTER_UNINIT), nullptr, 0U);
if (result != MSPROF_ERROR_NONE) {
ACL_LOG_CALL_ERROR("[Uninit][ProfEngine]Uninit profiling engine failed, result = %d", result);
return ACL_ERROR_PROFILING_FAILURE;
}
isProfiling_ = false;
return ACL_SUCCESS;
}
bool AclProfilingManager::IsDeviceListEmpty() const
{
return deviceList_.empty();
}
aclError AclProfilingManager::ProfilingData(ReporterData &data)
{
const std::lock_guard<std::mutex> lk(mutex_);
if (reporterCallback_ == nullptr) {
return ACL_ERROR_PROFILING_FAILURE;
} else {
if (reporterCallback_(static_cast<uint32_t>(MSPROF_MODULE_ACL), static_cast<uint32_t>(MSPROF_REPORTER_REPORT),
&data, sizeof(ReporterData)) != 0) {
return ACL_ERROR_PROFILING_FAILURE;
}
}
return ACL_SUCCESS;
}
aclError AclProfilingManager::AddDeviceList(const uint32_t *const deviceIdList, const uint32_t deviceNums)
{
if (deviceNums == 0U) {
return ACL_SUCCESS;
}
ACL_REQUIRES_NOT_NULL(deviceIdList);
for (size_t devId = 0U; devId < deviceNums; devId++) {
if (deviceList_.count(*(deviceIdList + devId)) == 0U) {
(void)deviceList_.insert(*(deviceIdList + devId));
ACL_LOG_INFO("device id %u is successfully added in acl profiling", *(deviceIdList + devId));
}
}
return ACL_SUCCESS;
}
aclError AclProfilingManager::RemoveDeviceList(const uint32_t *const deviceIdList, const uint32_t deviceNums)
{
if (deviceNums == 0U) {
return ACL_SUCCESS;
}
ACL_REQUIRES_NOT_NULL(deviceIdList);
for (size_t devId = 0U; devId < deviceNums; devId++) {
const auto iter = deviceList_.find(*(deviceIdList + devId));
if (iter != deviceList_.end()) {
(void)deviceList_.erase(iter);
}
}
return ACL_SUCCESS;
}
bool AclProfilingManager::IsDeviceEnable(const uint32_t &deviceId) const
{
return deviceList_.count(deviceId) > 0U;
}
AclProfilingReporter::AclProfilingReporter(const char_t *const funcName, const MsprofAclApiType funcType)
: funcName_(funcName),
funcType_(funcType)
{
if (AclProfilingManager::GetInstance().AclProfilingIsRun() && !ge::profiling::ProfilingContext::GetInstance().IsDumpToStdEnabled()) {
if (aclrtGetDevice(&deviceId_) != ACL_SUCCESS) {
ACL_LOG_WARN("Getting device id fail in AclProfiling!");
deviceId_ = -1;
}
switch (funcType) {
case MSPROF_ACL_API_TYPE_OP:
funcTag_ = "acl_op";
break;
case MSPROF_ACL_API_TYPE_MODEL:
funcTag_ = "acl_model";
break;
case MSPROF_ACL_API_TYPE_RUNTIME:
funcTag_ = "acl_rts";
break;
default:
funcTag_ = "acl_others";
break;
}
const mmTimespec ts = mmGetTickCount();
// 1000 ^ 3 converts second to nanosecond
startTime_ = (ts.tv_sec * 1000 * 1000 * 1000) + ts.tv_nsec;
}
}
AclProfilingReporter::~AclProfilingReporter()
{
if (AclProfilingManager::GetInstance().AclProfilingIsRun() && !ge::profiling::ProfilingContext::GetInstance().IsDumpToStdEnabled()) {
const mmTimespec ts = mmGetTickCount();
// 1000 ^ 3 converts second to nanosecond
const int64_t endTime = (ts.tv_sec * 1000 * 1000 * 1000) + ts.tv_nsec;
if ((funcTag_ == nullptr) || (funcName_ == nullptr)) {
ACL_LOG_WARN("function context is nullptr!");
return;
}
// -1 represents invalid device id
if (deviceId_ == -1) {
if (aclrtGetDevice(&deviceId_) != ACL_SUCCESS) {
ACL_LOG_WARN("Getting device id fail in AclProfiling!");
return;
}
}
if (!AclProfilingManager::GetInstance().IsDeviceEnable(static_cast<uint32_t>(deviceId_))) {
ACL_LOG_WARN("device id %d is not enable in Aclprofiling!", deviceId_);
return;
}
ReporterData reporter{};
reporter.deviceId = deviceId_;
const std::string tag_name = funcTag_;
errno_t err = EOK;
err = memcpy_s(reporter.tag, static_cast<size_t>(MSPROF_ENGINE_MAX_TAG_LEN),
tag_name.c_str(), tag_name.size());
if (err != EOK) {
ACL_LOG_INNER_ERROR("[Copy][Mem]memcpy_s failed, err = %d", err);
return;
}
const mmPid_t pid = static_cast<mmPid_t>(mmGetPid());
const int32_t tid = mmGetTid();
// magic number is "5A5A" and tag is 0 for acl
MsprofAclProfData profData{};
profData.magicNumber = static_cast<uint16_t>(MSPROF_DATA_HEAD_MAGIC_NUM);
profData.dataTag = MSPROF_ACL_DATA_TAG;
profData.apiType = static_cast<uint32_t>(funcType_);
profData.beginTime = static_cast<uint64_t>(startTime_);
profData.endTime = static_cast<uint64_t>(endTime);
profData.processId = static_cast<uint32_t>(pid);
profData.threadId = static_cast<uint32_t>(tid);
const size_t funcLen = strnlen(funcName_, static_cast<size_t>(MSPROF_ACL_API_NAME_LEN) - 1U);
err = memcpy_s(profData.apiName, static_cast<size_t>(MSPROF_ACL_API_NAME_LEN), funcName_, funcLen);
if (err != EOK) {
ACL_LOG_INNER_ERROR("[Copy][Mem]memcpy_s failed, err = %d", err);
return;
}
reporter.data = reinterpret_cast<uint8_t *>(&profData);
reporter.dataLen = sizeof(MsprofAclProfData);
ACL_LOG_DEBUG("AclProfiling reporter reports in %s, device id = %d", funcName_, deviceId_);
const aclError ret = AclProfilingManager::GetInstance().ProfilingData(reporter);
if (ret != ACL_SUCCESS) {
ACL_LOG_DEBUG("AclProfiling reporter reports failed, result = %d", ret);
}
}
}
} // namespace acl
Loading...
马建仓 AI 助手
尝试更多
代码解读
代码找茬
代码优化
C++
1
https://gitee.com/Ronnie_zheng/acl.git
git@gitee.com:Ronnie_zheng/acl.git
Ronnie_zheng
acl
acl
master

搜索帮助