add support for zetSysmanPowerGetEnergyCounter

-- add ULT support for power

Change-Id: I37ebebb62c3433a1efe106d6b6546955a2d6effb
Signed-off-by: SaiKishore Konda <saikishore.konda@intel.com>

level_zero/tools/source/sysman/power/linux/CMakeLists.txt

@@ -6,6 +6,7 @@
 
 set(L0_SRCS_TOOLS_SYSMAN_POWER_LINUX
     ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/os_power_imp.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/os_power_imp.h
 )
 
 if(UNIX)
@@ -15,4 +16,4 @@ if(UNIX)
 endif()
 
 # Make our source files visible to parent
-set_property(GLOBAL PROPERTY L0_SRCS_TOOLS_SYSMAN_POWER_LINUX ${L0_SRCS_TOOLS_SYSMAN_POWER_LINUX})
+set_property(GLOBAL PROPERTY L0_SRCS_TOOLS_SYSMAN_POWER_LINUX ${L0_SRCS_TOOLS_SYSMAN_POWER_LINUX})

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

@@ -5,22 +5,14 @@
  *
  */
 
-#include "shared/source/helpers/non_copyable_or_moveable.h"
-
-#include "level_zero/tools/source/sysman/power/os_power.h"
-
-#include "sysman/linux/os_sysman_imp.h"
+#include "level_zero/tools/source/sysman/power/linux/os_power_imp.h"
 
 namespace L0 {
 
-class LinuxPowerImp : public OsPower, public NEO::NonCopyableClass {
-  public:
-    LinuxPowerImp(OsSysman *pOsSysman);
-    ~LinuxPowerImp() override = default;
+ze_result_t LinuxPowerImp::getEnergyCounter(uint64_t &energy) {
 
-  private:
-    SysfsAccess *pSysfsAccess = nullptr;
-};
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
 
 LinuxPowerImp::LinuxPowerImp(OsSysman *pOsSysman) {
     LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
@@ -32,4 +24,4 @@ OsPower *OsPower::create(OsSysman *pOsSysman) {
     return static_cast<OsPower *>(pLinuxPowerImp);
 }
 
-} // namespace L0
+} // namespace L0

level_zero/tools/source/sysman/power/linux/os_power_imp.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "shared/source/helpers/non_copyable_or_moveable.h"
+
+#include "level_zero/tools/source/sysman/power/os_power.h"
+
+#include "sysman/linux/os_sysman_imp.h"
+
+namespace L0 {
+
+class LinuxPowerImp : public OsPower, public NEO::NonCopyableClass {
+  public:
+    ze_result_t getEnergyCounter(uint64_t &energy) override;
+    LinuxPowerImp(OsSysman *pOsSysman);
+    LinuxPowerImp() = default;
+    ~LinuxPowerImp() override = default;
+
+  protected:
+    SysfsAccess *pSysfsAccess = nullptr;
+};
+} // namespace L0

level_zero/tools/source/sysman/power/os_power.h

@@ -14,6 +14,7 @@ namespace L0 {
 struct OsSysman;
 class OsPower {
   public:
+    virtual ze_result_t getEnergyCounter(uint64_t &energy) = 0;
     static OsPower *create(OsSysman *pOsSysman);
     virtual ~OsPower() = default;
 };

level_zero/tools/source/sysman/power/power_imp.cpp

@@ -11,14 +11,30 @@
 
 #include "level_zero/core/source/device/device.h"
 
+#include <chrono>
+
 namespace L0 {
 
+void powerGetTimestamp(uint64_t &timestamp) {
+    std::chrono::time_point<std::chrono::steady_clock> ts = std::chrono::steady_clock::now();
+    timestamp = std::chrono::duration_cast<std::chrono::microseconds>(ts.time_since_epoch()).count();
+}
+
 ze_result_t PowerImp::powerGetProperties(zet_power_properties_t *pProperties) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 ze_result_t PowerImp::powerGetEnergyCounter(zet_power_energy_counter_t *pEnergy) {
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+
+    ze_result_t result = pOsPower->getEnergyCounter(pEnergy->energy);
+
+    if (result != ZE_RESULT_SUCCESS) {
+        return result;
+    }
+
+    powerGetTimestamp(pEnergy->timestamp);
+
+    return result;
 }
 
 ze_result_t PowerImp::powerGetLimits(zet_power_sustained_limit_t *pSustained, zet_power_burst_limit_t *pBurst, zet_power_peak_limit_t *pPeak) {

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

@@ -9,11 +9,19 @@
 
 namespace L0 {
 
-class WddmPowerImp : public OsPower {};
+class WddmPowerImp : public OsPower {
+  public:
+    ze_result_t getEnergyCounter(uint64_t &energy) override;
+};
+
+ze_result_t WddmPowerImp::getEnergyCounter(uint64_t &energy) {
+
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
 
 OsPower *OsPower::create(OsSysman *pOsSysman) {
     WddmPowerImp *pWddmPowerImp = new WddmPowerImp();
     return static_cast<OsPower *>(pWddmPowerImp);
 }
 
-} // namespace L0
+} // namespace L0

level_zero/tools/test/unit_tests/sources/sysman/power/CMakeLists.txt

@@ -0,0 +1,11 @@
+#
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+target_sources(${TARGET_NAME} PRIVATE
+     ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+)
+
+add_subdirectories()

level_zero/tools/test/unit_tests/sources/sysman/power/linux/CMakeLists.txt

@@ -0,0 +1,14 @@
+#
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+if(UNIX)
+    target_sources(${TARGET_NAME}
+        PRIVATE
+           ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+           ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/test_sysman_power.cpp
+           ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/mock_sysfs_power.h
+    )
+endif()

level_zero/tools/test/unit_tests/sources/sysman/power/linux/mock_sysfs_power.h

@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "level_zero/tools/source/sysman/power/linux/os_power_imp.h"
+
+namespace L0 {
+namespace ult {
+
+class PublicLinuxPowerImp : public L0::LinuxPowerImp {
+  public:
+    using LinuxPowerImp::pSysfsAccess;
+};
+} // namespace ult
+} // namespace L0

level_zero/tools/test/unit_tests/sources/sysman/power/linux/test_sysman_power.cpp

@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "mock_sysfs_power.h"
+#include "sysman/power/power_imp.h"
+
+using ::testing::_;
+
+namespace L0 {
+namespace ult {
+
+class SysmanPowerFixture : public DeviceFixture, public ::testing::Test {
+
+  protected:
+    std::unique_ptr<SysmanImp> sysmanImp;
+    zet_sysman_handle_t hSysman;
+
+    OsPower *pOsPower = nullptr;
+    PublicLinuxPowerImp linuxPowerImp;
+    PowerImp *pPowerImp = nullptr;
+
+    void SetUp() override {
+
+        DeviceFixture::SetUp();
+        sysmanImp = std::make_unique<SysmanImp>(device->toHandle());
+        pOsPower = static_cast<OsPower *>(&linuxPowerImp);
+        pPowerImp = new PowerImp();
+        pPowerImp->pOsPower = pOsPower;
+        pPowerImp->init();
+        hSysman = sysmanImp->toHandle();
+    }
+    void TearDown() override {
+        //pOsPower is static_cast of LinuxPowerImp class , hence in cleanup assign to nullptr
+        if (pPowerImp != nullptr) {
+            pPowerImp->pOsPower = nullptr;
+            delete pPowerImp;
+            pPowerImp = nullptr;
+        }
+        DeviceFixture::TearDown();
+    }
+};
+
+TEST_F(SysmanPowerFixture, GivenComponentCountZeroWhenCallingZetSysmanPowerGetThenZeroCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
+    uint32_t count = 0;
+    ze_result_t result = zetSysmanPowerGet(hSysman, &count, NULL);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(count, 0u);
+
+    uint32_t testcount = count + 1;
+
+    result = zetSysmanPowerGet(hSysman, &testcount, NULL);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(testcount, count);
+}
+} // namespace ult
+} // namespace L0