增加debug寄存器address-runtime-AtomGit

Minclude/driver/ascend_hal_base.h+8-0

	@@ -5554,6 +5554,14 @@ DLLEXPORT DV_ONLINE drvError_t halResMap(
5554	*/	5554	*/
5555	DLLEXPORT DV_ONLINE drvError_t halResUnmap(unsigned int devId, struct res_map_info *res_info);	5555	DLLEXPORT DV_ONLINE drvError_t halResUnmap(unsigned int devId, struct res_map_info *res_info);
5556		5556
		5557	+/**
		5558	+ * @ingroup driver
		5559	+ * @brief get max res map type supported by driver.
		5560	+ * @attention null
		5561	+ * @return max res map type value
		5562	+ */
		5563	+DLLEXPORT DV_ONLINE unsigned int halGetMaxResMapType(void);
		5564	+
5557	/**	5565	/**
5558	* @ingroup driver	5566	* @ingroup driver
5559	* @brief read or write value to resource reg	5567	* @brief read or write value to resource reg

Minclude/driver/hal_pkg/dpa_pkg.h+1-0

	@@ -25,6 +25,7 @@ enum res_map_type {
25	RES_HSCB_AICORE,	25	RES_HSCB_AICORE,
26	RES_L2BUFF,	26	RES_L2BUFF,
27	RES_C2C,	27	RES_C2C,
		28	+ RES_DBG_ADDR = 0x10,
28	RES_MAP_TYPE_MAX	29	RES_MAP_TYPE_MAX
29	};	30	};
30		31

Msrc/runtime/core/inc/printf.hpp+5-2

Msrc/runtime/core/src/device/raw_device.cc+1-1

	@@ -2172,7 +2172,7 @@ rtError_t RawDevice::InitPrintInfo()
2172	COND_RETURN_ERROR((ret != RT_ERROR_NONE), ret, "Malloc mem failed, device_id=%u, ret=%u.", deviceId_, ret);	2172	COND_RETURN_ERROR((ret != RT_ERROR_NONE), ret, "Malloc mem failed, device_id=%u, ret=%u.", deviceId_, ret);
2173		2173
2174	// 如果初始化失败，需要free后返回	2174	// 如果初始化失败，需要free后返回
2175	- ret = InitPrintf(printfAddr_, printblockLen_, driver_);	2175	+ ret = InitPrintf(printfAddr_, printblockLen_, this);
2176	if (ret != RT_ERROR_NONE) {	2176	if (ret != RT_ERROR_NONE) {
2177	(void)driver_->DevMemFree(printfAddr_, deviceId_);	2177	(void)driver_->DevMemFree(printfAddr_, deviceId_);
2178	printfAddr_ = nullptr;	2178	printfAddr_ = nullptr;

Msrc/runtime/core/src/dfx/printf.cc+43-2

	@@ -23,6 +23,8 @@
23	#include "hifloat.h"	23	#include "hifloat.h"
24	#include "external/graph/types.h"	24	#include "external/graph/types.h"
25	#include "runtime/rt_inner_dfx.h"	25	#include "runtime/rt_inner_dfx.h"
		26	+#include "npu_driver.hpp"
		27	+#include "device.hpp"
26		28
27	namespace cce {	29	namespace cce {
28	namespace runtime {	30	namespace runtime {
	@@ -1005,9 +1007,46 @@ void PrintBlockInfo(const uint8_t *blockData, const uint32_t blockId, const uint
1005	}	1007	}
1006	} // namespace	1008	} // namespace
1007		1009
1008	-rtError_t InitPrintf(void addr, const size_t blockSize, Driver curDrv)	1010	+uint64_t GetDebugAddrForCore(uint32_t deviceId, uint16_t coreId)
1009	{	1011	{
1010	- NULL_PTR_RETURN(curDrv, RT_ERROR_DRV_NULL);	1012	+ if (&halGetMaxResMapType == nullptr) {
		1013	+ RT_LOG(RT_LOG_WARNING, "[drv api] halGetMaxResMapType does not exist, device_id=%u", deviceId);
		1014	+ return 0;
		1015	+ }
		1016	+
		1017	+ uint32_t const maxResMapType = halGetMaxResMapType();
		1018	+ if (maxResMapType < RES_DBG_ADDR) {
		1019	+ RT_LOG(RT_LOG_WARNING,
		1020	+ "[drv api] halGetMaxResMapType returned %u, less than RES_DBG_ADDR(0x10), device_id=%u",
		1021	+ maxResMapType, deviceId);
		1022	+ return 0;
		1023	+ }
		1024	+
		1025	+ struct res_map_info resInfo;
		1026	+ resInfo.target_proc_type = PROCESS_CP1;
		1027	+ resInfo.res_type = RES_DBG_ADDR;
		1028	+ resInfo.res_id = static_cast<unsigned int>(coreId);
		1029	+ resInfo.flag = 0U;
		1030	+ resInfo.rsv[0] = 0U;
		1031	+
		1032	+ uint64_t dbgVa = 0;
		1033	+ uint32_t dbgLen = 0;
		1034	+ const drvError_t drvRet = halResMap(deviceId, &resInfo, &dbgVa, &dbgLen);
		1035	+ if (drvRet != DRV_ERROR_NONE) {
		1036	+ RT_LOG(RT_LOG_WARNING, "halResMap failed for core %u, device_id=%u, drvRetCode=%d",
		1037	+ coreId, deviceId, static_cast<int32_t>(drvRet));
		1038	+ return 0;
		1039	+ }
		1040	+ RT_LOG(RT_LOG_INFO, "halResMap success for core %u, device_id=%u, va=0x%llx, len=%u",
		1041	+ coreId, deviceId, dbgVa, dbgLen);
		1042	+ return dbgVa;
		1043	+}
		1044	+
		1045	+rtError_t InitPrintf(void addr, const size_t blockSize, const Device const dev)
		1046	+{
		1047	+ NULL_PTR_RETURN(dev, RT_ERROR_DRV_NULL);
		1048	+ Driver *const curDrv = dev->Driver_();
		1049	+ uint32_t const deviceId = dev->Id_();
1011	auto props = curDrv->GetDevProperties();	1050	auto props = curDrv->GetDevProperties();
1012	const uint64_t totalCoreNum = static_cast<uint64_t>(props.aicNum + props.aivNum);	1051	const uint64_t totalCoreNum = static_cast<uint64_t>(props.aicNum + props.aivNum);
1013	const uint64_t totalLen = blockSize * totalCoreNum;	1052	const uint64_t totalLen = blockSize * totalCoreNum;
	@@ -1023,6 +1062,8 @@ rtError_t InitPrintf(void addr, const size_t blockSize, Driver curDrv)
1023	blockInfo->magic = MAGIC_NUM;	1062	blockInfo->magic = MAGIC_NUM;
1024	blockInfo->dumpAddr = RtPtrToValue(addr) + blockSize * i + sizeof(BlockInfo) + sizeof(BlockReadInfo);	1063	blockInfo->dumpAddr = RtPtrToValue(addr) + blockSize * i + sizeof(BlockInfo) + sizeof(BlockReadInfo);
1025		1064
		1065	+ blockInfo->dbgAddr = GetDebugAddrForCore(deviceId, static_cast<uint16_t>(i));
		1066	+
1026	BlockReadInfo readInfo = RtPtrToPtr<BlockReadInfo >(blockAddr + sizeof(BlockInfo));	1067	BlockReadInfo readInfo = RtPtrToPtr<BlockReadInfo >(blockAddr + sizeof(BlockInfo));
1027	readInfo->dumpType = DumpType::DUMP_BUFO;	1068	readInfo->dumpType = DumpType::DUMP_BUFO;
1028	readInfo->length = sizeof(uint64_t) + sizeof(uint64_t); // readIdx 和 resv 的大小相加	1069	readInfo->length = sizeof(uint64_t) + sizeof(uint64_t); // readIdx 和 resv 的大小相加

Msrc/runtime/core/src/dfx/printf_tiny_stub.cc+2-2

	@@ -12,11 +12,11 @@
12		12
13	namespace cce {	13	namespace cce {
14	namespace runtime {	14	namespace runtime {
15	-rtError_t InitPrintf(void addr, const size_t blockSize, Driver curDrv)	15	+rtError_t InitPrintf(void addr, const size_t blockSize, const Device const dev)
16	{	16	{
17	UNUSED(addr);	17	UNUSED(addr);
18	UNUSED(blockSize);	18	UNUSED(blockSize);
19	- UNUSED(curDrv);	19	+ UNUSED(dev);
20	return RT_ERROR_FEATURE_NOT_SUPPORT;	20	return RT_ERROR_FEATURE_NOT_SUPPORT;
21	}	21	}
22		22

Msrc/runtime/driver/npu_driver_base.hpp+3-0

	@@ -130,6 +130,9 @@ drvError_t __attribute__((weak)) halSqTaskArgsAsyncCopy(uint32_t devId, struct h
130	drvError_t __attribute__((weak)) halResAddrMap(unsigned int devId, struct res_addr_info *res_info,	130	drvError_t __attribute__((weak)) halResAddrMap(unsigned int devId, struct res_addr_info *res_info,
131	unsigned long va, unsigned int len);	131	unsigned long va, unsigned int len);
132	drvError_t __attribute__((weak)) halResAddrUnmap(unsigned int devId, struct res_addr_info *res_info);	132	drvError_t __attribute__((weak)) halResAddrUnmap(unsigned int devId, struct res_addr_info *res_info);
		133	+drvError_t __attribute__((weak)) halResMap(unsigned int devId, struct res_map_info *res_info,
		134	+ unsigned long va, unsigned int len);
		135	+unsigned int __attribute__((weak)) halGetMaxResMapType(void);
133		136
134	drvError_t __attribute__((weak)) halHostUnregisterEx(void *srcPtr, UINT32 devid, UINT32 flag);	137	drvError_t __attribute__((weak)) halHostUnregisterEx(void *srcPtr, UINT32 devid, UINT32 flag);
135	drvError_t __attribute__((weak)) halHostRegisterCapabilities(UINT32 devid, UINT32 acc_module_type,	138	drvError_t __attribute__((weak)) halHostRegisterCapabilities(UINT32 devid, UINT32 acc_module_type,

Mtests/ut/runtime/runtime/stub/hal_stub.cc+14-0

	@@ -1281,6 +1281,20 @@ drvError_t halResAddrMap(unsigned int devId, struct res_addr_info *res_info, uns
1281	return DRV_ERROR_NONE;	1281	return DRV_ERROR_NONE;
1282	}	1282	}
1283		1283
		1284	+drvError_t halResMap(unsigned int devId, struct res_map_info res_info, unsigned long va, unsigned int *len) {
		1285	+ if (va != nullptr) {
		1286	+ *va = 0x1000;
		1287	+ }
		1288	+ if (len != nullptr) {
		1289	+ *len = 0x100;
		1290	+ }
		1291	+ return DRV_ERROR_NONE;
		1292	+}
		1293	+
		1294	+unsigned int halGetMaxResMapType(void) {
		1295	+ return 0x10;
		1296	+}
		1297	+
1284	int32_t checkProcessStatusFlag = 0;	1298	int32_t checkProcessStatusFlag = 0;
1285	drvError_t halCheckProcessStatus(DVdevice device, processType_t processType, processStatus_t status, bool *isMatched) {	1299	drvError_t halCheckProcessStatus(DVdevice device, processType_t processType, processStatus_t status, bool *isMatched) {
1286	if (checkProcessStatusFlag == 1) {	1300	if (checkProcessStatusFlag == 1) {

Mtests/ut/runtime/runtime/test/platform/910B/stub/hal_stub.cc+14-0

	@@ -1386,6 +1386,20 @@ drvError_t halResAddrMap(unsigned int devId, struct res_addr_info *res_info, uns
1386	return DRV_ERROR_NONE;	1386	return DRV_ERROR_NONE;
1387	}	1387	}
1388		1388
		1389	+drvError_t halResMap(unsigned int devId, struct res_map_info res_info, unsigned long va, unsigned int *len) {
		1390	+ if (va != nullptr) {
		1391	+ *va = 0x1000;
		1392	+ }
		1393	+ if (len != nullptr) {
		1394	+ *len = 0x100;
		1395	+ }
		1396	+ return DRV_ERROR_NONE;
		1397	+}
		1398	+
		1399	+unsigned int halGetMaxResMapType(void) {
		1400	+ return 0x10;
		1401	+}
		1402	+
1389	int32_t checkProcessStatusFlag = 0;	1403	int32_t checkProcessStatusFlag = 0;
1390	drvError_t halCheckProcessStatus(DVdevice device, processType_t processType, processStatus_t status, bool *isMatched) {	1404	drvError_t halCheckProcessStatus(DVdevice device, processType_t processType, processStatus_t status, bool *isMatched) {
1391	if (checkProcessStatusFlag == 1) {	1405	if (checkProcessStatusFlag == 1) {

Mtests/ut/runtime/runtime/test/platform/910_95/stub/hal_stub.cc+14-0

	@@ -1338,6 +1338,20 @@ drvError_t halResAddrMap(unsigned int devId, struct res_addr_info *res_info, uns
1338	return DRV_ERROR_NONE;	1338	return DRV_ERROR_NONE;
1339	}	1339	}
1340		1340
		1341	+drvError_t halResMap(unsigned int devId, struct res_map_info res_info, unsigned long va, unsigned int *len) {
		1342	+ if (va != nullptr) {
		1343	+ *va = 0x1000;
		1344	+ }
		1345	+ if (len != nullptr) {
		1346	+ *len = 0x100;
		1347	+ }
		1348	+ return DRV_ERROR_NONE;
		1349	+}
		1350	+
		1351	+unsigned int halGetMaxResMapType(void) {
		1352	+ return 0x10;
		1353	+}
		1354	+
1341	int32_t checkProcessStatusFlag = 0;	1355	int32_t checkProcessStatusFlag = 0;
1342	drvError_t halCheckProcessStatus(DVdevice device, processType_t processType, processStatus_t status, bool *isMatched) {	1356	drvError_t halCheckProcessStatus(DVdevice device, processType_t processType, processStatus_t status, bool *isMatched) {
1343	if (checkProcessStatusFlag == 1) {	1357	if (checkProcessStatusFlag == 1) {

Mtests/ut/runtime/runtime/test/platform/adc/stub/hal_stub.cc+14-0

	@@ -1224,6 +1224,20 @@ drvError_t halResAddrMap(unsigned int devId, struct res_addr_info *res_info, uns
1224	return DRV_ERROR_NONE;	1224	return DRV_ERROR_NONE;
1225	}	1225	}
1226		1226
		1227	+drvError_t halResMap(unsigned int devId, struct res_map_info res_info, unsigned long va, unsigned int *len) {
		1228	+ if (va != nullptr) {
		1229	+ *va = 0x1000;
		1230	+ }
		1231	+ if (len != nullptr) {
		1232	+ *len = 0x100;
		1233	+ }
		1234	+ return DRV_ERROR_NONE;
		1235	+}
		1236	+
		1237	+unsigned int halGetMaxResMapType(void) {
		1238	+ return 0x10;
		1239	+}
		1240	+
1227	int32_t checkProcessStatusFlag = 0;	1241	int32_t checkProcessStatusFlag = 0;
1228	drvError_t halCheckProcessStatus(DVdevice device, processType_t processType, processStatus_t status, bool *isMatched) {	1242	drvError_t halCheckProcessStatus(DVdevice device, processType_t processType, processStatus_t status, bool *isMatched) {
1229	if (checkProcessStatusFlag == 1) {	1243	if (checkProcessStatusFlag == 1) {

Mtests/ut/runtime/runtime/test/platform/cloud/stub/hal_stub.cc+14-0

	@@ -1235,6 +1235,20 @@ drvError_t halResAddrMap(unsigned int devId, struct res_addr_info *res_info, uns
1235	return DRV_ERROR_NONE;	1235	return DRV_ERROR_NONE;
1236	}	1236	}
1237		1237
		1238	+drvError_t halResMap(unsigned int devId, struct res_map_info res_info, unsigned long va, unsigned int *len) {
		1239	+ if (va != nullptr) {
		1240	+ *va = 0x1000;
		1241	+ }
		1242	+ if (len != nullptr) {
		1243	+ *len = 0x100;
		1244	+ }
		1245	+ return DRV_ERROR_NONE;
		1246	+}
		1247	+
		1248	+unsigned int halGetMaxResMapType(void) {
		1249	+ return 0x10;
		1250	+}
		1251	+
1238	int32_t checkProcessStatusFlag = 0;	1252	int32_t checkProcessStatusFlag = 0;
1239	drvError_t halCheckProcessStatus(DVdevice device, processType_t processType, processStatus_t status, bool *isMatched) {	1253	drvError_t halCheckProcessStatus(DVdevice device, processType_t processType, processStatus_t status, bool *isMatched) {
1240	if (checkProcessStatusFlag == 1) {	1254	if (checkProcessStatusFlag == 1) {

Mtests/ut/runtime/runtime/test/platform/dc/stub/hal_stub.cc+14-0

	@@ -1231,6 +1231,20 @@ drvError_t halResAddrMap(unsigned int devId, struct res_addr_info *res_info, uns
1231	return DRV_ERROR_NONE;	1231	return DRV_ERROR_NONE;
1232	}	1232	}
1233		1233
		1234	+drvError_t halResMap(unsigned int devId, struct res_map_info res_info, unsigned long va, unsigned int *len) {
		1235	+ if (va != nullptr) {
		1236	+ *va = 0x1000;
		1237	+ }
		1238	+ if (len != nullptr) {
		1239	+ *len = 0x100;
		1240	+ }
		1241	+ return DRV_ERROR_NONE;
		1242	+}
		1243	+
		1244	+unsigned int halGetMaxResMapType(void) {
		1245	+ return 0x10;
		1246	+}
		1247	+
1234	int32_t checkProcessStatusFlag = 0;	1248	int32_t checkProcessStatusFlag = 0;
1235	drvError_t halCheckProcessStatus(DVdevice device, processType_t processType, processStatus_t status, bool *isMatched) {	1249	drvError_t halCheckProcessStatus(DVdevice device, processType_t processType, processStatus_t status, bool *isMatched) {
1236	if (checkProcessStatusFlag == 1) {	1250	if (checkProcessStatusFlag == 1) {

Mtests/ut/runtime/runtime/test/platform/mini_v3/stub/hal_stub.cc+14-0

	@@ -1358,6 +1358,20 @@ drvError_t halResAddrMap(unsigned int devId, struct res_addr_info *res_info, uns
1358	return DRV_ERROR_NONE;	1358	return DRV_ERROR_NONE;
1359	}	1359	}
1360		1360
		1361	+drvError_t halResMap(unsigned int devId, struct res_map_info res_info, unsigned long va, unsigned int *len) {
		1362	+ if (va != nullptr) {
		1363	+ *va = 0x1000;
		1364	+ }
		1365	+ if (len != nullptr) {
		1366	+ *len = 0x100;
		1367	+ }
		1368	+ return DRV_ERROR_NONE;
		1369	+}
		1370	+
		1371	+unsigned int halGetMaxResMapType(void) {
		1372	+ return 0x10;
		1373	+}
		1374	+
1361	int32_t checkProcessStatusFlag = 0;	1375	int32_t checkProcessStatusFlag = 0;
1362	drvError_t halCheckProcessStatus(DVdevice device, processType_t processType, processStatus_t status, bool *isMatched) {	1376	drvError_t halCheckProcessStatus(DVdevice device, processType_t processType, processStatus_t status, bool *isMatched) {
1363	if (checkProcessStatusFlag == 1) {	1377	if (checkProcessStatusFlag == 1) {

Mtests/ut/runtime/runtime/test/rt_utest_printf.cc+83-0

	@@ -1391,3 +1391,86 @@ TEST_F(PrintfTest, DumpFP16_InfAndNan)
1391	cce::runtime::fp16_t num4[] = {data4};	1391	cce::runtime::fp16_t num4[] = {data4};
1392	EXPECT_TRUE(std::isnan(num4[0].toFloat()));	1392	EXPECT_TRUE(std::isnan(num4[0].toFloat()));
1393	}	1393	}
		1394	+
		1395	+TEST_F(PrintfTest, TestInitPrintf_MaxResMapTypeTooSmall)
		1396	+{
		1397	+ rtError_t error = rtSetDevice(0);
		1398	+ EXPECT_EQ(error, RT_ERROR_NONE);
		1399	+
		1400	+ Runtime rtInstance = (Runtime )Runtime::Instance();
		1401	+ RawDevice dev = (RawDevice )rtInstance->GetDevice(0U, 0U);
		1402	+ dev->simdEnable_ = true;
		1403	+ error = dev->ParseSimdPrintInfo();
		1404	+ EXPECT_EQ(error, RT_ERROR_NONE);
		1405	+
		1406	+ MOCKER(halGetMaxResMapType).stubs().will(returnValue(0x05));
		1407	+
		1408	+ auto props = dev->GetDevProperties();
		1409	+ const uint64_t totalCoreNum = static_cast<uint64_t>(props.aicNum + props.aivNum);
		1410	+ const size_t blockSize = 1024 * 1024;
		1411	+ std::vector<uint8_t> hostData(blockSize * totalCoreNum, 0);
		1412	+
		1413	+ error = InitPrintf(hostData.data(), blockSize, dev);
		1414	+ EXPECT_EQ(error, RT_ERROR_NONE);
		1415	+
		1416	+ BlockInfo blockInfo = RtPtrToPtr<BlockInfo >(hostData.data());
		1417	+ EXPECT_EQ(blockInfo->dbgAddr, 0U);
		1418	+
		1419	+ GlobalMockObject::verify();
		1420	+ rtDeviceReset(0);
		1421	+}
		1422	+
		1423	+TEST_F(PrintfTest, TestInitPrintf_HalResMapFailed)
		1424	+{
		1425	+ rtError_t error = rtSetDevice(0);
		1426	+ EXPECT_EQ(error, RT_ERROR_NONE);
		1427	+
		1428	+ Runtime rtInstance = (Runtime )Runtime::Instance();
		1429	+ RawDevice dev = (RawDevice )rtInstance->GetDevice(0U, 0U);
		1430	+ dev->simdEnable_ = true;
		1431	+ error = dev->ParseSimdPrintInfo();
		1432	+ EXPECT_EQ(error, RT_ERROR_NONE);
		1433	+
		1434	+ MOCKER(halGetMaxResMapType).stubs().will(returnValue(0x20));
		1435	+ MOCKER(halResMap).stubs().will(returnValue(DRV_ERROR_NOT_SUPPORT));
		1436	+
		1437	+ auto props = dev->GetDevProperties();
		1438	+ const uint64_t totalCoreNum = static_cast<uint64_t>(props.aicNum + props.aivNum);
		1439	+ const size_t blockSize = 1024 * 1024;
		1440	+ std::vector<uint8_t> hostData(blockSize * totalCoreNum, 0);
		1441	+
		1442	+ error = InitPrintf(hostData.data(), blockSize, dev);
		1443	+ EXPECT_EQ(error, RT_ERROR_NONE);
		1444	+
		1445	+ BlockInfo blockInfo = RtPtrToPtr<BlockInfo >(hostData.data());
		1446	+ EXPECT_EQ(blockInfo->dbgAddr, 0U);
		1447	+
		1448	+ GlobalMockObject::verify();
		1449	+ rtDeviceReset(0);
		1450	+}
		1451	+
		1452	+TEST_F(PrintfTest, TestInitPrintf_DebugAddrSuccess)
		1453	+{
		1454	+ rtError_t error = rtSetDevice(0);
		1455	+ EXPECT_EQ(error, RT_ERROR_NONE);
		1456	+
		1457	+ Runtime rtInstance = (Runtime )Runtime::Instance();
		1458	+ RawDevice dev = (RawDevice )rtInstance->GetDevice(0U, 0U);
		1459	+ dev->simdEnable_ = true;
		1460	+ error = dev->ParseSimdPrintInfo();
		1461	+ EXPECT_EQ(error, RT_ERROR_NONE);
		1462	+
		1463	+ auto props = dev->GetDevProperties();
		1464	+ const uint64_t totalCoreNum = static_cast<uint64_t>(props.aicNum + props.aivNum);
		1465	+ const size_t blockSize = 1024 * 1024;
		1466	+ std::vector<uint8_t> hostData(blockSize * totalCoreNum, 0);
		1467	+
		1468	+ error = InitPrintf(hostData.data(), blockSize, dev);
		1469	+ EXPECT_EQ(error, RT_ERROR_NONE);
		1470	+
		1471	+ BlockInfo blockInfo = RtPtrToPtr<BlockInfo >(hostData.data());
		1472	+ EXPECT_NE(blockInfo->dbgAddr, 0x1000U);
		1473	+ EXPECT_EQ(blockInfo->dbgAddr, 0U);
		1474	+
		1475	+ rtDeviceReset(0);
		1476	+}

	@@ -16,6 +16,8 @@
16	namespace cce {	16	namespace cce {
17	namespace runtime {	17	namespace runtime {
18		18
		19	+class Device;
		20	+
19	// 单核数据排布 blockData: \| blockInfo \| readInfo \| tlv1 \| tlv2 \| tlv3 ... \| writeInfo \|	21	// 单核数据排布 blockData: \| blockInfo \| readInfo \| tlv1 \| tlv2 \| tlv3 ... \| writeInfo \|
20	// 整体排布：\| blockData1 \| blockData2 \| ... \| bloackData75 \|	22	// 整体排布：\| blockData1 \| blockData2 \| ... \| bloackData75 \|
21		23
	@@ -28,7 +30,8 @@ struct BlockInfo {
28	uint16_t flag = 0; // flag value, 0:simd-aic, 1:simd-aiv, 2:simt	30	uint16_t flag = 0; // flag value, 0:simd-aic, 1:simd-aiv, 2:simt
29	uint32_t rsv = 0; // DUMP EXC FLAG	31	uint32_t rsv = 0; // DUMP EXC FLAG
30	uint64_t dumpAddr = 0; // 起始printf的地址	32	uint64_t dumpAddr = 0; // 起始printf的地址
31	- uint32_t resv[6] = {0U};	33	+ uint64_t dbgAddr = 0; // debug bus addr
		34	+ uint32_t resv[4] = {0U};
32	};	35	};
33		36
34	enum class DumpType : uint32_t {	37	enum class DumpType : uint32_t {
	@@ -103,7 +106,7 @@ constexpr uint32_t RT_KERNEL_DFX_INFO_CORE_TYPE_AIC = 0U;
103	constexpr uint32_t RT_KERNEL_DFX_INFO_CORE_TYPE_AIV = 1U;	106	constexpr uint32_t RT_KERNEL_DFX_INFO_CORE_TYPE_AIV = 1U;
104	constexpr uint32_t RT_KERNEL_DFX_INFO_CORE_TYPE_SIMT = 2U;	107	constexpr uint32_t RT_KERNEL_DFX_INFO_CORE_TYPE_SIMT = 2U;
105		108
106	-rtError_t InitPrintf(void addr, const size_t blockSize, Driver curDrv);	109	+rtError_t InitPrintf(void addr, const size_t blockSize, const Device const dev);
107	rtError_t InitSimtPrintf(void addr, const size_t blockSize, Driver curDrv);	110	rtError_t InitSimtPrintf(void addr, const size_t blockSize, Driver curDrv);
108	rtError_t ParsePrintf(void addr, const size_t blockSize, Driver curDrv);	111	rtError_t ParsePrintf(void addr, const size_t blockSize, Driver curDrv);
109	rtError_t ParseSimtPrintf(void addr, const size_t blockSize, Driver curDrv, const Device * const dev);	112	rtError_t ParseSimtPrintf(void addr, const size_t blockSize, Driver curDrv, const Device * const dev);