Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add support for extended power properties

Browse Source 
Related-To: LOCI-3242

Signed-off-by: Bellekallu Rajkiran <bellekallu.rajkiran@intel.com>
This commit is contained in:
Bellekallu Rajkiran
2022-07-14 17:40:14 +00:00
committed by Compute-Runtime-Automation
parent 582ed0565b
commit f23f78e2cc
13 changed files with 199 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
level_zero/tools/source/sysman/power/linux/os_power_imp.cpp
View File

@ -58,6 +58,10 @@ ze_result_t LinuxPowerImp::getProperties(zes_power_properties_t *pProperties) {
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxPowerImp::getPropertiesExt(zes_power_ext_properties_t *pExtPoperties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxPowerImp::getPmtEnergyCounter(zes_power_energy_counter_t *pEnergy) {
const std::string key("PACKAGE_ENERGY");
uint64_t energy = 0;

1
level_zero/tools/source/sysman/power/linux/os_power_imp.h
View File

@ -27,6 +27,7 @@ class LinuxPowerImp : public OsPower, NEO::NonCopyableOrMovableClass {
ze_result_t setEnergyThreshold(double threshold) override;
ze_result_t getLimitsExt(uint32_t *pCount, zes_power_limit_ext_desc_t *pSustained) override;
ze_result_t setLimitsExt(uint32_t *pCount, zes_power_limit_ext_desc_t *pSustained) override;
ze_result_t getPropertiesExt(zes_power_ext_properties_t *pExtPoperties) override;
bool isPowerModuleSupported() override;
bool isHwmonDir(std::string name);

27
level_zero/tools/source/sysman/power/linux/os_power_imp_prelim.cpp
View File

@ -34,12 +34,29 @@ ze_result_t LinuxPowerImp::getProperties(zes_power_properties_t *pProperties) {
pProperties->defaultLimit = -1;
pProperties->minLimit = -1;
pProperties->maxLimit = -1;
if (!isSubdevice) {
uint32_t val = 0;
auto result = pSysfsAccess->read(i915HwmonDir + "/" + defaultPowerLimit, val);
if (ZE_RESULT_SUCCESS == result) {
pProperties->defaultLimit = static_cast<int32_t>(val / milliFactor); // need to convert from microwatt to milliwatt
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxPowerImp::getPropertiesExt(zes_power_ext_properties_t *pExtPoperties) {
pExtPoperties->domain = isSubdevice ? ZES_POWER_DOMAIN_PACKAGE : ZES_POWER_DOMAIN_CARD;
if (pExtPoperties->defaultLimit) {
if (!isSubdevice) {
uint32_t val = 0;
ze_result_t result = pSysfsAccess->read(i915HwmonDir + "/" + defaultPowerLimit, val);
if (result == ZE_RESULT_SUCCESS) {
pExtPoperties->defaultLimit->limit = static_cast<int32_t>(val / milliFactor); // need to convert from microwatt to milliwatt
} else {
return getErrorCode(result);
}
} else {
pExtPoperties->defaultLimit->limit = -1;
}
pExtPoperties->defaultLimit->limitUnit = ZES_LIMIT_UNIT_POWER;
pExtPoperties->defaultLimit->enabledStateLocked = true;
pExtPoperties->defaultLimit->intervalValueLocked = true;
pExtPoperties->defaultLimit->limitValueLocked = true;
pExtPoperties->defaultLimit->source = ZES_POWER_SOURCE_ANY;
pExtPoperties->defaultLimit->level = ZES_POWER_LEVEL_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}

1
level_zero/tools/source/sysman/power/linux/os_power_imp_prelim.h
View File

@ -29,6 +29,7 @@ class LinuxPowerImp : public OsPower, NEO::NonCopyableOrMovableClass {
ze_result_t setEnergyThreshold(double threshold) override;
ze_result_t getLimitsExt(uint32_t *pCount, zes_power_limit_ext_desc_t *pSustained) override;
ze_result_t setLimitsExt(uint32_t *pCount, zes_power_limit_ext_desc_t *pSustained) override;
ze_result_t getPropertiesExt(zes_power_ext_properties_t *pExtPoperties) override;
bool isPowerModuleSupported() override;
bool isHwmonDir(std::string name);

1
level_zero/tools/source/sysman/power/os_power.h
View File

@ -22,6 +22,7 @@ class OsPower {
virtual ze_result_t setEnergyThreshold(double threshold) = 0;
virtual ze_result_t getLimitsExt(uint32_t *pCount, zes_power_limit_ext_desc_t *pSustained) = 0;
virtual ze_result_t setLimitsExt(uint32_t *pCount, zes_power_limit_ext_desc_t *pSustained) = 0;
virtual ze_result_t getPropertiesExt(zes_power_ext_properties_t *pExtPoperties) = 0;
virtual bool isPowerModuleSupported() = 0;
static OsPower *create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId);

1
level_zero/tools/source/sysman/power/power.h
View File

@ -40,7 +40,6 @@ class Power : _zet_sysman_pwr_handle_t, _zes_pwr_handle_t {
inline zes_pwr_handle_t toHandle() { return this; }
bool initSuccess = false;
bool isCardPower = false;
zes_power_properties_t powerProperties = {};
};
struct PowerHandleContext {
PowerHandleContext(OsSysman *pOsSysman) : pOsSysman(pOsSysman){};

15
level_zero/tools/source/sysman/power/power_imp.cpp
View File

@ -12,8 +12,21 @@
namespace L0 {
ze_result_t PowerImp::powerGetProperties(zes_power_properties_t *pProperties) {
ze_result_t result = ZE_RESULT_SUCCESS;
void *pNext = pProperties->pNext;
*pProperties = powerProperties;
return ZE_RESULT_SUCCESS;
pProperties->pNext = pNext;
while (pNext) {
zes_power_ext_properties_t *pExtProps = reinterpret_cast<zes_power_ext_properties_t *>(pNext);
if (pExtProps->stype == ZES_STRUCTURE_TYPE_POWER_EXT_PROPERTIES) {
result = pOsPower->getPropertiesExt(pExtProps);
if (result != ZE_RESULT_SUCCESS) {
return result;
}
}
pNext = pExtProps->pNext;
}
return result;
}
ze_result_t PowerImp::powerGetEnergyCounter(zes_power_energy_counter_t *pEnergy) {

1
level_zero/tools/source/sysman/power/power_imp.h
View File

@ -33,5 +33,6 @@ class PowerImp : public Power, NEO::NonCopyableOrMovableClass {
private:
ze_device_handle_t deviceHandle = {};
zes_power_properties_t powerProperties = {};
};
} // namespace L0

4
level_zero/tools/source/sysman/power/windows/os_power_imp.cpp
View File

@ -60,6 +60,10 @@ ze_result_t WddmPowerImp::getProperties(zes_power_properties_t *pProperties) {
return ZE_RESULT_SUCCESS;
}
ze_result_t WddmPowerImp::getPropertiesExt(zes_power_ext_properties_t *pExtPoperties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmPowerImp::getEnergyCounter(zes_power_energy_counter_t *pEnergy) {
uint32_t energyUnits = 0;
uint32_t timestampFrequency = 0;

1
level_zero/tools/source/sysman/power/windows/os_power_imp.h
View File

@ -23,6 +23,7 @@ class WddmPowerImp : public OsPower, NEO::NonCopyableOrMovableClass {
ze_result_t setEnergyThreshold(double threshold) override;
ze_result_t getLimitsExt(uint32_t *pCount, zes_power_limit_ext_desc_t *pSustained) override;
ze_result_t setLimitsExt(uint32_t *pCount, zes_power_limit_ext_desc_t *pSustained) override;
ze_result_t getPropertiesExt(zes_power_ext_properties_t *pExtPoperties) override;
bool isPowerModuleSupported() override;
WddmPowerImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId);

30
level_zero/tools/test/unit_tests/sources/sysman/power/linux/test_zes_power.cpp
View File

@ -655,5 +655,35 @@ TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandlesWhenCallingSetAndGetPower
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerPropertiesExtThenApiReturnsFailure) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
zes_power_properties_t properties = {};
zes_power_ext_properties_t extProperties = {};
extProperties.stype = ZES_STRUCTURE_TYPE_POWER_EXT_PROPERTIES;
properties.pNext = &extProperties;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetProperties(handle, &properties));
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerPropertiesExtWithoutStypeThenExtPropertiesAreNotReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
zes_power_properties_t properties = {};
zes_power_ext_properties_t extProperties = {};
properties.pNext = &extProperties;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
EXPECT_FALSE(properties.onSubdevice);
EXPECT_EQ(properties.subdeviceId, 0u);
EXPECT_EQ(properties.canControl, true);
EXPECT_EQ(properties.isEnergyThresholdSupported, false);
EXPECT_EQ(properties.defaultLimit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
EXPECT_EQ(properties.maxLimit, (int32_t)(mockMaxPowerLimitVal / milliFactor));
EXPECT_EQ(properties.minLimit, (int32_t)(mockMinPowerLimitVal / milliFactor));
}
}
} // namespace ult
} // namespace L0

64
level_zero/tools/test/unit_tests/sources/sysman/power/linux/test_zes_power_helper_prelim.cpp
View File

@ -60,7 +60,7 @@ TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerPointerWhenGett
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerHandleWhenGettingPowerPropertiesThenCallSucceeds) {
auto handles = getPowerHandles(powerHandleComponentCountMultiDevice);
for (auto handle : handles) {
zes_power_properties_t properties;
zes_power_properties_t properties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
if (properties.onSubdevice) {
EXPECT_FALSE(properties.canControl);
@ -68,7 +68,63 @@ TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerHandleWhenGetti
} else {
EXPECT_EQ(properties.canControl, true);
EXPECT_EQ(properties.defaultLimit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
EXPECT_EQ(properties.defaultLimit, -1);
}
EXPECT_EQ(properties.isEnergyThresholdSupported, false);
EXPECT_EQ(properties.maxLimit, -1);
EXPECT_EQ(properties.minLimit, -1);
}
}
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerHandleWhenGettingPowerPropertiesAndExtPropertiesThenCallSucceeds) {
auto handles = getPowerHandles(powerHandleComponentCountMultiDevice);
for (auto handle : handles) {
zes_power_properties_t properties = {};
zes_power_ext_properties_t extProperties = {};
zes_power_limit_ext_desc_t defaultLimit = {};
extProperties.defaultLimit = &defaultLimit;
extProperties.stype = ZES_STRUCTURE_TYPE_POWER_EXT_PROPERTIES;
properties.pNext = &extProperties;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
EXPECT_EQ(properties.defaultLimit, -1);
EXPECT_TRUE(defaultLimit.limitValueLocked);
EXPECT_TRUE(defaultLimit.enabledStateLocked);
EXPECT_TRUE(defaultLimit.intervalValueLocked);
EXPECT_EQ(defaultLimit.level, ZES_POWER_LEVEL_UNKNOWN);
EXPECT_EQ(defaultLimit.source, ZES_POWER_SOURCE_ANY);
EXPECT_EQ(defaultLimit.limitUnit, ZES_LIMIT_UNIT_POWER);
if (properties.onSubdevice) {
EXPECT_FALSE(properties.canControl);
EXPECT_EQ(extProperties.domain, ZES_POWER_DOMAIN_PACKAGE);
EXPECT_EQ(defaultLimit.limit, -1);
} else {
EXPECT_TRUE(properties.canControl);
EXPECT_EQ(extProperties.domain, ZES_POWER_DOMAIN_CARD);
EXPECT_EQ(defaultLimit.limit, static_cast<int32_t>(mockDefaultPowerLimitVal / milliFactor));
}
EXPECT_EQ(properties.isEnergyThresholdSupported, false);
EXPECT_EQ(properties.maxLimit, -1);
EXPECT_EQ(properties.minLimit, -1);
}
}
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerHandleAndExtPropertiesWithNullDescWhenGettingPowerPropertiesThenCallSucceeds) {
auto handles = getPowerHandles(powerHandleComponentCountMultiDevice);
for (auto handle : handles) {
zes_power_properties_t properties = {};
zes_power_ext_properties_t extProperties = {};
properties.pNext = &extProperties;
extProperties.stype = ZES_STRUCTURE_TYPE_POWER_EXT_PROPERTIES;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
EXPECT_EQ(properties.defaultLimit, -1);
if (properties.onSubdevice) {
EXPECT_FALSE(properties.canControl);
EXPECT_EQ(extProperties.domain, ZES_POWER_DOMAIN_PACKAGE);
} else {
EXPECT_TRUE(properties.canControl);
EXPECT_EQ(extProperties.domain, ZES_POWER_DOMAIN_CARD);
}
EXPECT_EQ(properties.isEnergyThresholdSupported, false);
EXPECT_EQ(properties.maxLimit, -1);
@ -121,7 +177,7 @@ TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerHandleWhenGetti
auto handles = getPowerHandles(powerHandleComponentCountMultiDevice);
for (auto handle : handles) {
zes_power_properties_t properties;
zes_power_properties_t properties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
zes_power_energy_counter_t energyCounter = {};
ASSERT_EQ(ZE_RESULT_SUCCESS, zesPowerGetEnergyCounter(handle, &energyCounter));
@ -136,7 +192,7 @@ TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerHandleWhenGetti
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenSetPowerLimitsWhenGettingPowerLimitsThenLimitsSetEarlierAreRetrieved) {
auto handles = getPowerHandles(powerHandleComponentCountMultiDevice);
for (auto handle : handles) {
zes_power_properties_t properties;
zes_power_properties_t properties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
zes_power_sustained_limit_t sustainedSet = {};

98
level_zero/tools/test/unit_tests/sources/sysman/power/linux/test_zes_power_prelim.cpp
View File

@ -109,69 +109,76 @@ TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerProperties
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
zes_power_properties_t properties;
zes_power_properties_t properties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
EXPECT_FALSE(properties.onSubdevice);
EXPECT_EQ(properties.subdeviceId, 0u);
EXPECT_EQ(properties.canControl, true);
EXPECT_EQ(properties.isEnergyThresholdSupported, false);
EXPECT_EQ(properties.defaultLimit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
EXPECT_EQ(properties.maxLimit, -1);
EXPECT_EQ(properties.minLimit, -1);
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerPropertiesWhenHwmonInterfaceExistThenLimitsReturnsUnkown) {
pSysfsAccess->mockReadResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pSysmanDeviceImp->pPowerHandleContext->init(deviceHandles, device->toHandle());
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
zes_power_properties_t properties;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
EXPECT_FALSE(properties.onSubdevice);
EXPECT_EQ(properties.subdeviceId, 0u);
EXPECT_EQ(properties.defaultLimit, -1);
EXPECT_EQ(properties.maxLimit, -1);
EXPECT_EQ(properties.minLimit, -1);
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerPropertiesWhenHwmonInterfaceExistThenMaxLimitIsUnsupported) {
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pSysmanDeviceImp->pPowerHandleContext->init(deviceHandles, device->toHandle());
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerPropertiesAndExtPropertiesThenCallSucceeds) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
zes_power_properties_t properties;
zes_power_properties_t properties = {};
zes_power_ext_properties_t extProperties = {};
zes_power_limit_ext_desc_t defaultLimit = {};
extProperties.defaultLimit = &defaultLimit;
extProperties.stype = ZES_STRUCTURE_TYPE_POWER_EXT_PROPERTIES;
properties.pNext = &extProperties;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
EXPECT_FALSE(properties.onSubdevice);
EXPECT_EQ(properties.subdeviceId, 0u);
EXPECT_EQ(properties.defaultLimit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
EXPECT_EQ(properties.canControl, true);
EXPECT_EQ(properties.isEnergyThresholdSupported, false);
EXPECT_EQ(properties.defaultLimit, -1);
EXPECT_EQ(properties.maxLimit, -1);
EXPECT_EQ(properties.minLimit, -1);
EXPECT_EQ(extProperties.domain, ZES_POWER_DOMAIN_CARD);
EXPECT_TRUE(defaultLimit.limitValueLocked);
EXPECT_TRUE(defaultLimit.enabledStateLocked);
EXPECT_TRUE(defaultLimit.intervalValueLocked);
EXPECT_EQ(ZES_POWER_SOURCE_ANY, defaultLimit.source);
EXPECT_EQ(ZES_LIMIT_UNIT_POWER, defaultLimit.limitUnit);
EXPECT_EQ(defaultLimit.limit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWithNoStypeForExtPropertiesWhenGettingPowerPropertiesAndExtPropertiesThenCallSucceeds) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
zes_power_properties_t properties = {};
zes_power_ext_properties_t extProperties = {};
zes_power_limit_ext_desc_t defaultLimit = {};
extProperties.defaultLimit = &defaultLimit;
properties.pNext = &extProperties;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
EXPECT_FALSE(properties.onSubdevice);
EXPECT_EQ(properties.subdeviceId, 0u);
EXPECT_EQ(properties.canControl, true);
EXPECT_EQ(properties.isEnergyThresholdSupported, false);
EXPECT_EQ(properties.defaultLimit, -1);
EXPECT_EQ(properties.maxLimit, -1);
EXPECT_EQ(properties.minLimit, -1);
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerPropertiesThenHwmonInterfaceExistAndMinLimitIsUnknown) {
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pSysmanDeviceImp->pPowerHandleContext->init(deviceHandles, device->toHandle());
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerPropertiesThenUnknownLimitsAreReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
zes_power_properties_t properties;
zes_power_properties_t properties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
EXPECT_FALSE(properties.onSubdevice);
EXPECT_EQ(properties.subdeviceId, 0u);
EXPECT_EQ(properties.defaultLimit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
EXPECT_EQ(properties.defaultLimit, -1);
EXPECT_EQ(properties.maxLimit, -1);
EXPECT_EQ(properties.minLimit, -1);
}
@ -226,6 +233,21 @@ TEST_F(SysmanDevicePowerFixture, GivenSetPowerLimitsWhenGettingPowerLimitsWhenHw
}
}
TEST_F(SysmanDevicePowerFixture, GivenDefaultLimitSysfsNodesNotAvailableWhenGettingPowerPropertiesAndExtPropertiesThenApiCallReturnsFailure) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
zes_power_properties_t properties = {};
zes_power_ext_properties_t extProperties = {};
zes_power_limit_ext_desc_t defaultLimit = {};
extProperties.defaultLimit = &defaultLimit;
extProperties.stype = ZES_STRUCTURE_TYPE_POWER_EXT_PROPERTIES;
properties.pNext = &extProperties;
pSysfsAccess->mockReadResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetProperties(handle, &properties));
}
}
HWTEST2_F(SysmanDevicePowerFixture, GivenValidPowerHandlesWhenCallingSetAndGetPowerLimitExtThenLimitsSetEarlierAreRetrieved, IsPVC) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
@ -671,7 +693,7 @@ TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerProperties
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
zes_power_properties_t properties;
zes_power_properties_t properties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
EXPECT_FALSE(properties.onSubdevice);
EXPECT_EQ(properties.subdeviceId, 0u);