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

move batch test cases from gpu/cpu/template plugin to auto batch plugin

Browse Source
This commit is contained in:
River,Li
2023-01-12 22:06:10 +08:00
parent 086a0d8ef7
commit 9f4f2ce1af
38 changed files with 582 additions and 309 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
src/plugins/auto_batch/tests/functional/CMakeLists.txt
View File

@@ -4,6 +4,26 @@
set(TARGET_NAME ov_auto_batch_func_tests)
if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
ie_add_compiler_flags(/wd4244)
ie_add_compiler_flags(/wd4267)
ie_add_compiler_flags(/wd4305)
ie_add_compiler_flags(/wd4018)
ie_add_compiler_flags(/wd4050)
ie_add_compiler_flags(/wd4250)
ie_add_compiler_flags(/wd4334)
ie_add_compiler_flags(/wd4661)
ie_add_compiler_flags(/wd4273)
ie_add_compiler_flags(/wd4309)
ie_add_compiler_flags(/wd4804)
endif()
if(NOT MSVC)
ie_add_compiler_flags(-Wno-missing-declarations)
ie_add_compiler_flags(-Wno-sign-compare)
ie_add_compiler_flags(-Wno-odr)
ie_add_compiler_flags(-Wno-all)
endif()
set(SHARED_HEADERS_DIR "${OpenVINO_SOURCE_DIR}/src/tests/functional/plugin/shared/include")
addIeTargetTest(
NAME
@@ -22,6 +42,10 @@ addIeTargetTest(
Auto_Batch
)
if (ENABLE_INTEL_GPU)
target_compile_definitions(${TARGET_NAME} PRIVATE HAVE_GPU_PLUGIN)
target_compile_definitions(${TARGET_NAME} PRIVATE HAVE_INTEL_GPU_PLUGIN)
endif()
if (ENABLE_TEMPLATE)
target_compile_definitions(${TARGET_NAME} PRIVATE HAVE_TEMPLATE_PLUGIN)
endif()
set_ie_threading_interface_for(${TARGET_NAME})

28
src/plugins/auto_batch/tests/functional/behavior/executable_network/exec_net_base.cpp Normal file
View File

@@ -0,0 +1,28 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/executable_network/exec_network_base.hpp"
using namespace BehaviorTestsDefinitions;
namespace {
const std::vector<InferenceEngine::Precision> netPrecisions = {InferenceEngine::Precision::FP32,
InferenceEngine::Precision::FP16};
auto autoBatchConfig = []() {
return std::vector<std::map<std::string, std::string>>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
#ifdef HAVE_INTEL_GPU_PLUGIN
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests,
ExecNetSetPrecision,
::testing::Combine(::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(autoBatchConfig())),
ExecNetSetPrecision::getTestCaseName);
#endif
} // namespace

24
src/plugins/auto_batch/tests/functional/behavior/infer_request/callback.cpp Normal file
View File

@@ -0,0 +1,24 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/infer_request/callback.hpp"
using namespace BehaviorTestsDefinitions;
namespace {
auto autoBatchConfigs = []() {
return std::vector<std::map<std::string, std::string>>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
#ifdef HAVE_INTEL_GPU_PLUGIN
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests,
InferRequestCallbackTests,
::testing::Combine(::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(autoBatchConfigs())),
InferRequestCallbackTests::getTestCaseName);
#endif
} // namespace

28
src/plugins/auto_batch/tests/functional/behavior/infer_request/multithreading.cpp Normal file
View File

@@ -0,0 +1,28 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/infer_request/multithreading.hpp"
#include <vector>
#include "ie_plugin_config.hpp"
using namespace BehaviorTestsDefinitions;
namespace {
auto auto_batch_configs = []() {
return std::vector<std::map<std::string, std::string>>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
#ifdef HAVE_INTEL_GPU_PLUGIN
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests,
InferRequestMultithreadingTests,
::testing::Combine(::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(auto_batch_configs())),
InferRequestMultithreadingTests::getTestCaseName);
#endif
} // namespace

24
src/plugins/auto_batch/tests/functional/behavior/infer_request/perf_counters.cpp Normal file
View File

@@ -0,0 +1,24 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/infer_request/perf_counters.hpp"
using namespace BehaviorTestsDefinitions;
namespace {
auto AutoBatchConfigs = []() {
return std::vector<std::map<std::string, std::string>>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
#ifdef HAVE_INTEL_GPU_PLUGIN
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests,
InferRequestPerfCountersTest,
::testing::Combine(::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(AutoBatchConfigs())),
InferRequestPerfCountersTest::getTestCaseName);
#endif
} // namespace

28
src/plugins/auto_batch/tests/functional/behavior/infer_request/wait.cpp Normal file
View File

@@ -0,0 +1,28 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/infer_request/wait.hpp"
#include <vector>
#include "ie_plugin_config.hpp"
using namespace BehaviorTestsDefinitions;
namespace {
auto autoBatchConfigs = []() {
return std::vector<std::map<std::string, std::string>>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
#ifdef HAVE_INTEL_GPU_PLUGIN
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests,
InferRequestWaitTests,
::testing::Combine(::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(autoBatchConfigs())),
InferRequestWaitTests::getTestCaseName);
#endif
} // namespace

24
src/plugins/auto_batch/tests/functional/behavior/ov_executable_network/exec_net_base.cpp Normal file
View File

@@ -0,0 +1,24 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/ov_executable_network/exec_network_base.hpp"
using namespace ov::test::behavior;
namespace {
auto autoBatchConfigs = []() {
return std::vector<ov::AnyMap>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
#ifdef HAVE_INTEL_GPU_PLUGIN
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatchBehaviorTests, OVExecutableNetworkBaseTest,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(autoBatchConfigs())),
OVExecutableNetworkBaseTest::getTestCaseName);
#endif
} // namespace

52
src/plugins/auto_batch/tests/functional/behavior/ov_executable_network/properties.cpp Normal file
View File

@@ -0,0 +1,52 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/ov_executable_network/properties.hpp"
#include "ie_system_conf.h"
#include "openvino/runtime/properties.hpp"
using namespace ov::test::behavior;
namespace {
const std::vector<ov::AnyMap> auto_batch_inproperties = {
{ov::num_streams(-100)},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_CPU) + "(4)"},
{ov::auto_batch_timeout(-1)}},
#ifdef HAVE_TEMPLATE_PLUGIN
{ov::device::id("UNSUPPORTED_DEVICE_ID_STRING")},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_TEMPLATE) + "(4)"},
{ov::auto_batch_timeout(-1)}},
#endif
};
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests,
OVCompiledModelPropertiesIncorrectTests,
::testing::Combine(::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(auto_batch_inproperties)),
OVCompiledModelPropertiesIncorrectTests::getTestCaseName);
const std::vector<ov::AnyMap> auto_batch_properties = {
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_CPU) + "(4)"}},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_CPU) + "(4)"},
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "1"}},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_CPU) + "(4)"},
{ov::auto_batch_timeout(10)}},
#ifdef HAVE_TEMPLATE_PLUGIN
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_TEMPLATE) + "(4)"}},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_TEMPLATE) + "(4)"},
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "1"}},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_TEMPLATE) + "(4)"},
{ov::auto_batch_timeout(10)}},
#endif
};
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests,
OVCompiledModelPropertiesTests,
::testing::Combine(::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(auto_batch_properties)),
OVCompiledModelPropertiesTests::getTestCaseName);
} // namespace

27
src/plugins/auto_batch/tests/functional/behavior/ov_infer_request/callback.cpp Normal file
View File

@@ -0,0 +1,27 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/ov_infer_request/callback.hpp"
#include <vector>
using namespace ov::test::behavior;
namespace {
auto autoBatchConfigs = []() {
return std::vector<ov::AnyMap>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
#ifdef HAVE_INTEL_GPU_PLUGIN
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests,
OVInferRequestCallbackTests,
::testing::Combine(::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(autoBatchConfigs())),
OVInferRequestCallbackTests::getTestCaseName);
#endif
} // namespace

25
src/plugins/auto_batch/tests/functional/behavior/ov_infer_request/cancellation.cpp Normal file
View File

@@ -0,0 +1,25 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/ov_infer_request/cancellation.hpp"
using namespace ov::test::behavior;
namespace {
auto autoBatchConfigs = []() {
return std::vector<ov::AnyMap>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
#ifdef HAVE_INTEL_GPU_PLUGIN
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatchBehaviorTests,
OVInferRequestCancellationTests,
::testing::Combine(::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(autoBatchConfigs())),
OVInferRequestCancellationTests::getTestCaseName);
#endif
} // namespace

73
src/plugins/auto_batch/tests/functional/behavior/ov_infer_request/io_tensor.cpp Normal file
View File

@@ -0,0 +1,73 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/ov_infer_request/io_tensor.hpp"
#include <vector>
using namespace ov::test::behavior;
namespace {
auto AutoBatchConfigs = []() {
return std::vector<ov::AnyMap>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
std::vector<ov::element::Type> prcs = {
ov::element::boolean,
ov::element::bf16,
ov::element::f16,
ov::element::f32,
ov::element::f64,
ov::element::i4,
ov::element::i8,
ov::element::i16,
ov::element::i32,
ov::element::i64,
ov::element::u1,
ov::element::u4,
ov::element::u8,
ov::element::u16,
ov::element::u32,
ov::element::u64,
};
std::vector<ov::element::Type> supported_input_prcs = {ov::element::boolean,
ov::element::f16,
ov::element::f32,
ov::element::f64,
ov::element::i8,
ov::element::i16,
ov::element::i32,
ov::element::i64,
ov::element::u8,
ov::element::u16,
ov::element::u32,
ov::element::u64};
#ifdef HAVE_INTEL_GPU_PLUGIN
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests,
OVInferRequestIOTensorTest,
::testing::Combine(::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(AutoBatchConfigs())),
OVInferRequestIOTensorTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests,
OVInferRequestIOTensorSetPrecisionTest,
::testing::Combine(::testing::ValuesIn(prcs),
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(AutoBatchConfigs())),
OVInferRequestIOTensorSetPrecisionTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests,
OVInferRequestCheckTensorPrecision,
::testing::Combine(::testing::ValuesIn(supported_input_prcs),
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(AutoBatchConfigs())),
OVInferRequestCheckTensorPrecision::getTestCaseName);
#endif
} // namespace

27
src/plugins/auto_batch/tests/functional/behavior/ov_infer_request/multithreading.cpp Normal file
View File

@@ -0,0 +1,27 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/ov_infer_request/multithreading.hpp"
#include <vector>
using namespace ov::test::behavior;
namespace {
auto AutoBatchConfigs = []() {
return std::vector<ov::AnyMap>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
#ifdef HAVE_INTEL_GPU_PLUGIN
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests,
OVInferRequestMultithreadingTests,
::testing::Combine(::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(AutoBatchConfigs())),
OVInferRequestMultithreadingTests::getTestCaseName);
#endif
} // namespace

25
src/plugins/auto_batch/tests/functional/behavior/ov_infer_request/perf_counters.cpp Normal file
View File

@@ -0,0 +1,25 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/ov_infer_request/perf_counters.hpp"
using namespace ov::test::behavior;
namespace {
auto AutoBatchConfigs = []() {
return std::vector<ov::AnyMap>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
#ifdef HAVE_INTEL_GPU_PLUGIN
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests,
OVInferRequestPerfCountersTest,
::testing::Combine(::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(AutoBatchConfigs())),
OVInferRequestPerfCountersTest::getTestCaseName);
#endif
} // namespace

27
src/plugins/auto_batch/tests/functional/behavior/ov_infer_request/wait.cpp Normal file
View File

@@ -0,0 +1,27 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/ov_infer_request/wait.hpp"
#include <vector>
using namespace ov::test::behavior;
namespace {
auto AutoBatchConfigs = []() {
return std::vector<ov::AnyMap>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
#ifdef HAVE_INTEL_GPU_PLUGIN
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests,
OVInferRequestWaitTests,
::testing::Combine(::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(AutoBatchConfigs())),
OVInferRequestWaitTests::getTestCaseName);
#endif
} // namespace

14
src/plugins/auto_batch/tests/functional/behavior/ov_plugin/life_time.cpp Normal file
View File

@@ -0,0 +1,14 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/ov_plugin/life_time.hpp"
using namespace ov::test::behavior;
namespace {
INSTANTIATE_TEST_SUITE_P(smoke_VirtualPlugin_BehaviorTests,
OVHoldersTest,
::testing::Values(CommonTestUtils::DEVICE_BATCH),
OVHoldersTest::getTestCaseName);
} // namespace

34
src/plugins/auto_batch/tests/functional/behavior/ov_plugin/properties_tests.cpp Normal file
View File

@@ -0,0 +1,34 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/ov_plugin/properties_tests.hpp"
#include "openvino/runtime/properties.hpp"
using namespace ov::test::behavior;
namespace {
const std::vector<ov::AnyMap> auto_batch_inproperties = {
{ov::device::id("UNSUPPORTED_DEVICE_ID_STRING")},
};
INSTANTIATE_TEST_SUITE_P(DISABLED_smoke_AutoBatch_BehaviorTests,
OVPropertiesIncorrectTests,
::testing::Combine(::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(auto_batch_inproperties)),
OVPropertiesIncorrectTests::getTestCaseName);
const std::vector<ov::AnyMap> auto_batch_properties = {
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), CommonTestUtils::DEVICE_TEMPLATE}},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), CommonTestUtils::DEVICE_TEMPLATE}, {CONFIG_KEY(AUTO_BATCH_TIMEOUT), "1"}},
};
#ifdef HAVE_INTEL_TEMPLATE_PLUGIN
INSTANTIATE_TEST_SUITE_P(DISABLED_smoke_AutoBatch_BehaviorTests,
OVPropertiesTests,
::testing::Combine(::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(auto_batch_properties)),
OVPropertiesTests::getTestCaseName);
#endif
} // namespace

33
src/plugins/auto_batch/tests/functional/behavior/ov_plugin/remote.cpp Normal file
View File

@@ -0,0 +1,33 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/ov_plugin/remote.hpp"
#include "common_test_utils/test_constants.hpp"
#include "ie_plugin_config.hpp"
using namespace ov::test;
namespace {
std::vector<std::pair<ov::AnyMap, ov::AnyMap>> generate_remote_params() {
return {};
}
auto AutoBatchConfigs = []() {
return std::vector<ov::AnyMap>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
#ifdef HAVE_INTEL_GPU_PLUGIN
INSTANTIATE_TEST_SUITE_P(DISABLED_smoke_AutoBatch_BehaviorTests,
OVRemoteTest,
::testing::Combine(::testing::Values(ngraph::element::f32),
::testing::Values(::CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(AutoBatchConfigs()),
::testing::ValuesIn(generate_remote_params())),
OVRemoteTest::getTestCaseName);
#endif
} // namespace

2
src/plugins/auto_batch/tests/functional/behavior/plugin/auto_batching_tests.cpp
View File

@@ -32,7 +32,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_AutoBatching_CPU,
::testing::ValuesIn(num_batch)),
AutoBatching_Test_DetectionOutput::getTestCaseName);
#ifdef HAVE_GPU_PLUGIN
#ifdef HAVE_INTEL_GPU_PLUGIN
const std::vector<size_t> gpu_num_streams{2};
const std::vector<bool> gpu_get_vs_set{true, false};
const std::vector<size_t> gpu_num_requests{1, 8, 16, 64};

