Sysman for Windows: Fix timestamp units for power and engines.

Returning now in usecs as the documentation state it should be.

level_zero/tools/source/sysman/engine/windows/os_engine_imp.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020 Intel Corporation
+ * Copyright (C) 2020-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -10,7 +10,9 @@
 namespace L0 {
 
 ze_result_t WddmEngineImp::getActivity(zes_engine_stats_t *pStats) {
-    uint64_t value = 0;
+    uint64_t activeTime = 0;
+    uint64_t timeStamp = 0;
+    uint32_t timestampFrequency = 0;
     KmdSysman::RequestProperty request;
     KmdSysman::ResponseProperty response;
 
@@ -40,10 +42,27 @@ ze_result_t WddmEngineImp::getActivity(zes_engine_stats_t *pStats) {
         return status;
     }
 
-    memcpy_s(&value, sizeof(uint64_t), response.dataBuffer, sizeof(uint64_t));
-    pStats->activeTime = value;
-    memcpy_s(&value, sizeof(uint64_t), (response.dataBuffer + sizeof(uint64_t)), sizeof(uint64_t));
-    pStats->timestamp = value;
+    memcpy_s(&activeTime, sizeof(uint64_t), response.dataBuffer, sizeof(uint64_t));
+    memcpy_s(&timeStamp, sizeof(uint64_t), (response.dataBuffer + sizeof(uint64_t)), sizeof(uint64_t));
+
+    request.requestId = KmdSysman::Requests::Activity::TimestampFrequency;
+
+    status = pKmdSysManager->requestSingle(request, response);
+
+    if (status != ZE_RESULT_SUCCESS) {
+        return status;
+    }
+
+    memcpy_s(&timestampFrequency, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
+    double timeFactor = 1.0 / static_cast<double>(timestampFrequency);
+
+    double elapsedTime = static_cast<double>(activeTime) * timeFactor;
+    elapsedTime *= static_cast<double>(microFacor);
+    pStats->activeTime = static_cast<uint64_t>(elapsedTime);
+
+    elapsedTime = static_cast<double>(timeStamp) * timeFactor;
+    elapsedTime *= static_cast<double>(microFacor);
+    pStats->timestamp = static_cast<uint64_t>(elapsedTime);
 
     return status;
 }

level_zero/tools/source/sysman/power/windows/os_power_imp.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020 Intel Corporation
+ * Copyright (C) 2020-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -64,6 +64,7 @@ ze_result_t WddmPowerImp::getProperties(zes_power_properties_t *pProperties) {
 
 ze_result_t WddmPowerImp::getEnergyCounter(zes_power_energy_counter_t *pEnergy) {
     uint32_t energyUnits = 0;
+    uint32_t timestampFrequency = 0;
     KmdSysman::RequestProperty request;
     KmdSysman::ResponseProperty response;
 
@@ -95,7 +96,22 @@ ze_result_t WddmPowerImp::getEnergyCounter(zes_power_energy_counter_t *pEnergy)
     valueConverted *= static_cast<double>(convertJouleToMicroJoule);
     pEnergy->energy = static_cast<uint64_t>(valueConverted);
     memcpy_s(&valueTimeStamp, sizeof(uint64_t), (response.dataBuffer + sizeof(uint32_t)), sizeof(uint64_t));
-    pEnergy->timestamp = valueTimeStamp;
+
+    request.commandId = KmdSysman::Command::Get;
+    request.componentId = KmdSysman::Component::ActivityComponent;
+    request.requestId = KmdSysman::Requests::Activity::TimestampFrequency;
+
+    status = pKmdSysManager->requestSingle(request, response);
+
+    if (status != ZE_RESULT_SUCCESS) {
+        return status;
+    }
+
+    memcpy_s(&timestampFrequency, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
+    double timeFactor = 1.0 / static_cast<double>(timestampFrequency);
+    timeFactor = static_cast<double>(valueTimeStamp) * timeFactor;
+    timeFactor *= static_cast<double>(microFacor);
+    pEnergy->timestamp = static_cast<uint64_t>(timeFactor);
 
     return status;
 }

level_zero/tools/source/sysman/sysman_const.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020 Intel Corporation
+ * Copyright (C) 2020-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -41,4 +41,5 @@ constexpr uint64_t minTimeoutInMicroSeconds = 1000u;
 constexpr uint16_t milliSecsToMicroSecs = 1000;
 constexpr uint64_t numSocTemperatureEntries = 7;
 constexpr uint32_t numCoreTemperatureEntries = 4;
-constexpr uint32_t milliFactor = 1000u;
+constexpr uint32_t milliFactor = 1000u;
+constexpr uint32_t microFacor = milliFactor * milliFactor;

level_zero/tools/test/unit_tests/sources/sysman/engine/windows/mock_engine.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020 Intel Corporation
+ * Copyright (C) 2020-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -18,9 +18,10 @@ template <>
 struct Mock<EngineKmdSysManager> : public EngineKmdSysManager {
 
     KmdSysman::ActivityDomainsType mockEngineTypes[3] = {KmdSysman::ActivityDomainsType::ActitvityDomainGT, KmdSysman::ActivityDomainsType::ActivityDomainRenderCompute, KmdSysman::ActivityDomainsType::ActivityDomainMedia};
-    uint64_t mockActivityCounters[3] = {652115546, 22115546, 4115546};
-    uint64_t mockActivityTimeStamps[3] = {456465421541, 456465421545, 456465421548};
+    uint64_t mockActivityCounters[3] = {652411, 222115, 451115};
+    uint64_t mockActivityTimeStamps[3] = {4465421, 2566851, 1226621};
     uint32_t mockNumSupportedEngineGroups = 3;
+    uint32_t mockFrequencyTimeStamp = 38400000;
 
     void getActivityProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
         uint8_t *pBuffer = reinterpret_cast<uint8_t *>(pResponse);
@@ -49,6 +50,12 @@ struct Mock<EngineKmdSysManager> : public EngineKmdSysManager {
             pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
             pResponse->outDataSize = 2 * sizeof(uint64_t);
         } break;
+        case KmdSysman::Requests::Activity::TimestampFrequency: {
+            uint32_t *pValueFrequency = reinterpret_cast<uint32_t *>(pBuffer);
+            *pValueFrequency = mockFrequencyTimeStamp;
+            pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
+            pResponse->outDataSize = sizeof(uint32_t);
+        } break;
         default: {
             pResponse->outDataSize = 0;
             pResponse->outReturnCode = KmdSysman::KmdSysmanFail;

level_zero/tools/test/unit_tests/sources/sysman/engine/windows/test_zes_engine.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020 Intel Corporation
+ * Copyright (C) 2020-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -104,8 +104,8 @@ TEST_F(SysmanDeviceEngineFixture, GivenValidHandleGetAvtivityThenCorrectValuesAr
         ze_result_t result = zesEngineGetActivity(handle, &stats);
 
         EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-        EXPECT_EQ(stats.activeTime, pKmdSysManager->mockActivityCounters[engineGroupIndex]);
-        EXPECT_EQ(stats.timestamp, pKmdSysManager->mockActivityTimeStamps[engineGroupIndex]);
+        EXPECT_EQ(stats.activeTime, convertTStoMicroSec(pKmdSysManager->mockActivityCounters[engineGroupIndex], pKmdSysManager->mockFrequencyTimeStamp));
+        EXPECT_EQ(stats.timestamp, convertTStoMicroSec(pKmdSysManager->mockActivityTimeStamps[engineGroupIndex], pKmdSysManager->mockFrequencyTimeStamp));
         engineGroupIndex++;
     }
 }

level_zero/tools/test/unit_tests/sources/sysman/power/windows/mock_power.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020 Intel Corporation
+ * Copyright (C) 2020-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -34,6 +34,26 @@ struct Mock<PowerKmdSysManager> : public PowerKmdSysManager {
     uint32_t mockTimeStamp = 1123412412;
     uint32_t mockEnergyUnit = 14;
 
+    uint32_t mockFrequencyTimeStamp = 38400000;
+
+    void getActivityProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
+        uint8_t *pBuffer = reinterpret_cast<uint8_t *>(pResponse);
+        pBuffer += sizeof(KmdSysman::GfxSysmanReqHeaderOut);
+
+        switch (pRequest->inRequestId) {
+        case KmdSysman::Requests::Activity::TimestampFrequency: {
+            uint32_t *pValueFrequency = reinterpret_cast<uint32_t *>(pBuffer);
+            *pValueFrequency = mockFrequencyTimeStamp;
+            pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
+            pResponse->outDataSize = sizeof(uint32_t);
+        } break;
+        default: {
+            pResponse->outDataSize = 0;
+            pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
+        } break;
+        }
+    }
+
     void getPowerProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) override {
         uint8_t *pBuffer = reinterpret_cast<uint8_t *>(pResponse);
         pBuffer += sizeof(KmdSysman::GfxSysmanReqHeaderOut);

level_zero/tools/test/unit_tests/sources/sysman/power/windows/test_zes_sysman_power.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020 Intel Corporation
+ * Copyright (C) 2020-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -145,7 +145,7 @@ TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerEnergyCoun
         uint64_t mockEnergytoMicroJoules = static_cast<uint64_t>(valueConverted);
         EXPECT_EQ(ZE_RESULT_SUCCESS, result);
         EXPECT_EQ(energyCounter.energy, mockEnergytoMicroJoules);
-        EXPECT_EQ(energyCounter.timestamp, pKmdSysManager->mockTimeStamp);
+        EXPECT_EQ(energyCounter.timestamp, convertTStoMicroSec(pKmdSysManager->mockTimeStamp, pKmdSysManager->mockFrequencyTimeStamp));
     }
 }
 

level_zero/tools/test/unit_tests/sources/sysman/windows/mock_kmd_sys_manager.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2020 Intel Corporation
+ * Copyright (C) 2019-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -25,6 +25,8 @@ struct MockEventHandle {
     bool inited = false;
 };
 
+uint64_t convertTStoMicroSec(uint64_t TS, uint32_t freq);
+
 class MockKmdSysManager : public KmdSysManager {};
 
 template <>

level_zero/tools/test/unit_tests/sources/sysman/windows/test_sysman_manager.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2020 Intel Corporation
+ * Copyright (C) 2019-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -23,6 +23,13 @@ using ::testing::Return;
 namespace L0 {
 namespace ult {
 
+uint64_t convertTStoMicroSec(uint64_t TS, uint32_t freq) {
+    double timeFactor = 1.0 / static_cast<double>(freq);
+    timeFactor = static_cast<double>(TS) * timeFactor;
+    timeFactor *= static_cast<double>(microFacor);
+    return static_cast<uint64_t>(timeFactor);
+}
+
 class SysmanKmdManagerFixture : public ::testing::Test {
 
   protected: