IntenseWebs/openvino
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update cpu properties name to enable_hyper_threading and enable_hyper_threading (#16723)

Browse Source
This commit is contained in:
Shen, Wanglei 2023-04-04 19:25:11 +08:00 committed by GitHub
parent 8691ec2779
commit 9f54504232
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 71 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/bindings/c/include/openvino/c/ov_property.h
View File

@ -125,14 +125,14 @@ ov_property_key_inference_num_threads;
* @ingroup ov_property_c_api * @ingroup ov_property_c_api
*/ */
OPENVINO_C_VAR(const char*) OPENVINO_C_VAR(const char*)
ov_property_key_hint_use_cpu_pinning; ov_property_key_hint_enable_cpu_pinning;
/** /**
* @brief Read-write property, it is high-level OpenVINO hint for using hyper threading processors during CPU inference * @brief Read-write property, it is high-level OpenVINO hint for using hyper threading processors during CPU inference
* @ingroup ov_property_c_api * @ingroup ov_property_c_api
*/ */
OPENVINO_C_VAR(const char*) OPENVINO_C_VAR(const char*)
ov_property_key_hint_use_hyper_threading; ov_property_key_hint_enable_hyper_threading;
/** /**
* @brief Read-write property, it is high-level OpenVINO Performance Hints * @brief Read-write property, it is high-level OpenVINO Performance Hints

4
src/bindings/c/src/ov_property.cpp
View File

@ -23,9 +23,9 @@ const char* ov_property_key_num_streams = "NUM_STREAMS";
const char* ov_property_key_affinity = "AFFINITY"; const char* ov_property_key_affinity = "AFFINITY";
const char* ov_property_key_inference_num_threads = "INFERENCE_NUM_THREADS"; const char* ov_property_key_inference_num_threads = "INFERENCE_NUM_THREADS";
const char* ov_property_key_hint_performance_mode = "PERFORMANCE_HINT"; const char* ov_property_key_hint_performance_mode = "PERFORMANCE_HINT";
const char* ov_property_key_hint_use_cpu_pinning = "USE_CPU_PINNING"; const char* ov_property_key_hint_enable_cpu_pinning = "ENABLE_CPU_PINNING";
const char* ov_property_key_hint_scheduling_core_type = "SCHEDULING_CORE_TYPE"; const char* ov_property_key_hint_scheduling_core_type = "SCHEDULING_CORE_TYPE";
const char* ov_property_key_hint_use_hyper_threading = "USE_HYPER_THREADING"; const char* ov_property_key_hint_enable_hyper_threading = "ENABLE_HYPER_THREADING";
const char* ov_property_key_hint_inference_precision = "INFERENCE_PRECISION_HINT"; const char* ov_property_key_hint_inference_precision = "INFERENCE_PRECISION_HINT";
const char* ov_property_key_hint_num_requests = "PERFORMANCE_HINT_NUM_REQUESTS"; const char* ov_property_key_hint_num_requests = "PERFORMANCE_HINT_NUM_REQUESTS";
const char* ov_property_key_hint_model_priority = "MODEL_PRIORITY"; const char* ov_property_key_hint_model_priority = "MODEL_PRIORITY";

8
src/bindings/c/tests/ov_core_test.cpp
View File

@ -260,7 +260,7 @@ TEST_P(ov_core_test, ov_core_set_property_enum_invalid) {
EXPECT_STRNE(invalid_mode, ret); EXPECT_STRNE(invalid_mode, ret);
ov_free(ret); ov_free(ret);
const char* key_pin = ov_property_key_hint_use_cpu_pinning; const char* key_pin = ov_property_key_hint_enable_cpu_pinning;
const char* val_pin = "YES"; const char* val_pin = "YES";
OV_EXPECT_OK(ov_core_set_property(core, device_name.c_str(), key_pin, val_pin)); OV_EXPECT_OK(ov_core_set_property(core, device_name.c_str(), key_pin, val_pin));
ret = nullptr; ret = nullptr;
@ -289,7 +289,7 @@ TEST_P(ov_core_test, ov_core_set_property_enum_invalid) {
EXPECT_STRNE(invalid_val, ret); EXPECT_STRNE(invalid_val, ret);
ov_free(ret); ov_free(ret);
const char* key_ht = ov_property_key_hint_use_hyper_threading; const char* key_ht = ov_property_key_hint_enable_hyper_threading;
const char* val_ht = "YES"; const char* val_ht = "YES";
OV_EXPECT_OK(ov_core_set_property(core, device_name.c_str(), key_ht, val_ht)); OV_EXPECT_OK(ov_core_set_property(core, device_name.c_str(), key_ht, val_ht));
ret = nullptr; ret = nullptr;
@ -320,7 +320,7 @@ TEST_P(ov_core_test, ov_core_set_and_get_property_enum) {
EXPECT_STREQ(affinity, ret); EXPECT_STREQ(affinity, ret);
ov_free(ret); ov_free(ret);
const char* key_pin = ov_property_key_hint_use_cpu_pinning; const char* key_pin = ov_property_key_hint_enable_cpu_pinning;
const char* val_pin = "YES"; const char* val_pin = "YES";
OV_EXPECT_OK(ov_core_set_property(core, device_name.c_str(), key_pin, val_pin)); OV_EXPECT_OK(ov_core_set_property(core, device_name.c_str(), key_pin, val_pin));
ret = nullptr; ret = nullptr;
@ -336,7 +336,7 @@ TEST_P(ov_core_test, ov_core_set_and_get_property_enum) {
EXPECT_STREQ(val_type, ret); EXPECT_STREQ(val_type, ret);
ov_free(ret); ov_free(ret);
const char* key_ht = ov_property_key_hint_use_hyper_threading; const char* key_ht = ov_property_key_hint_enable_hyper_threading;
const char* val_ht = "YES"; const char* val_ht = "YES";
OV_EXPECT_OK(ov_core_set_property(core, device_name.c_str(), key_ht, val_ht)); OV_EXPECT_OK(ov_core_set_property(core, device_name.c_str(), key_ht, val_ht));
ret = nullptr; ret = nullptr;

4
src/bindings/python/src/pyopenvino/core/properties/properties.cpp
View File

@ -72,9 +72,9 @@ void regmodule_properties(py::module m) {
wrap_property_RW(m_hint, ov::hint::inference_precision, "inference_precision"); wrap_property_RW(m_hint, ov::hint::inference_precision, "inference_precision");
wrap_property_RW(m_hint, ov::hint::model_priority, "model_priority"); wrap_property_RW(m_hint, ov::hint::model_priority, "model_priority");
wrap_property_RW(m_hint, ov::hint::performance_mode, "performance_mode"); wrap_property_RW(m_hint, ov::hint::performance_mode, "performance_mode");
wrap_property_RW(m_hint, ov::hint::use_cpu_pinning, "use_cpu_pinning"); wrap_property_RW(m_hint, ov::hint::enable_cpu_pinning, "enable_cpu_pinning");
wrap_property_RW(m_hint, ov::hint::scheduling_core_type, "scheduling_core_type"); wrap_property_RW(m_hint, ov::hint::scheduling_core_type, "scheduling_core_type");
wrap_property_RW(m_hint, ov::hint::use_hyper_threading, "use_hyper_threading"); wrap_property_RW(m_hint, ov::hint::enable_hyper_threading, "enable_hyper_threading");
wrap_property_RW(m_hint, ov::hint::execution_mode, "execution_mode"); wrap_property_RW(m_hint, ov::hint::execution_mode, "execution_mode");
wrap_property_RW(m_hint, ov::hint::num_requests, "num_requests"); wrap_property_RW(m_hint, ov::hint::num_requests, "num_requests");
wrap_property_RW(m_hint, ov::hint::model, "model"); wrap_property_RW(m_hint, ov::hint::model, "model");

16
src/bindings/python/tests/test_runtime/test_properties.py
View File

@ -226,8 +226,8 @@ def test_properties_ro(ov_property_ro, expected_value):
((properties.hint.PerformanceMode.UNDEFINED, properties.hint.PerformanceMode.UNDEFINED),), ((properties.hint.PerformanceMode.UNDEFINED, properties.hint.PerformanceMode.UNDEFINED),),
), ),
( (
properties.hint.use_cpu_pinning, properties.hint.enable_cpu_pinning,
"USE_CPU_PINNING", "ENABLE_CPU_PINNING",
( (
(True, True), (True, True),
(False, False), (False, False),
@ -241,8 +241,8 @@ def test_properties_ro(ov_property_ro, expected_value):
((properties.hint.SchedulingCoreType.PCORE_ONLY, properties.hint.SchedulingCoreType.PCORE_ONLY),), ((properties.hint.SchedulingCoreType.PCORE_ONLY, properties.hint.SchedulingCoreType.PCORE_ONLY),),
), ),
( (
properties.hint.use_hyper_threading, properties.hint.enable_hyper_threading,
"USE_HYPER_THREADING", "ENABLE_HYPER_THREADING",
( (
(True, True), (True, True),
(False, False), (False, False),
@ -460,9 +460,9 @@ def test_single_property_setting(device):
properties.affinity(properties.Affinity.NONE), properties.affinity(properties.Affinity.NONE),
properties.hint.inference_precision(Type.f32), properties.hint.inference_precision(Type.f32),
properties.hint.performance_mode(properties.hint.PerformanceMode.LATENCY), properties.hint.performance_mode(properties.hint.PerformanceMode.LATENCY),
properties.hint.use_cpu_pinning(True), properties.hint.enable_cpu_pinning(True),
properties.hint.scheduling_core_type(properties.hint.SchedulingCoreType.PCORE_ONLY), properties.hint.scheduling_core_type(properties.hint.SchedulingCoreType.PCORE_ONLY),
properties.hint.use_hyper_threading(True), properties.hint.enable_hyper_threading(True),
properties.hint.num_requests(12), properties.hint.num_requests(12),
properties.streams.num(5), properties.streams.num(5),
], ],
@ -475,9 +475,9 @@ def test_single_property_setting(device):
properties.affinity(): properties.Affinity.NONE, properties.affinity(): properties.Affinity.NONE,
properties.hint.inference_precision(): Type.f32, properties.hint.inference_precision(): Type.f32,
properties.hint.performance_mode(): properties.hint.PerformanceMode.LATENCY, properties.hint.performance_mode(): properties.hint.PerformanceMode.LATENCY,
properties.hint.use_cpu_pinning(): True, properties.hint.enable_cpu_pinning(): True,
properties.hint.scheduling_core_type(): properties.hint.SchedulingCoreType.PCORE_ONLY, properties.hint.scheduling_core_type(): properties.hint.SchedulingCoreType.PCORE_ONLY,
properties.hint.use_hyper_threading(): True, properties.hint.enable_hyper_threading(): True,
properties.hint.num_requests(): 12, properties.hint.num_requests(): 12,
properties.streams.num(): 5, properties.streams.num(): 5,
}, },

2
src/inference/dev_api/openvino/runtime/threading/cpu_map_scheduling.hpp
View File

@ -26,7 +26,7 @@ std::vector<std::vector<int>> apply_scheduling_core_type(const ov::hint::Schedul
/** /**
* @brief Limit available CPU resource in processors type table according to hyper threading property * @brief Limit available CPU resource in processors type table according to hyper threading property
* @param[in] input_type indicate value of property use_hyper_threading. * @param[in] input_type indicate value of property enable_hyper_threading.
* @param[in] input_changed indicate if value is set by user. * @param[in] input_changed indicate if value is set by user.
* @param[in] proc_type_table candidate processors available at this time * @param[in] proc_type_table candidate processors available at this time
* @return updated proc_type_table which removed unmatched processors * @return updated proc_type_table which removed unmatched processors

12
src/inference/include/openvino/runtime/properties.hpp
View File

@ -418,11 +418,11 @@ static constexpr Property<SchedulingCoreType> scheduling_core_type{"SCHEDULING_C
* The following code is example to use this property. * The following code is example to use this property.
* *
* @code * @code
* ie.set_property(ov::hint::use_cpu_pinning(true)); * ie.set_property(ov::hint::enable_cpu_pinning(true));
* ie.set_property(ov::hint::use_cpu_pinning(false)); * ie.set_property(ov::hint::enable_cpu_pinning(false));
* @endcode * @endcode
*/ */
static constexpr Property<bool> use_cpu_pinning{"USE_CPU_PINNING"}; static constexpr Property<bool> enable_cpu_pinning{"ENABLE_CPU_PINNING"};
/** /**
* @brief This property define if using hyper threading during inference. * @brief This property define if using hyper threading during inference.
@ -434,11 +434,11 @@ static constexpr Property<bool> use_cpu_pinning{"USE_CPU_PINNING"};
* The following code is example to use this property. * The following code is example to use this property.
* *
* @code * @code
* ie.set_property(ov::hint::use_hyper_threading(true)); * ie.set_property(ov::hint::enable_hyper_threading(true));
* ie.set_property(ov::hint::use_hyper_threading(false)); * ie.set_property(ov::hint::enable_hyper_threading(false));
* @endcode * @endcode
*/ */
static constexpr Property<bool> use_hyper_threading{"USE_HYPER_THREADING"}; static constexpr Property<bool> enable_hyper_threading{"ENABLE_HYPER_THREADING"};
/** /**
* @brief (Optional) property that backs the (above) Performance Hints * @brief (Optional) property that backs the (above) Performance Hints

16
src/plugins/intel_cpu/src/config.cpp
View File

@ -79,15 +79,15 @@ void Config::readProperties(const std::map<std::string, std::string> &prop) {
streamExecutorConfig.SetConfig(key, val); streamExecutorConfig.SetConfig(key, val);
} else if (hintsConfigKeys.end() != std::find(hintsConfigKeys.begin(), hintsConfigKeys.end(), key)) { } else if (hintsConfigKeys.end() != std::find(hintsConfigKeys.begin(), hintsConfigKeys.end(), key)) {
perfHintsConfig.SetConfig(key, val); perfHintsConfig.SetConfig(key, val);
} else if (key == ov::hint::use_cpu_pinning.name()) { } else if (key == ov::hint::enable_cpu_pinning.name()) {
if (val == PluginConfigParams::YES) { if (val == PluginConfigParams::YES) {
useCpuPinning = true; enableCpuPinning = true;
changedCpuPinning = true; changedCpuPinning = true;
} else if (val == PluginConfigParams::NO) { } else if (val == PluginConfigParams::NO) {
useCpuPinning = false; enableCpuPinning = false;
changedCpuPinning = true; changedCpuPinning = true;
} else { } else {
IE_THROW() << "Wrong value " << val << "for property key " << ov::hint::use_cpu_pinning.name() IE_THROW() << "Wrong value " << val << "for property key " << ov::hint::enable_cpu_pinning.name()
<< ". Expected only true/false." << std::endl; << ". Expected only true/false." << std::endl;
} }
} else if (key == ov::hint::scheduling_core_type.name()) { } else if (key == ov::hint::scheduling_core_type.name()) {
@ -102,15 +102,15 @@ void Config::readProperties(const std::map<std::string, std::string> &prop) {
<< ov::hint::SchedulingCoreType::PCORE_ONLY << "/" << ov::hint::SchedulingCoreType::PCORE_ONLY << "/"
<< ov::hint::SchedulingCoreType::ECORE_ONLY << std::endl; << ov::hint::SchedulingCoreType::ECORE_ONLY << std::endl;
} }
} else if (key == ov::hint::use_hyper_threading.name()) { } else if (key == ov::hint::enable_hyper_threading.name()) {
if (val == PluginConfigParams::YES) { if (val == PluginConfigParams::YES) {
useHyperThreading = true; enableHyperThreading = true;
changedHyperThreading = true; changedHyperThreading = true;
} else if (val == PluginConfigParams::NO) { } else if (val == PluginConfigParams::NO) {
useHyperThreading = false; enableHyperThreading = false;
changedHyperThreading = true; changedHyperThreading = true;
} else { } else {
IE_THROW() << "Wrong value " << val << "for property key " << ov::hint::use_hyper_threading.name() IE_THROW() << "Wrong value " << val << "for property key " << ov::hint::enable_hyper_threading.name()
<< ". Expected only true/false." << std::endl; << ". Expected only true/false." << std::endl;
} }
} else if (key == PluginConfigParams::KEY_DYN_BATCH_LIMIT) { } else if (key == PluginConfigParams::KEY_DYN_BATCH_LIMIT) {

4
src/plugins/intel_cpu/src/config.h
View File

@ -51,10 +51,10 @@ struct Config {
size_t rtCacheCapacity = 5000ul; size_t rtCacheCapacity = 5000ul;
InferenceEngine::IStreamsExecutor::Config streamExecutorConfig; InferenceEngine::IStreamsExecutor::Config streamExecutorConfig;
InferenceEngine::PerfHintsConfig perfHintsConfig; InferenceEngine::PerfHintsConfig perfHintsConfig;
bool useCpuPinning = true; bool enableCpuPinning = true;
bool changedCpuPinning = false; bool changedCpuPinning = false;
ov::hint::SchedulingCoreType schedulingCoreType = ov::hint::SchedulingCoreType::ANY_CORE; ov::hint::SchedulingCoreType schedulingCoreType = ov::hint::SchedulingCoreType::ANY_CORE;
bool useHyperThreading = true; bool enableHyperThreading = true;
bool changedHyperThreading = false; bool changedHyperThreading = false;
#if defined(OPENVINO_ARCH_X86) || defined(OPENVINO_ARCH_X86_64) #if defined(OPENVINO_ARCH_X86) || defined(OPENVINO_ARCH_X86_64)
LPTransformsMode lpTransformsMode = LPTransformsMode::On; LPTransformsMode lpTransformsMode = LPTransformsMode::On;

16
src/plugins/intel_cpu/src/exec_network.cpp
View File

@ -313,9 +313,9 @@ InferenceEngine::Parameter ExecNetwork::GetMetric(const std::string &name) const
RO_property(ov::hint::performance_mode.name()), RO_property(ov::hint::performance_mode.name()),
RO_property(ov::hint::execution_mode.name()), RO_property(ov::hint::execution_mode.name()),
RO_property(ov::hint::num_requests.name()), RO_property(ov::hint::num_requests.name()),
RO_property(ov::hint::use_cpu_pinning.name()), RO_property(ov::hint::enable_cpu_pinning.name()),
RO_property(ov::hint::scheduling_core_type.name()), RO_property(ov::hint::scheduling_core_type.name()),
RO_property(ov::hint::use_hyper_threading.name()), RO_property(ov::hint::enable_hyper_threading.name()),
RO_property(ov::execution_devices.name()), RO_property(ov::execution_devices.name()),
}; };
} }
@ -356,15 +356,15 @@ InferenceEngine::Parameter ExecNetwork::GetMetric(const std::string &name) const
} else if (name == ov::hint::performance_mode) { } else if (name == ov::hint::performance_mode) {
const auto perfHint = ov::util::from_string(config.perfHintsConfig.ovPerfHint, ov::hint::performance_mode); const auto perfHint = ov::util::from_string(config.perfHintsConfig.ovPerfHint, ov::hint::performance_mode);
return perfHint; return perfHint;
} else if (name == ov::hint::use_cpu_pinning.name()) { } else if (name == ov::hint::enable_cpu_pinning.name()) {
const bool use_pin = config.useCpuPinning; const bool use_pin = config.enableCpuPinning;
return decltype(ov::hint::use_cpu_pinning)::value_type(use_pin); return decltype(ov::hint::enable_cpu_pinning)::value_type(use_pin);
} else if (name == ov::hint::scheduling_core_type) { } else if (name == ov::hint::scheduling_core_type) {
const auto core_type = config.schedulingCoreType; const auto core_type = config.schedulingCoreType;
return core_type; return core_type;
} else if (name == ov::hint::use_hyper_threading.name()) { } else if (name == ov::hint::enable_hyper_threading.name()) {
const bool use_ht = config.useHyperThreading; const bool use_ht = config.enableHyperThreading;
return decltype(ov::hint::use_hyper_threading)::value_type(use_ht); return decltype(ov::hint::enable_hyper_threading)::value_type(use_ht);
} else if (name == ov::hint::execution_mode) { } else if (name == ov::hint::execution_mode) {
return config.executionMode; return config.executionMode;
} else if (name == ov::hint::num_requests) { } else if (name == ov::hint::num_requests) {

16
src/plugins/intel_cpu/src/plugin.cpp
View File

@ -596,15 +596,15 @@ Parameter Engine::GetConfig(const std::string& name, const std::map<std::string,
} else if (name == ov::hint::performance_mode) { } else if (name == ov::hint::performance_mode) {
const auto perfHint = ov::util::from_string(engConfig.perfHintsConfig.ovPerfHint, ov::hint::performance_mode); const auto perfHint = ov::util::from_string(engConfig.perfHintsConfig.ovPerfHint, ov::hint::performance_mode);
return perfHint; return perfHint;
} else if (name == ov::hint::use_cpu_pinning) { } else if (name == ov::hint::enable_cpu_pinning) {
const bool pin_value = engConfig.useCpuPinning; const bool pin_value = engConfig.enableCpuPinning;
return decltype(ov::hint::use_cpu_pinning)::value_type(pin_value); return decltype(ov::hint::enable_cpu_pinning)::value_type(pin_value);
} else if (name == ov::hint::scheduling_core_type) { } else if (name == ov::hint::scheduling_core_type) {
const auto core_type = engConfig.schedulingCoreType; const auto core_type = engConfig.schedulingCoreType;
return core_type; return core_type;
} else if (name == ov::hint::use_hyper_threading) { } else if (name == ov::hint::enable_hyper_threading) {
const bool ht_value = engConfig.useHyperThreading; const bool ht_value = engConfig.enableHyperThreading;
return decltype(ov::hint::use_hyper_threading)::value_type(ht_value); return decltype(ov::hint::enable_hyper_threading)::value_type(ht_value);
} else if (name == ov::hint::num_requests) { } else if (name == ov::hint::num_requests) {
const auto perfHintNumRequests = engConfig.perfHintsConfig.ovPerfHintNumRequests; const auto perfHintNumRequests = engConfig.perfHintsConfig.ovPerfHintNumRequests;
return decltype(ov::hint::num_requests)::value_type(perfHintNumRequests); return decltype(ov::hint::num_requests)::value_type(perfHintNumRequests);
@ -696,9 +696,9 @@ Parameter Engine::GetMetric(const std::string& name, const std::map<std::string,
RW_property(ov::hint::performance_mode.name()), RW_property(ov::hint::performance_mode.name()),
RW_property(ov::hint::execution_mode.name()), RW_property(ov::hint::execution_mode.name()),
RW_property(ov::hint::num_requests.name()), RW_property(ov::hint::num_requests.name()),
RW_property(ov::hint::use_cpu_pinning.name()), RW_property(ov::hint::enable_cpu_pinning.name()),
RW_property(ov::hint::scheduling_core_type.name()), RW_property(ov::hint::scheduling_core_type.name()),
RW_property(ov::hint::use_hyper_threading.name()), RW_property(ov::hint::enable_hyper_threading.name()),
RW_property(ov::device::id.name()), RW_property(ov::device::id.name()),
}; };

4
src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_plugin/core_integration.cpp
View File

@ -49,7 +49,7 @@ INSTANTIATE_TEST_SUITE_P(
::testing::Values("CPU", "MULTI", "HETERO", "AUTO")); ::testing::Values("CPU", "MULTI", "HETERO", "AUTO"));
INSTANTIATE_TEST_SUITE_P(smoke_OVClassSetConfigTest, INSTANTIATE_TEST_SUITE_P(smoke_OVClassSetConfigTest,
OVClassSetUseHyperThreadingHintConfigTest, OVClassSetEnableHyperThreadingHintConfigTest,
::testing::Values("CPU")); ::testing::Values("CPU"));
INSTANTIATE_TEST_SUITE_P(smoke_OVClassSetConfigTest, INSTANTIATE_TEST_SUITE_P(smoke_OVClassSetConfigTest,
@ -80,7 +80,7 @@ INSTANTIATE_TEST_SUITE_P(
smoke_OVClassGetAvailableDevices, OVClassGetAvailableDevices, smoke_OVClassGetAvailableDevices, OVClassGetAvailableDevices,
::testing::Values("CPU")); ::testing::Values("CPU"));
INSTANTIATE_TEST_SUITE_P(smoke_OVClassSetConfigTest, OVClassSetUseCpuPinningHintConfigTest, ::testing::Values("CPU")); INSTANTIATE_TEST_SUITE_P(smoke_OVClassSetConfigTest, OVClassSetEnableCpuPinningHintConfigTest, ::testing::Values("CPU"));
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_SUITE_P(
smoke_OVClassSetModelPriorityConfigTest, OVClassSetModelPriorityConfigTest, smoke_OVClassSetModelPriorityConfigTest, OVClassSetModelPriorityConfigTest,

36
src/tests/functional/plugin/shared/include/behavior/ov_plugin/core_integration.hpp
View File

@ -121,9 +121,9 @@ using OVClassLoadNetworkTest = OVClassQueryNetworkTest;
using OVClassSetGlobalConfigTest = OVClassBaseTestP; using OVClassSetGlobalConfigTest = OVClassBaseTestP;
using OVClassSetModelPriorityConfigTest = OVClassBaseTestP; using OVClassSetModelPriorityConfigTest = OVClassBaseTestP;
using OVClassSetExecutionModeHintConfigTest = OVClassBaseTestP; using OVClassSetExecutionModeHintConfigTest = OVClassBaseTestP;
using OVClassSetUseCpuPinningHintConfigTest = OVClassBaseTestP; using OVClassSetEnableCpuPinningHintConfigTest = OVClassBaseTestP;
using OVClassSetSchedulingCoreTypeHintConfigTest = OVClassBaseTestP; using OVClassSetSchedulingCoreTypeHintConfigTest = OVClassBaseTestP;
using OVClassSetUseHyperThreadingHintConfigTest = OVClassBaseTestP; using OVClassSetEnableHyperThreadingHintConfigTest = OVClassBaseTestP;
using OVClassSetTBBForceTerminatePropertyTest = OVClassBaseTestP; using OVClassSetTBBForceTerminatePropertyTest = OVClassBaseTestP;
using OVClassSetLogLevelConfigTest = OVClassBaseTestP; using OVClassSetLogLevelConfigTest = OVClassBaseTestP;
using OVClassSpecificDeviceTestSetConfig = OVClassBaseTestP; using OVClassSpecificDeviceTestSetConfig = OVClassBaseTestP;
@ -612,21 +612,21 @@ TEST_P(OVClassSetExecutionModeHintConfigTest, SetConfigNoThrow) {
ASSERT_EQ(ov::hint::ExecutionMode::PERFORMANCE, ie.get_property(target_device, ov::hint::execution_mode)); ASSERT_EQ(ov::hint::ExecutionMode::PERFORMANCE, ie.get_property(target_device, ov::hint::execution_mode));
} }
TEST_P(OVClassSetUseCpuPinningHintConfigTest, SetConfigNoThrow) { TEST_P(OVClassSetEnableCpuPinningHintConfigTest, SetConfigNoThrow) {
ov::Core ie = createCoreWithTemplate(); ov::Core ie = createCoreWithTemplate();
OV_ASSERT_PROPERTY_SUPPORTED(ov::hint::use_cpu_pinning); OV_ASSERT_PROPERTY_SUPPORTED(ov::hint::enable_cpu_pinning);
bool defaultMode{}; bool defaultMode{};
ASSERT_NO_THROW(defaultMode = ie.get_property(target_device, ov::hint::use_cpu_pinning)); ASSERT_NO_THROW(defaultMode = ie.get_property(target_device, ov::hint::enable_cpu_pinning));
(void)defaultMode; (void)defaultMode;
ASSERT_EQ(true, ie.get_property(target_device, ov::hint::use_cpu_pinning)); ASSERT_EQ(true, ie.get_property(target_device, ov::hint::enable_cpu_pinning));
ie.set_property(target_device, ov::hint::use_cpu_pinning(false)); ie.set_property(target_device, ov::hint::enable_cpu_pinning(false));
ASSERT_EQ(false, ie.get_property(target_device, ov::hint::use_cpu_pinning)); ASSERT_EQ(false, ie.get_property(target_device, ov::hint::enable_cpu_pinning));
ie.set_property(target_device, ov::hint::use_cpu_pinning(true)); ie.set_property(target_device, ov::hint::enable_cpu_pinning(true));
ASSERT_EQ(true, ie.get_property(target_device, ov::hint::use_cpu_pinning)); ASSERT_EQ(true, ie.get_property(target_device, ov::hint::enable_cpu_pinning));
} }
TEST_P(OVClassSetSchedulingCoreTypeHintConfigTest, SetConfigNoThrow) { TEST_P(OVClassSetSchedulingCoreTypeHintConfigTest, SetConfigNoThrow) {
@ -648,21 +648,21 @@ TEST_P(OVClassSetSchedulingCoreTypeHintConfigTest, SetConfigNoThrow) {
ASSERT_EQ(ov::hint::SchedulingCoreType::ANY_CORE, ie.get_property(target_device, ov::hint::scheduling_core_type)); ASSERT_EQ(ov::hint::SchedulingCoreType::ANY_CORE, ie.get_property(target_device, ov::hint::scheduling_core_type));
} }
TEST_P(OVClassSetUseHyperThreadingHintConfigTest, SetConfigNoThrow) { TEST_P(OVClassSetEnableHyperThreadingHintConfigTest, SetConfigNoThrow) {
ov::Core ie = createCoreWithTemplate(); ov::Core ie = createCoreWithTemplate();
OV_ASSERT_PROPERTY_SUPPORTED(ov::hint::use_hyper_threading); OV_ASSERT_PROPERTY_SUPPORTED(ov::hint::enable_hyper_threading);
bool defaultMode{}; bool defaultMode{};
ASSERT_NO_THROW(defaultMode = ie.get_property(target_device, ov::hint::use_hyper_threading)); ASSERT_NO_THROW(defaultMode = ie.get_property(target_device, ov::hint::enable_hyper_threading));
(void)defaultMode; (void)defaultMode;
ASSERT_EQ(true, ie.get_property(target_device, ov::hint::use_hyper_threading)); ASSERT_EQ(true, ie.get_property(target_device, ov::hint::enable_hyper_threading));
ie.set_property(target_device, ov::hint::use_hyper_threading(false)); ie.set_property(target_device, ov::hint::enable_hyper_threading(false));
ASSERT_EQ(false, ie.get_property(target_device, ov::hint::use_hyper_threading)); ASSERT_EQ(false, ie.get_property(target_device, ov::hint::enable_hyper_threading));
ie.set_property(target_device, ov::hint::use_hyper_threading(true)); ie.set_property(target_device, ov::hint::enable_hyper_threading(true));
ASSERT_EQ(true, ie.get_property(target_device, ov::hint::use_hyper_threading)); ASSERT_EQ(true, ie.get_property(target_device, ov::hint::enable_hyper_threading));
} }
TEST_P(OVClassSetDevicePriorityConfigTest, SetConfigAndCheckGetConfigNoThrow) { TEST_P(OVClassSetDevicePriorityConfigTest, SetConfigAndCheckGetConfigNoThrow) {