54
src/plugins/auto_batch/tests/functional/behavior/plugin/configuration_tests.cpp Normal file
View File

@@ -0,0 +1,54 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/plugin/configuration_tests.hpp"
#include "gpu/gpu_config.hpp"
using namespace BehaviorTestsDefinitions;
namespace {
IE_SUPPRESS_DEPRECATED_START
auto auto_batch_inconfigs = []() {
return std::vector<std::map<std::string, std::string>>{
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), CommonTestUtils::DEVICE_GPU}, {CONFIG_KEY(AUTO_BATCH_TIMEOUT), "-1"}},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), CommonTestUtils::DEVICE_GPU},
{InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT, "DOESN'T EXIST"}},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), CommonTestUtils::DEVICE_GPU},
{InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT, InferenceEngine::PluginConfigParams::LATENCY},
{InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT_NUM_REQUESTS, "-1"}},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), CommonTestUtils::DEVICE_GPU},
{InferenceEngine::PluginConfigParams::KEY_PERF_COUNT, "ON"}},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), CommonTestUtils::DEVICE_GPU},
{InferenceEngine::PluginConfigParams::KEY_CONFIG_FILE, "unknown_file"}},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), CommonTestUtils::DEVICE_GPU},
{InferenceEngine::PluginConfigParams::KEY_DEVICE_ID, "DEVICE_UNKNOWN"}}};
};
IE_SUPPRESS_DEPRECATED_END
auto auto_batch_configs = []() {
return std::vector<std::map<std::string, std::string>>{
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), CommonTestUtils::DEVICE_GPU}},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), CommonTestUtils::DEVICE_GPU}, {CONFIG_KEY(AUTO_BATCH_TIMEOUT), "1"}},
};
};
#ifdef HAVE_INTEL_GPU_PLUGIN
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests,
IncorrectConfigTests,
::testing::Combine(::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(auto_batch_inconfigs())),
IncorrectConfigTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests,
IncorrectConfigAPITests,
::testing::Combine(::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(auto_batch_inconfigs())),
IncorrectConfigAPITests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests,
CorrectConfigTests,
::testing::Combine(::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(auto_batch_configs())),
CorrectConfigTests::getTestCaseName);
#endif
} // namespace

8
src/plugins/auto_batch/tests/functional/skip_tests_config.cpp
View File

@@ -11,5 +11,13 @@ std::vector<std::string> disabledTestPatterns() {
return {
// TODO: for 22.2 (CVS-68949)
R"(smoke_AutoBatching_CPU/AutoBatching_Test_DetectionOutput.*)",
// Not implemented yet:
R"(.*Behavior.*ExecutableNetworkBaseTest.*canSetConfigToExecNet.*)",
R"(.*Behavior.*ExecutableNetworkBaseTest.*canExport.*)",
R"(.*OVExecutableNetworkBaseTest.*CanSetConfigToExecNet.*)",
R"(.*OVExecutableNetworkBaseTest.*CanSetConfigToExecNetAndCheckConfigAndCheck.*)",
// Issue: 90539
R"(smoke_AutoBatch_BehaviorTests/OVInferRequestIOTensorTest.InferStaticNetworkSetInputTensor/targetDevice=BATCH.*)",
R"(.*VirtualPlugin.*BehaviorTests.*OVHoldersTest.*)",
};
}

22
src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_executable_network/properties.cpp
View File

@@ -28,11 +28,6 @@ const std::vector<ov::AnyMap> auto_inproperties = {
};
const std::vector<ov::AnyMap> auto_batch_inproperties = {
{ov::num_streams(-100)},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG) , std::string(CommonTestUtils::DEVICE_CPU) + "(4)"}, {ov::auto_batch_timeout(-1)}},
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVCompiledModelPropertiesIncorrectTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_CPU),
@@ -57,12 +52,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, OVCompiledModelPropertiesInco
::testing::ValuesIn(auto_inproperties)),
OVCompiledModelPropertiesIncorrectTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, OVCompiledModelPropertiesIncorrectTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(auto_batch_inproperties)),
OVCompiledModelPropertiesIncorrectTests::getTestCaseName);
#if (defined(__APPLE__) || defined(_WIN32))
auto default_affinity = [] {
auto numaNodes = InferenceEngine::getAvailableNUMANodes();
@@ -110,12 +99,6 @@ const std::vector<ov::AnyMap> multi_properties = {
{InferenceEngine::PluginConfigParams::KEY_CPU_THROUGHPUT_STREAMS, InferenceEngine::PluginConfigParams::CPU_THROUGHPUT_AUTO}},
};
const std::vector<ov::AnyMap> auto_batch_properties = {
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG) , std::string(CommonTestUtils::DEVICE_CPU) + "(4)"}},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG) , std::string(CommonTestUtils::DEVICE_CPU) + "(4)"}, {CONFIG_KEY(AUTO_BATCH_TIMEOUT) , "1"}},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG) , std::string(CommonTestUtils::DEVICE_CPU) + "(4)"}, {ov::auto_batch_timeout(10)}},
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVCompiledModelPropertiesTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_CPU),
@@ -134,9 +117,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, OVCompiledModelPropertiesTes
::testing::ValuesIn(multi_properties)),
OVCompiledModelPropertiesTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, OVCompiledModelPropertiesTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(auto_batch_properties)),
OVCompiledModelPropertiesTests::getTestCaseName);
} // namespace

1
src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_plugin/life_time.cpp
View File

@@ -13,7 +13,6 @@ namespace {
INSTANTIATE_TEST_SUITE_P(smoke_VirtualPlugin_BehaviorTests, OVHoldersTest,
::testing::Values("AUTO:CPU",
"MULTI:CPU",
//CommonTestUtils::DEVICE_BATCH,
"HETERO:CPU"),
OVHoldersTest::getTestCaseName);

24
src/plugins/template/tests/functional/shared_tests_instances/behavior/ov_executable_network/properties.cpp
View File

@@ -26,13 +26,6 @@ const std::vector<ov::AnyMap> auto_inproperties = {
{ov::device::id("UNSUPPORTED_DEVICE_ID_STRING")},
};
const std::vector<ov::AnyMap> auto_batch_inproperties = {
{ov::device::id("UNSUPPORTED_DEVICE_ID_STRING")},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG) , std::string(CommonTestUtils::DEVICE_TEMPLATE) + "(4)"},
{ov::auto_batch_timeout(-1)}},
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVCompiledModelPropertiesIncorrectTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_TEMPLATE),
@@ -57,12 +50,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, OVCompiledModelPropertiesInco
::testing::ValuesIn(auto_inproperties)),
OVCompiledModelPropertiesIncorrectTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, OVCompiledModelPropertiesIncorrectTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(auto_batch_inproperties)),
OVCompiledModelPropertiesIncorrectTests::getTestCaseName);
const std::vector<ov::AnyMap> default_properties = {
{ov::enable_profiling(true)},
{ov::device::id("0")},
@@ -90,12 +77,6 @@ const std::vector<ov::AnyMap> multi_properties = {
{ov::device::priorities(CommonTestUtils::DEVICE_TEMPLATE), ov::device::id("0")},
};
const std::vector<ov::AnyMap> auto_batch_properties = {
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG) , std::string(CommonTestUtils::DEVICE_TEMPLATE) + "(4)"}},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG) , std::string(CommonTestUtils::DEVICE_TEMPLATE) + "(4)"}, {CONFIG_KEY(AUTO_BATCH_TIMEOUT) , "1"}},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG) , std::string(CommonTestUtils::DEVICE_TEMPLATE) + "(4)"}, {ov::auto_batch_timeout(10)}},
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVCompiledModelPropertiesTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_TEMPLATE),
@@ -114,9 +95,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, OVCompiledModelPropertiesTes
::testing::ValuesIn(multi_properties)),
OVCompiledModelPropertiesTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, OVCompiledModelPropertiesTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(auto_batch_properties)),
OVCompiledModelPropertiesTests::getTestCaseName);
} // namespace

23
src/plugins/template/tests/functional/shared_tests_instances/behavior/ov_plugin/properties_tests.cpp
View File

@@ -21,16 +21,10 @@ const std::vector<ov::AnyMap> multi_inproperties = {
{ov::device::id("UNSUPPORTED_DEVICE_ID_STRING")},
};
const std::vector<ov::AnyMap> auto_inproperties = {
{ov::device::id("UNSUPPORTED_DEVICE_ID_STRING")},
};
const std::vector<ov::AnyMap> auto_batch_inproperties = {
{ov::device::id("UNSUPPORTED_DEVICE_ID_STRING")},
};
INSTANTIATE_TEST_SUITE_P(DISABLED_smoke_BehaviorTests, OVPropertiesIncorrectTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_TEMPLATE),
@@ -55,12 +49,6 @@ INSTANTIATE_TEST_SUITE_P(DISABLED_smoke_Auto_BehaviorTests, OVPropertiesIncorrec
::testing::ValuesIn(auto_inproperties)),
OVPropertiesIncorrectTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(DISABLED_smoke_AutoBatch_BehaviorTests, OVPropertiesIncorrectTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(auto_batch_inproperties)),
OVPropertiesIncorrectTests::getTestCaseName);
const std::vector<ov::AnyMap> default_properties = {
{ov::enable_profiling(true)},
{ov::device::id(0)},
@@ -88,12 +76,6 @@ const std::vector<ov::AnyMap> multi_properties = {
{ov::device::priorities(CommonTestUtils::DEVICE_TEMPLATE), ov::device::id(0)},
};
const std::vector<ov::AnyMap> auto_batch_properties = {
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG) , CommonTestUtils::DEVICE_TEMPLATE}},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG) , CommonTestUtils::DEVICE_TEMPLATE},
{CONFIG_KEY(AUTO_BATCH_TIMEOUT) , "1"}},
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVPropertiesTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_TEMPLATE),
@@ -112,9 +94,4 @@ INSTANTIATE_TEST_SUITE_P(DISABLED_smoke_Multi_BehaviorTests, OVPropertiesTests,
::testing::ValuesIn(multi_properties)),
OVPropertiesTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(DISABLED_smoke_AutoBatch_BehaviorTests, OVPropertiesTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(auto_batch_properties)),
OVPropertiesTests::getTestCaseName);
} // namespace

15
src/tests/functional/plugin/gpu/shared_tests_instances/behavior/executable_network/exec_net_base.cpp
View File

@@ -58,14 +58,6 @@ auto autoConfig = []() {
};
};
auto autoBatchConfig = []() {
return std::vector<std::map<std::string, std::string>>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, ExecNetSetPrecision,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
@@ -86,11 +78,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, ExecNetSetPrecision,
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(autoConfig())),
ExecNetSetPrecision::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, ExecNetSetPrecision,
::testing::Combine(
::testing::ValuesIn(netPrecisions),
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(autoBatchConfig())),
ExecNetSetPrecision::getTestCaseName);
} // namespace

14
src/tests/functional/plugin/gpu/shared_tests_instances/behavior/infer_request/callback.cpp
View File

@@ -24,14 +24,6 @@ auto autoConfigs = []() {
CommonTestUtils::DEVICE_GPU + std::string(",") + CommonTestUtils::DEVICE_CPU}}};
};
auto autoBatchConfigs = []() {
return std::vector<std::map<std::string, std::string>>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, InferRequestCallbackTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_GPU),
@@ -49,10 +41,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, InferRequestCallbackTests,
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(autoConfigs())),
InferRequestCallbackTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, InferRequestCallbackTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(autoBatchConfigs())),
InferRequestCallbackTests::getTestCaseName);
} // namespace

14
src/tests/functional/plugin/gpu/shared_tests_instances/behavior/infer_request/multithreading.cpp
View File

@@ -21,14 +21,6 @@ auto autoconfigs = []() {
std::string(CommonTestUtils::DEVICE_CPU) + "," + CommonTestUtils::DEVICE_GPU}}};
};
auto auto_batch_configs = []() {
return std::vector<std::map<std::string, std::string>>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, InferRequestMultithreadingTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_GPU),
@@ -47,10 +39,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, InferRequestMultithreadingTes
::testing::ValuesIn(autoconfigs())),
InferRequestMultithreadingTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, InferRequestMultithreadingTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(auto_batch_configs())),
InferRequestMultithreadingTests::getTestCaseName);
} // namespace

15
src/tests/functional/plugin/gpu/shared_tests_instances/behavior/infer_request/perf_counters.cpp
View File

@@ -24,15 +24,6 @@ auto AutoConfigs =
CommonTestUtils::DEVICE_GPU + std::string(",") + CommonTestUtils::DEVICE_CPU}}};
};
auto AutoBatchConfigs =
[]() {
return std::vector<std::map<std::string, std::string>>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests,
InferRequestPerfCountersTest,
::testing::Combine(::testing::Values(CommonTestUtils::DEVICE_GPU),
@@ -50,10 +41,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests,
::testing::Combine(::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(AutoConfigs())),
InferRequestPerfCountersTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests,
InferRequestPerfCountersTest,
::testing::Combine(::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(AutoBatchConfigs())),
InferRequestPerfCountersTest::getTestCaseName);
} // namespace

14
src/tests/functional/plugin/gpu/shared_tests_instances/behavior/infer_request/wait.cpp
View File

@@ -21,14 +21,6 @@ auto autoConfigs = []() {
CommonTestUtils::DEVICE_GPU + std::string(",") + CommonTestUtils::DEVICE_CPU}}};
};
auto autoBatchConfigs = []() {
return std::vector<std::map<std::string, std::string>>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests,
InferRequestWaitTests,
::testing::Combine(::testing::Values(CommonTestUtils::DEVICE_GPU),
@@ -47,10 +39,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests,
::testing::ValuesIn(autoConfigs())),
InferRequestWaitTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests,
InferRequestWaitTests,
::testing::Combine(::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(autoBatchConfigs())),
InferRequestWaitTests::getTestCaseName);
} // namespace

14
src/tests/functional/plugin/gpu/shared_tests_instances/behavior/ov_executable_network/exec_net_base.cpp
View File

@@ -12,23 +12,9 @@ auto configs = []() {
};
};
auto autoBatchConfigs = []() {
return std::vector<ov::AnyMap>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVExecutableNetworkBaseTest,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_GPU),
::testing::ValuesIn(configs())),
OVExecutableNetworkBaseTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatchBehaviorTests, OVExecutableNetworkBaseTest,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(autoBatchConfigs())),
OVExecutableNetworkBaseTest::getTestCaseName);
} // namespace

14
src/tests/functional/plugin/gpu/shared_tests_instances/behavior/ov_infer_request/callback.cpp
View File

@@ -21,14 +21,6 @@ auto multiConfigs = []() {
return std::vector<ov::AnyMap>{{ov::device::priorities(CommonTestUtils::DEVICE_GPU)}};
};
auto autoBatchConfigs = []() {
return std::vector<ov::AnyMap>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVInferRequestCallbackTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_GPU),
@@ -47,10 +39,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, OVInferRequestCallbackTests,
::testing::ValuesIn(multiConfigs())),
OVInferRequestCallbackTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, OVInferRequestCallbackTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(autoBatchConfigs())),
OVInferRequestCallbackTests::getTestCaseName);
} // namespace

13
src/tests/functional/plugin/gpu/shared_tests_instances/behavior/ov_infer_request/cancellation.cpp
View File

@@ -13,23 +13,10 @@ auto configs = []() {
};
};
auto autoBatchConfigs = []() {
return std::vector<ov::AnyMap>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVInferRequestCancellationTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_GPU),
::testing::ValuesIn(configs())),
OVInferRequestCancellationTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatchBehaviorTests, OVInferRequestCancellationTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(autoBatchConfigs())),
OVInferRequestCancellationTests::getTestCaseName);
} // namespace

27
src/tests/functional/plugin/gpu/shared_tests_instances/behavior/ov_infer_request/io_tensor.cpp
View File

@@ -30,14 +30,6 @@ auto AutoConfigs = []() {
return std::vector<ov::AnyMap>{{ov::device::priorities(CommonTestUtils::DEVICE_GPU)}};
};
auto AutoBatchConfigs = []() {
return std::vector<ov::AnyMap>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVInferRequestIOTensorTest,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_GPU),
@@ -56,12 +48,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, OVInferRequestIOTensorTest,
::testing::ValuesIn(AutoConfigs())),
OVInferRequestIOTensorTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, OVInferRequestIOTensorTest,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(AutoBatchConfigs())),
OVInferRequestIOTensorTest::getTestCaseName);
std::vector<ov::element::Type> prcs = {
ov::element::boolean,
ov::element::bf16,
@@ -117,12 +103,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, OVInferRequestIOTensorSetPrec
::testing::ValuesIn(AutoConfigs())),
OVInferRequestIOTensorSetPrecisionTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, OVInferRequestIOTensorSetPrecisionTest,
::testing::Combine(
::testing::ValuesIn(prcs),
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(AutoBatchConfigs())),
OVInferRequestIOTensorSetPrecisionTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_GPU_BehaviorTests, OVInferRequestCheckTensorPrecision,
::testing::Combine(
@@ -131,10 +111,5 @@ INSTANTIATE_TEST_SUITE_P(smoke_GPU_BehaviorTests, OVInferRequestCheckTensorPreci
::testing::ValuesIn(emptyConfigs())),
OVInferRequestCheckTensorPrecision::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, OVInferRequestCheckTensorPrecision,
::testing::Combine(
::testing::ValuesIn(supported_input_prcs),
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(AutoBatchConfigs())),
OVInferRequestCheckTensorPrecision::getTestCaseName);
} // namespace

13
src/tests/functional/plugin/gpu/shared_tests_instances/behavior/ov_infer_request/multithreading.cpp
View File

@@ -22,14 +22,6 @@ auto Multiconfigs = []() {
return std::vector<ov::AnyMap>{{ov::device::priorities(CommonTestUtils::DEVICE_GPU)}};
};
auto AutoBatchConfigs = []() {
return std::vector<ov::AnyMap>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVInferRequestMultithreadingTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_GPU),
@@ -48,9 +40,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, OVInferRequestMultithreadingT
::testing::ValuesIn(Multiconfigs())),
OVInferRequestMultithreadingTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, OVInferRequestMultithreadingTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(AutoBatchConfigs())),
OVInferRequestMultithreadingTests::getTestCaseName);
} // namespace

13
src/tests/functional/plugin/gpu/shared_tests_instances/behavior/ov_infer_request/perf_counters.cpp
View File

@@ -41,14 +41,6 @@ auto Autoconfigs = []() {
return std::vector<ov::AnyMap>{{ov::device::priorities(CommonTestUtils::DEVICE_GPU)}};
};
auto AutoBatchConfigs = []() {
return std::vector<ov::AnyMap>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVInferRequestPerfCountersTest,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_GPU),
@@ -67,9 +59,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, OVInferRequestPerfCountersTes
::testing::ValuesIn(Autoconfigs())),
OVInferRequestPerfCountersTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, OVInferRequestPerfCountersTest,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(AutoBatchConfigs())),
OVInferRequestPerfCountersTest::getTestCaseName);
} // namespace

