feature: Add Support for 64 bit aggregated read/write counters

Related-To: LOCI-4529

Signed-off-by: Mayank Raghuwanshi <mayank.raghuwanshi@intel.com>

Source: d028857

Author: mraghuwa

level_zero/tools/source/sysman/linux/pmt/pmt_xml_offsets.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -207,7 +207,15 @@ const std::map<std::string, std::map<std::string, uint64_t>> guidToKeyOffsetMap
       {"VF1_HBM2_READ", 344},
       {"VF1_HBM2_WRITE", 348},
       {"VF1_HBM3_READ", 360},
-      {"VF1_HBM3_WRITE", 364}}},
+      {"VF1_HBM3_WRITE", 364},
+      {"VF0_HBM_READ_L", 384},
+      {"VF0_HBM_READ_H", 388},
+      {"VF0_HBM_WRITE_L", 392},
+      {"VF0_HBM_WRITE_H", 396},
+      {"VF1_HBM_READ_L", 400},
+      {"VF1_HBM_READ_H", 404},
+      {"VF1_HBM_WRITE_L", 408},
+      {"VF1_HBM_WRITE_H", 412}}},
     {"0xb15a0edd", // For PVC device
      {{"HBM0MaxDeviceTemperature", 28},
       {"HBM1MaxDeviceTemperature", 36},
@@ -238,7 +246,54 @@ const std::map<std::string, std::map<std::string, uint64_t>> guidToKeyOffsetMap
       {"VF1_HBM2_READ", 344},
       {"VF1_HBM2_WRITE", 348},
       {"VF1_HBM3_READ", 360},
-      {"VF1_HBM3_WRITE", 364}}},
+      {"VF1_HBM3_WRITE", 364},
+      {"VF0_HBM_READ_L", 384},
+      {"VF0_HBM_READ_H", 388},
+      {"VF0_HBM_WRITE_L", 392},
+      {"VF0_HBM_WRITE_H", 396},
+      {"VF1_HBM_READ_L", 400},
+      {"VF1_HBM_READ_H", 404},
+      {"VF1_HBM_WRITE_L", 408},
+      {"VF1_HBM_WRITE_H", 412}}},
+    {"0xb15a0ede", // For PVC device
+     {{"HBM0MaxDeviceTemperature", 28},
+      {"HBM1MaxDeviceTemperature", 36},
+      {"TileMinTemperature", 40},
+      {"TileMaxTemperature", 44},
+      {"GTMinTemperature", 48},
+      {"GTMaxTemperature", 52},
+      {"VF0_VFID", 88},
+      {"VF0_HBM0_READ", 92},
+      {"VF0_HBM0_WRITE", 96},
+      {"VF0_HBM1_READ", 104},
+      {"VF0_HBM1_WRITE", 108},
+      {"VF0_TIMESTAMP_L", 168},
+      {"VF0_TIMESTAMP_H", 172},
+      {"VF1_VFID", 176},
+      {"VF1_HBM0_READ", 180},
+      {"VF1_HBM0_WRITE", 184},
+      {"VF1_HBM1_READ", 192},
+      {"VF1_HBM1_WRITE", 196},
+      {"VF1_TIMESTAMP_L", 256},
+      {"VF1_TIMESTAMP_H", 260},
+      {"HBM2MaxDeviceTemperature", 300},
+      {"HBM3MaxDeviceTemperature", 308},
+      {"VF0_HBM2_READ", 312},
+      {"VF0_HBM2_WRITE", 316},
+      {"VF0_HBM3_READ", 328},
+      {"VF0_HBM3_WRITE", 332},
+      {"VF1_HBM2_READ", 344},
+      {"VF1_HBM2_WRITE", 348},
+      {"VF1_HBM3_READ", 360},
+      {"VF1_HBM3_WRITE", 364},
+      {"VF0_HBM_READ_L", 384},
+      {"VF0_HBM_READ_H", 388},
+      {"VF0_HBM_WRITE_L", 392},
+      {"VF0_HBM_WRITE_H", 396},
+      {"VF1_HBM_READ_L", 400},
+      {"VF1_HBM_READ_H", 404},
+      {"VF1_HBM_WRITE_L", 408},
+      {"VF1_HBM_WRITE_H", 412}}},
     {"0x41fe79a5", // For PVC root device
      {{"PPIN", 152},
       {"BoardNumber", 72}}}};

