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

Add StandbySetMode support

Browse Source 
Added mode setting support for standby if required permission is available

Signed-off-by: Joshua Santosh Ranjan <joshua.santosh.ranjan@intel.com>
This commit is contained in:
Joshua Santosh Ranjan
2021-06-29 09:06:21 +05:30
committed by Compute-Runtime-Automation
parent bb51681bbb
commit d3d2e153f2
5 changed files with 126 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
level_zero/tools/source/sysman/standby/linux/CMakeLists.txt
View File

@@ -6,7 +6,7 @@
set(L0_SRCS_TOOLS_SYSMAN_STANDBY_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/os_standby_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/os_standby_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/os_standby_imp.h
)

17
level_zero/tools/source/sysman/standby/linux/os_standby_imp.cpp
View File

@@ -47,12 +47,17 @@ ze_result_t LinuxStandbyImp::getMode(zes_standby_promo_mode_t &mode) {
}
ze_result_t LinuxStandbyImp::setMode(zes_standby_promo_mode_t mode) {
// standbyModeFile is not writable.
// Mode cannot be set from L0.
// To set the mode, user must reload
// the i915 module and set module parameter
// enable_rc6 appropriately.
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
ze_result_t result = ZE_RESULT_ERROR_UNKNOWN;
if (ZES_STANDBY_PROMO_MODE_DEFAULT == mode) {
result = pSysfsAccess->write(standbyModeFile, standbyModeDefault);
} else {
result = pSysfsAccess->write(standbyModeFile, standbyModeNever);
}
if (ZE_RESULT_ERROR_NOT_AVAILABLE == result) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
return result;
}
LinuxStandbyImp::LinuxStandbyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) : isSubdevice(onSubdevice), subdeviceId(subdeviceId) {

6
level_zero/tools/test/unit_tests/sources/sysman/standby/linux/CMakeLists.txt
View File

@@ -1,5 +1,5 @@
#
# Copyright (C) 2020 Intel Corporation
# Copyright (C) 2020-2021 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
@@ -8,8 +8,8 @@ if(UNIX)
target_sources(${TARGET_NAME}
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/mock_sysfs_standby.h
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/test_zes_sysman_standby.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_standby.h
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_sysman_standby.cpp
)
endif()

46
level_zero/tools/test/unit_tests/sources/sysman/standby/linux/mock_sysfs_standby.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -19,33 +19,57 @@ class StandbySysfsAccess : public SysfsAccess {};
template <>
struct Mock<StandbySysfsAccess> : public StandbySysfsAccess {
int mockStandbyMode = -1;
bool isStandbyModeFileAvailable = true;
::mode_t mockStandbyFileMode = S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR;
MOCK_METHOD(ze_result_t, read, (const std::string file, int &val), (override));
MOCK_METHOD(ze_result_t, write, (const std::string file, int val), (override));
MOCK_METHOD(ze_result_t, canRead, (const std::string file), (override));
ze_result_t getCanReadStatus(const std::string file) {
if (file.compare(standbyModeFile) == 0) {
if (isFileAccessible(file) == true) {
return ZE_RESULT_SUCCESS;
}
return ZE_RESULT_ERROR_UNKNOWN;
}
ze_result_t getVal(const std::string file, int &val) {
if (file.compare(standbyModeFile) == 0) {
if ((isFileAccessible(file) == true) &&
(mockStandbyFileMode & S_IRUSR) != 0) {
val = mockStandbyMode;
return ZE_RESULT_SUCCESS;
}
return ZE_RESULT_ERROR_NOT_AVAILABLE;
if (isStandbyModeFileAvailable == false) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
if ((mockStandbyFileMode & S_IRUSR) == 0) {
return ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;
}
return ZE_RESULT_ERROR_UNKNOWN;
}
ze_result_t setVal(const std::string file, const int val) {
if (file.compare(standbyModeFile) == 0) {
if ((isFileAccessible(file) == true) &&
(mockStandbyFileMode & S_IWUSR) != 0) {
mockStandbyMode = val;
return ZE_RESULT_SUCCESS;
}
return ZE_RESULT_ERROR_NOT_AVAILABLE;
if (isFileAccessible(file) == false) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
if ((mockStandbyFileMode & S_IWUSR) == 0) {
return ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;
}
return ZE_RESULT_ERROR_UNKNOWN;
}
ze_result_t setValReturnError(const std::string file, const int val) {
if (file.compare(standbyModeFile) == 0) {
if (isFileAccessible(file) == true) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_ERROR_NOT_AVAILABLE;
@@ -53,6 +77,14 @@ struct Mock<StandbySysfsAccess> : public StandbySysfsAccess {
Mock() = default;
~Mock() override = default;
private:
bool isFileAccessible(const std::string file) {
if ((file.compare(standbyModeFile) == 0) && (isStandbyModeFileAvailable == true)) {
return true;
}
return false;
}
};
class PublicLinuxStandbyImp : public L0::LinuxStandbyImp {

74
level_zero/tools/test/unit_tests/sources/sysman/standby/linux/test_zes_sysman_standby.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -34,6 +34,8 @@ class ZesStandbyFixture : public SysmanDeviceFixture {
ptestSysfsAccess->setVal(standbyModeFile, standbyModeDefault);
ON_CALL(*ptestSysfsAccess.get(), read(_, Matcher<int &>(_)))
.WillByDefault(::testing::Invoke(ptestSysfsAccess.get(), &Mock<StandbySysfsAccess>::getVal));
ON_CALL(*ptestSysfsAccess.get(), write(_, Matcher<int>(_)))
.WillByDefault(::testing::Invoke(ptestSysfsAccess.get(), &Mock<StandbySysfsAccess>::setVal));
ON_CALL(*ptestSysfsAccess.get(), canRead(_))
.WillByDefault(::testing::Invoke(ptestSysfsAccess.get(), &Mock<StandbySysfsAccess>::getCanReadStatus));
for (const auto &handle : pSysmanDeviceImp->pStandbyHandleContext->handleList) {
@@ -163,13 +165,80 @@ TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenCallingzesStandbyGetModeThe
}
}
TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenCallingzesStandbySetModeThenVerifySysmanzesySetModeCallFailsWithUnsupported) {
TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenCallingzesStandbyGetModeOnUnavailableFileThenVerifyzesStandbyGetModeCallFailsForUnsupportedFeature) {
zes_standby_promo_mode_t mode = {};
ptestSysfsAccess->setVal(standbyModeFile, standbyModeInvalid);
auto handles = get_standby_handles(mockHandleCount);
ptestSysfsAccess->isStandbyModeFileAvailable = false;
for (auto hSysmanStandby : handles) {
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesStandbyGetMode(hSysmanStandby, &mode));
}
}
TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenCallingzesStandbyGetModeWithInsufficientPermissionsThenVerifyzesStandbyGetModeCallFailsForInsufficientPermissions) {
zes_standby_promo_mode_t mode = {};
ptestSysfsAccess->setVal(standbyModeFile, standbyModeInvalid);
auto handles = get_standby_handles(mockHandleCount);
ptestSysfsAccess->mockStandbyFileMode &= ~S_IRUSR;
for (auto hSysmanStandby : handles) {
EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, zesStandbyGetMode(hSysmanStandby, &mode));
}
}
TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenCallingzesStandbySetModeThenwithUnwritableFileVerifySysmanzesySetModeCallFailedWithInsufficientPermissions) {
auto handles = get_standby_handles(mockHandleCount);
ptestSysfsAccess->mockStandbyFileMode &= ~S_IWUSR;
for (auto hSysmanStandby : handles) {
EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, zesStandbySetMode(hSysmanStandby, ZES_STANDBY_PROMO_MODE_NEVER));
}
}
TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenCallingzesStandbySetModeOnUnavailableFileThenVerifyzesStandbySetModeCallFailsForUnsupportedFeature) {
auto handles = get_standby_handles(mockHandleCount);
ptestSysfsAccess->isStandbyModeFileAvailable = false;
for (auto hSysmanStandby : handles) {
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesStandbySetMode(hSysmanStandby, ZES_STANDBY_PROMO_MODE_NEVER));
}
}
TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenCallingzesStandbySetModeNeverThenVerifySysmanzesySetModeCallSucceeds) {
auto handles = get_standby_handles(mockHandleCount);
for (auto hSysmanStandby : handles) {
zes_standby_promo_mode_t mode;
ptestSysfsAccess->setVal(standbyModeFile, standbyModeDefault);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesStandbyGetMode(hSysmanStandby, &mode));
EXPECT_EQ(ZES_STANDBY_PROMO_MODE_DEFAULT, mode);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesStandbySetMode(hSysmanStandby, ZES_STANDBY_PROMO_MODE_NEVER));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesStandbyGetMode(hSysmanStandby, &mode));
EXPECT_EQ(ZES_STANDBY_PROMO_MODE_NEVER, mode);
}
}
TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenCallingzesStandbySetModeDefaultThenVerifySysmanzesySetModeCallSucceeds) {
auto handles = get_standby_handles(mockHandleCount);
for (auto hSysmanStandby : handles) {
zes_standby_promo_mode_t mode;
ptestSysfsAccess->setVal(standbyModeFile, standbyModeNever);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesStandbyGetMode(hSysmanStandby, &mode));
EXPECT_EQ(ZES_STANDBY_PROMO_MODE_NEVER, mode);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesStandbySetMode(hSysmanStandby, ZES_STANDBY_PROMO_MODE_DEFAULT));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesStandbyGetMode(hSysmanStandby, &mode));
EXPECT_EQ(ZES_STANDBY_PROMO_MODE_DEFAULT, mode);
}
}
TEST_F(ZesStandbyFixture, GivenOnSubdeviceNotSetWhenValidatingosStandbyGetPropertiesThenSuccessIsReturned) {
zes_standby_properties_t properties = {};
ze_device_properties_t deviceProperties = {};
@@ -260,5 +329,6 @@ TEST_F(ZesStandbyMultiDeviceFixture, GivenOnSubdeviceNotSetWhenValidatingosStand
EXPECT_EQ(properties.onSubdevice, isSubDevice);
delete pLinuxStandbyImp;
}
} // namespace ult
} // namespace L0