intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-05 09:09:04 +08:00
Code Issues Packages Projects Releases Wiki Activity

feature: Add support for 64 bit memory counters for zesInit

Browse Source 
Related-To: LOCI-4613, LOCI-4612

Signed-off-by: Mayank Raghuwanshi <mayank.raghuwanshi@intel.com>
This commit is contained in:
Mayank Raghuwanshi
2023-07-14 11:56:00 +00:00
committed by Compute-Runtime-Automation
parent c3ca3ff119
commit af6798f257
29 changed files with 195 additions and 378 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
level_zero/tools/source/sysman/memory/linux/os_memory_imp.cpp
View File

@@ -41,10 +41,6 @@ ze_result_t LinuxMemoryImp::getState(zes_mem_state_t *pState) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxMemoryImp::getBandwidthEx(uint64_t *pReadCounters, uint64_t *pWriteCounters, uint64_t *pMaxBandwidth, uint64_t timeout) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
std::unique_ptr<OsMemory> OsMemory::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) {
std::unique_ptr<LinuxMemoryImp> pLinuxMemoryImp = std::make_unique<LinuxMemoryImp>(pOsSysman, onSubdevice, subdeviceId);
return pLinuxMemoryImp;

1
level_zero/tools/source/sysman/memory/linux/os_memory_imp.h
View File

@@ -21,7 +21,6 @@ class LinuxMemoryImp : public OsMemory, NEO::NonCopyableOrMovableClass {
ze_result_t getProperties(zes_mem_properties_t *pProperties) override;
ze_result_t getBandwidth(zes_mem_bandwidth_t *pBandwidth) override;
ze_result_t getState(zes_mem_state_t *pState) override;
ze_result_t getBandwidthEx(uint64_t *pReadCounters, uint64_t *pWriteCounters, uint64_t *pMaxBandwidth, uint64_t timeout) override;
bool isMemoryModuleSupported() override;
LinuxMemoryImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId);

4
level_zero/tools/source/sysman/memory/linux/os_memory_imp_dg1.cpp
View File

@@ -41,10 +41,6 @@ ze_result_t LinuxMemoryImp::getBandwidth(zes_mem_bandwidth_t *pBandwidth) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxMemoryImp::getBandwidthEx(uint64_t *pReadCounters, uint64_t *pWriteCounters, uint64_t *pMaxBandwidth, uint64_t timeout) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxMemoryImp::getState(zes_mem_state_t *pState) {
std::vector<NEO::MemoryRegion> deviceRegions;
if (pDrm->queryMemoryInfo() == false) {

86
level_zero/tools/source/sysman/memory/linux/os_memory_imp_prelim.cpp
View File

@@ -354,92 +354,6 @@ ze_result_t LinuxMemoryImp::getBandwidth(zes_mem_bandwidth_t *pBandwidth) {
return result;
}
uint64_t getCounterIncrement(uint32_t counterMaxValue, uint64_t prevValue, uint64_t currentValue) {
if (currentValue < prevValue) {
return (counterMaxValue - prevValue + currentValue);
}
return (currentValue - prevValue);
}
ze_result_t LinuxMemoryImp::getHbmBandwidthEx(uint32_t numHbmModules, uint32_t counterMaxValue, uint64_t *pReadCounters, uint64_t *pWriteCounters, uint64_t *pMaxBandwidth, uint64_t timeout) {
std::vector<uint64_t> prevReadCounters(numHbmModules, 0);
std::vector<uint64_t> prevWriteCounters(numHbmModules, 0);
uint64_t totalReadCounters = 0;
uint64_t totalWriteCounters = 0;
bool counterInit = false;
ze_result_t result = ZE_RESULT_ERROR_UNKNOWN;
std::string vfId = "";
result = getVFIDString(vfId);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():getVFIDString returning error:0x%x while retriving VFID string \n", __FUNCTION__, result);
return result;
}
auto &hwInfo = pDevice->getNEODevice()->getHardwareInfo();
auto productFamily = hwInfo.platform.eProductFamily;
auto &productHelper = pDevice->getNEODevice()->getProductHelper();
auto stepping = productHelper.getSteppingFromHwRevId(hwInfo);
auto timeToExitLoop = std::chrono::steady_clock::now() + std::chrono::duration<uint64_t, std::milli>(timeout);
do {
for (auto hbmModuleIndex = 0u; hbmModuleIndex < numHbmModules; hbmModuleIndex++) {
uint32_t counterValue = 0;
// To read counters from VFID 0 and HBM module 0, key would be: VF0_HBM0_READ
std::string readCounterKey = vfId + "_HBM" + std::to_string(hbmModuleIndex) + "_READ";
result = pPmt->readValue(readCounterKey, counterValue);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for readCounterKey returning error:0x%x \n", __FUNCTION__, result);
return result;
}
if (counterInit) {
totalReadCounters += getCounterIncrement(counterMaxValue, prevReadCounters[hbmModuleIndex], counterValue);
}
prevReadCounters[hbmModuleIndex] = counterValue;
counterValue = 0;
// To write counters to VFID 0 and HBM module 0, key would be: VF0_HBM0_Write
std::string writeCounterKey = vfId + "_HBM" + std::to_string(hbmModuleIndex) + "_WRITE";
result = pPmt->readValue(writeCounterKey, counterValue);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for writeCounterKey returning error:0x%x \n", __FUNCTION__, result);
return result;
}
if (counterInit) {
totalWriteCounters += getCounterIncrement(counterMaxValue, prevWriteCounters[hbmModuleIndex], counterValue);
}
prevWriteCounters[hbmModuleIndex] = counterValue;
}
counterInit = true;
} while (std::chrono::steady_clock::now() <= timeToExitLoop);
constexpr uint64_t transactionSize = 32;
*pReadCounters = (totalReadCounters * transactionSize);
*pWriteCounters = (totalWriteCounters * transactionSize);
uint64_t hbmFrequency = 0;
getHbmFrequency(productFamily, stepping, hbmFrequency);
*pMaxBandwidth = memoryBusWidth * hbmFrequency * numHbmModules; // Value in bytes/secs
return result;
}
ze_result_t LinuxMemoryImp::getBandwidthEx(uint64_t *pReadCounters, uint64_t *pWriteCounters, uint64_t *pMaxBw, uint64_t timeout) {
if (pPmt == nullptr) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t result = ZE_RESULT_ERROR_UNKNOWN;
auto &hwInfo = pDevice->getNEODevice()->getHardwareInfo();
auto productFamily = hwInfo.platform.eProductFamily;
uint32_t numHbmModules = 0u;
uint32_t counterMaxValue;
switch (productFamily) {
case IGFX_PVC:
numHbmModules = 4u;
counterMaxValue = UINT32_MAX;
result = getHbmBandwidthEx(numHbmModules, counterMaxValue, pReadCounters, pWriteCounters, pMaxBw, timeout);
break;
default:
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
break;
}
return result;
}
ze_result_t LinuxMemoryImp::getState(zes_mem_state_t *pState) {
pState->health = ZES_MEM_HEALTH_UNKNOWN;
FirmwareUtil *pFwInterface = pLinuxSysmanImp->getFwUtilInterface();

1
level_zero/tools/source/sysman/memory/linux/os_memory_imp_prelim.h
View File

@@ -24,7 +24,6 @@ class LinuxMemoryImp : public OsMemory, NEO::NonCopyableOrMovableClass {
ze_result_t getProperties(zes_mem_properties_t *pProperties) override;
ze_result_t getBandwidth(zes_mem_bandwidth_t *pBandwidth) override;
ze_result_t getState(zes_mem_state_t *pState) override;
ze_result_t getBandwidthEx(uint64_t *pReadCounters, uint64_t *pWriteCounters, uint64_t *pMaxBandwidth, uint64_t timeout) override;
bool isMemoryModuleSupported() override;
LinuxMemoryImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId);

2
level_zero/tools/source/sysman/memory/memory.h
View File

@@ -22,8 +22,6 @@ class Memory : _zes_mem_handle_t {
virtual ze_result_t memoryGetProperties(zes_mem_properties_t *pProperties) = 0;
virtual ze_result_t memoryGetBandwidth(zes_mem_bandwidth_t *pBandwidth) = 0;
virtual ze_result_t memoryGetState(zes_mem_state_t *pState) = 0;
virtual ze_result_t memoryGetBandwidthEx(uint64_t *pReadCounters, uint64_t *pWriteCounters, uint64_t *pMaxBandwidth, uint64_t timeout) = 0;
static Memory *fromHandle(zes_mem_handle_t handle) {
return static_cast<Memory *>(handle);
}

4
level_zero/tools/source/sysman/memory/memory_imp.cpp
View File

@@ -24,10 +24,6 @@ ze_result_t MemoryImp::memoryGetProperties(zes_mem_properties_t *pProperties) {
return ZE_RESULT_SUCCESS;
}
ze_result_t MemoryImp::memoryGetBandwidthEx(uint64_t *pReadCounters, uint64_t *pWriteCounters, uint64_t *pMaxBandwidth, uint64_t timeout) {
return pOsMemory->getBandwidthEx(pReadCounters, pWriteCounters, pMaxBandwidth, timeout);
}
void MemoryImp::init() {
this->initSuccess = pOsMemory->isMemoryModuleSupported();
if (this->initSuccess == true) {

1
level_zero/tools/source/sysman/memory/memory_imp.h
View File

@@ -19,7 +19,6 @@ class MemoryImp : public Memory, NEO::NonCopyableOrMovableClass {
ze_result_t memoryGetProperties(zes_mem_properties_t *pProperties) override;
ze_result_t memoryGetBandwidth(zes_mem_bandwidth_t *pBandwidth) override;
ze_result_t memoryGetState(zes_mem_state_t *pState) override;
ze_result_t memoryGetBandwidthEx(uint64_t *pReadCounters, uint64_t *pWriteCounters, uint64_t *pMaxBandwidth, uint64_t timeout) override;
MemoryImp(OsSysman *pOsSysman, ze_device_handle_t handle);
~MemoryImp() override;

1
level_zero/tools/source/sysman/memory/os_memory.h
View File

@@ -19,7 +19,6 @@ class OsMemory {
virtual ze_result_t getProperties(zes_mem_properties_t *pProperties) = 0;
virtual ze_result_t getBandwidth(zes_mem_bandwidth_t *pBandwidth) = 0;
virtual ze_result_t getState(zes_mem_state_t *pState) = 0;
virtual ze_result_t getBandwidthEx(uint64_t *pReadCounters, uint64_t *pWriteCounters, uint64_t *pMaxBandwidth, uint64_t timeout) = 0;
virtual bool isMemoryModuleSupported() = 0;
static std::unique_ptr<OsMemory> create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId);
virtual ~OsMemory() {}

4
level_zero/tools/source/sysman/memory/windows/os_memory_imp.cpp
View File

@@ -168,10 +168,6 @@ ze_result_t WddmMemoryImp::getProperties(zes_mem_properties_t *pProperties) {
return ZE_RESULT_SUCCESS;
}
ze_result_t WddmMemoryImp::getBandwidthEx(uint64_t *pReadCounters, uint64_t *pWriteCounters, uint64_t *pMaxBandwidth, uint64_t timeout) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmMemoryImp::getBandwidth(zes_mem_bandwidth_t *pBandwidth) {
uint32_t retValu32 = 0;
uint64_t retValu64 = 0;

1
level_zero/tools/source/sysman/memory/windows/os_memory_imp.h
View File

@@ -28,7 +28,6 @@ class WddmMemoryImp : public OsMemory, NEO::NonCopyableOrMovableClass {
ze_result_t getProperties(zes_mem_properties_t *pProperties) override;
ze_result_t getBandwidth(zes_mem_bandwidth_t *pBandwidth) override;
ze_result_t getState(zes_mem_state_t *pState) override;
ze_result_t getBandwidthEx(uint64_t *pReadCounters, uint64_t *pWriteCounters, uint64_t *pMaxBandwidth, uint64_t timeout) override;
bool isMemoryModuleSupported() override;
WddmMemoryImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId);
WddmMemoryImp() = default;