level_zero/tools/source/sysman/memory/linux/os_memory_imp_prelim.cpp

@@ -266,6 +266,75 @@ ze_result_t LinuxMemoryImp::getHbmBandwidth(uint32_t numHbmModules, zes_mem_band
     return result;
 }
 
+ze_result_t LinuxMemoryImp::getHbmBandwidthPVC(uint32_t numHbmModules, zes_mem_bandwidth_t *pBandwidth) {
+    pBandwidth->readCounter = 0;
+    pBandwidth->writeCounter = 0;
+    pBandwidth->timestamp = 0;
+    pBandwidth->maxBandwidth = 0;
+    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);
+
+    uint32_t readCounterL = 0;
+    std::string readCounterKey = vfId + "_HBM_READ_L";
+    result = pPmt->readValue(readCounterKey, readCounterL);
+    if (result != ZE_RESULT_SUCCESS) {
+        NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for readCounterL returning error:0x%x \n", __FUNCTION__, result);
+        return result;
+    }
+
+    uint32_t readCounterH = 0;
+    readCounterKey = vfId + "_HBM_READ_H";
+    result = pPmt->readValue(readCounterKey, readCounterH);
+    if (result != ZE_RESULT_SUCCESS) {
+        NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for readCounterH returning error:0x%x \n", __FUNCTION__, result);
+        return result;
+    }
+
+    constexpr uint64_t transactionSize = 32;
+    pBandwidth->readCounter = readCounterH;
+    pBandwidth->readCounter = (pBandwidth->readCounter << 32) | static_cast<uint64_t>(readCounterL);
+    pBandwidth->readCounter = (pBandwidth->readCounter * transactionSize);
+
+    uint32_t writeCounterL = 0;
+    std::string writeCounterKey = vfId + "_HBM_WRITE_L";
+    result = pPmt->readValue(writeCounterKey, writeCounterL);
+    if (result != ZE_RESULT_SUCCESS) {
+        NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for writeCounterL returning error:0x%x \n", __FUNCTION__, result);
+        return result;
+    }
+
+    uint32_t writeCounterH = 0;
+    writeCounterKey = vfId + "_HBM_WRITE_H";
+    result = pPmt->readValue(writeCounterKey, writeCounterH);
+    if (result != ZE_RESULT_SUCCESS) {
+        NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for writeCounterH returning error:0x%x \n", __FUNCTION__, result);
+        return result;
+    }
+
+    pBandwidth->writeCounter = writeCounterH;
+    pBandwidth->writeCounter = (pBandwidth->writeCounter << 32) | static_cast<uint64_t>(writeCounterL);
+    pBandwidth->writeCounter = (pBandwidth->writeCounter * transactionSize);
+
+    uint64_t timeStampVal = 0;
+    memoryGetTimeStamp(timeStampVal);
+    pBandwidth->timestamp = timeStampVal;
+
+    uint64_t hbmFrequency = 0;
+    getHbmFrequency(productFamily, stepping, hbmFrequency);
+
+    pBandwidth->maxBandwidth = memoryBusWidth * hbmFrequency * numHbmModules; // Value in bytes/secs
+    return result;
+}
+
 ze_result_t LinuxMemoryImp::getBandwidth(zes_mem_bandwidth_t *pBandwidth) {
     if (pPmt == nullptr) {
         return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
@@ -284,7 +353,7 @@ ze_result_t LinuxMemoryImp::getBandwidth(zes_mem_bandwidth_t *pBandwidth) {
         break;
     case IGFX_PVC:
         numHbmModules = 4u;
-        result = getHbmBandwidth(numHbmModules, pBandwidth);
+        result = getHbmBandwidthPVC(numHbmModules, pBandwidth);
         break;
     default:
         result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;

level_zero/tools/source/sysman/memory/linux/os_memory_imp_prelim.h

@@ -44,6 +44,7 @@ class LinuxMemoryImp : public OsMemory, NEO::NonCopyableOrMovableClass {
     ze_result_t getVFIDString(std::string &vfID);
     ze_result_t getBandwidthForDg2(zes_mem_bandwidth_t *pBandwidth);
     ze_result_t getHbmBandwidth(uint32_t numHbmModules, zes_mem_bandwidth_t *pBandwidth);
+    ze_result_t getHbmBandwidthPVC(uint32_t numHbmModules, zes_mem_bandwidth_t *pBandwidth);
     ze_result_t getHbmBandwidthEx(uint32_t numHbmModules, uint32_t counterMaxValue, uint64_t *pReadCounters, uint64_t *pWriteCounters, uint64_t *pMaxBandwidth, uint64_t timeout);
     static const std::string deviceMemoryHealth;
     bool isSubdevice = false;

level_zero/tools/test/unit_tests/sources/sysman/memory/linux/mock_memory_prelim.h

@@ -30,6 +30,14 @@ constexpr uint64_t unallocatedSizeRegionTwo = 25 * GB;
 constexpr uint64_t unallocatedSizeRegionThree = 3 * GB;
 constexpr uint64_t unallocatedSizeRegionFour = 4 * GB;
 
+constexpr uint32_t VF0HbmLRead = 16;
+constexpr uint32_t VF0HbmHRead = 2;
+constexpr uint32_t VF0HbmLWrite = 8;
+constexpr uint32_t VF0HbmHWrite = 2;
+constexpr uint32_t VF1HbmLRead = 16;
+constexpr uint32_t VF1HbmHRead = 2;
+constexpr uint32_t VF1HbmLWrite = 8;
+constexpr uint32_t VF1HbmHWrite = 2;
 constexpr uint16_t vF0VfidIndex = 88;
 constexpr uint16_t vF0Hbm0ReadIndex = 92;
 constexpr uint16_t vF0Hbm0WriteIndex = 96;
@@ -332,6 +340,14 @@ struct MockMemoryPmt : public PlatformMonitoringTech {
             val = vF0Hbm3ReadValue;
         } else if (key.compare("VF0_HBM3_WRITE") == 0) {
             val = vF0Hbm3WriteValue;
+        } else if (key.compare("VF0_HBM_READ_L") == 0) {
+            val = VF0HbmLRead;
+        } else if (key.compare("VF0_HBM_READ_H") == 0) {
+            val = VF0HbmHRead;
+        } else if (key.compare("VF0_HBM_WRITE_L") == 0) {
+            val = VF0HbmLWrite;
+        } else if (key.compare("VF0_HBM_WRITE_H") == 0) {
+            val = VF0HbmHWrite;
         } else {
             return ZE_RESULT_ERROR_NOT_AVAILABLE;
         }
@@ -363,6 +379,14 @@ struct MockMemoryPmt : public PlatformMonitoringTech {
             val = vF1Hbm3ReadValue;
         } else if (key.compare("VF1_HBM3_WRITE") == 0) {
             val = vF1Hbm3WriteValue;
+        } else if (key.compare("VF1_HBM_READ_L") == 0) {
+            val = VF1HbmLRead;
+        } else if (key.compare("VF1_HBM_READ_H") == 0) {
+            val = VF1HbmHRead;
+        } else if (key.compare("VF1_HBM_WRITE_L") == 0) {
+            val = VF1HbmLWrite;
+        } else if (key.compare("VF1_HBM_WRITE_H") == 0) {
+            val = VF1HbmHWrite;
         } else {
             return ZE_RESULT_ERROR_NOT_AVAILABLE;
         }