13
src/tests/functional/plugin/gpu/shared_tests_instances/behavior/ov_infer_request/wait.cpp
View File

@@ -26,14 +26,6 @@ auto Autoconfigs = []() {
return std::vector<ov::AnyMap>{{ov::device::priorities(CommonTestUtils::DEVICE_GPU)}};
};
auto AutoBatchConfigs = []() {
return std::vector<ov::AnyMap>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVInferRequestWaitTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_GPU),
@@ -52,9 +44,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, OVInferRequestWaitTests,
::testing::ValuesIn(Autoconfigs())),
OVInferRequestWaitTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, OVInferRequestWaitTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(AutoBatchConfigs())),
OVInferRequestWaitTests::getTestCaseName);
} // namespace

15
src/tests/functional/plugin/gpu/shared_tests_instances/behavior/ov_plugin/remote.cpp
View File

@@ -20,14 +20,6 @@ auto MultiConfigs = []() {
return std::vector<ov::AnyMap>{{ov::device::priorities(CommonTestUtils::DEVICE_GPU)}};
};
auto AutoBatchConfigs = []() {
return std::vector<ov::AnyMap>{
// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU)
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), std::string(CommonTestUtils::DEVICE_GPU) + "(4)"},
// no timeout to avoid increasing the test time
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "0 "}}};
};
INSTANTIATE_TEST_SUITE_P(DISABLED_smoke_BehaviorTests, OVRemoteTest,
::testing::Combine(
::testing::Values(ngraph::element::f32),
@@ -44,11 +36,4 @@ INSTANTIATE_TEST_SUITE_P(DISABLED_smoke_Multi_BehaviorTests, OVRemoteTest,
::testing::ValuesIn(generate_remote_params())),
OVRemoteTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(DISABLED_smoke_AutoBatch_BehaviorTests, OVRemoteTest,
::testing::Combine(
::testing::Values(ngraph::element::f32),
::testing::Values(::CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(AutoBatchConfigs()),
::testing::ValuesIn(generate_remote_params())),
OVRemoteTest::getTestCaseName);
} // namespace

44
src/tests/functional/plugin/gpu/shared_tests_instances/behavior/plugin/configuration_tests.cpp
View File

@@ -86,24 +86,6 @@ namespace {
CommonTestUtils::DEVICE_GPU + std::string(",") + CommonTestUtils::DEVICE_CPU},
{InferenceEngine::PluginConfigParams::KEY_MODEL_PRIORITY, "ABC"}}};
};
auto auto_batch_inconfigs = []() {
return std::vector<std::map<std::string, std::string>>{
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), CommonTestUtils::DEVICE_GPU},
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "-1"}},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), CommonTestUtils::DEVICE_GPU},
{InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT, "DOESN'T EXIST"}},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), CommonTestUtils::DEVICE_GPU},
{InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT, InferenceEngine::PluginConfigParams::LATENCY},
{InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT_NUM_REQUESTS, "-1"}},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), CommonTestUtils::DEVICE_GPU},
{InferenceEngine::PluginConfigParams::KEY_PERF_COUNT, "ON"}},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), CommonTestUtils::DEVICE_GPU},
{InferenceEngine::PluginConfigParams::KEY_CONFIG_FILE, "unknown_file"}},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), CommonTestUtils::DEVICE_GPU},
{InferenceEngine::PluginConfigParams::KEY_DEVICE_ID, "DEVICE_UNKNOWN"}}};
};
IE_SUPPRESS_DEPRECATED_END
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, IncorrectConfigTests,
@@ -124,13 +106,6 @@ namespace {
::testing::ValuesIn(autoinconfigs())),
IncorrectConfigTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, IncorrectConfigTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(auto_batch_inconfigs())),
IncorrectConfigTests::getTestCaseName);
const std::vector<std::map<std::string, std::string>> conf = {
{}
};
@@ -231,14 +206,6 @@ namespace {
InferenceEngine::PluginConfigParams::MODEL_PRIORITY_LOW}}};
};
auto auto_batch_configs = []() {
return std::vector<std::map<std::string, std::string>>{
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), CommonTestUtils::DEVICE_GPU}},
{{CONFIG_KEY(AUTO_BATCH_DEVICE_CONFIG), CommonTestUtils::DEVICE_GPU},
{CONFIG_KEY(AUTO_BATCH_TIMEOUT), "1"}},
};
};
INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, DefaultValuesConfigTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_GPU),
@@ -262,17 +229,6 @@ namespace {
::testing::Values(CommonTestUtils::DEVICE_AUTO),
::testing::ValuesIn(autoinconfigs())),
IncorrectConfigAPITests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, IncorrectConfigAPITests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(auto_batch_inconfigs())),
IncorrectConfigAPITests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, CorrectConfigTests,
::testing::Combine(
::testing::Values(CommonTestUtils::DEVICE_BATCH),
::testing::ValuesIn(auto_batch_configs())),
CorrectConfigTests::getTestCaseName);
auto ExcluAsyncReqConfigs = []() {
return std::vector<std::map<std::string, std::string>>{