Get rid of API1.0 in stress_tests (openvinotoolkit#22888)

vurusovs · web-flow · commit 099c6f6c0cf4 · 2024-02-17T10:06:45.000Z
### Details:
Run of tests with `api_version=1` causes `Unsupported API version`
runtime error

### Tickets:
- CVS-129879
diff --git a/tests/stress_tests/.automation/memcheck_tests/nightly_configs/desktop_test_config.xml b/tests/stress_tests/.automation/memcheck_tests/nightly_configs/desktop_test_config.xml
@@ -3,10 +3,6 @@
         <value>CPU</value>
         <value>GPU</value>
     </devices>
-    <api_versions>
-        <value>1</value>
-        <value>2</value>
-    </api_versions>
     <models>
         <!--Models with FP32 precision-->
         <model name="mobilenet-v2-1.4-224" precision="FP32" source="omz" />
diff --git a/tests/stress_tests/.automation/memcheck_tests/precommit_configs/desktop_test_config.xml b/tests/stress_tests/.automation/memcheck_tests/precommit_configs/desktop_test_config.xml
@@ -3,10 +3,6 @@
         <value>CPU</value>
         <value>GPU</value>
     </devices>
-    <api_versions>
-        <value>1</value>
-        <value>2</value>
-    </api_versions>
     <models>
         <!--Models with FP32 precision-->
         <model name="vgg16" precision="FP32" source="omz" />
diff --git a/tests/stress_tests/.automation/memcheck_tests/weekly_configs/desktop_test_config.xml b/tests/stress_tests/.automation/memcheck_tests/weekly_configs/desktop_test_config.xml
@@ -3,10 +3,6 @@
         <value>CPU</value>
         <value>GPU</value>
     </devices>
-    <api_versions>
-        <value>1</value>
-        <value>2</value>
-    </api_versions>
     <models>
         <!--Models with FP32 precision-->
         <model name="mobilenet-v2-1.4-224" precision="FP32" source="omz" />
diff --git a/tests/stress_tests/.automation/unittests/nightly_configs/desktop_test_config.xml b/tests/stress_tests/.automation/unittests/nightly_configs/desktop_test_config.xml
@@ -14,10 +14,6 @@
         <value>CPU</value>
         <value>GPU</value>
     </devices>
-    <api_versions>
-        <value>1</value>
-        <value>2</value>
-    </api_versions>
     <models>
         <model name="alexnet" precision="FP32" source="omz" />
         <model name="mobilenet-ssd" precision="FP32" source="omz" />
diff --git a/tests/stress_tests/.automation/unittests/weekly_configs/desktop_test_config.xml b/tests/stress_tests/.automation/unittests/weekly_configs/desktop_test_config.xml
@@ -15,10 +15,6 @@
         <value>CPU</value>
         <value>GPU</value>
     </devices>
-    <api_versions>
-        <value>1</value>
-        <value>2</value>
-    </api_versions>
     <models>
         <model name="alexnet" precision="FP32" source="omz" />
         <model name="mobilenet-ssd" precision="FP32" source="omz" />
diff --git a/tests/stress_tests/common/ie_pipelines/pipelines.cpp b/tests/stress_tests/common/ie_pipelines/pipelines.cpp
@@ -12,60 +12,60 @@
 #include <openvino/openvino.hpp>
 
 
-std::function<void()> load_unload_plugin(const std::string &target_device, const int &api_version) {
+std::function<void()> load_unload_plugin(const std::string &target_device) {
     return [&] {
-        auto ie_api_wrapper = create_infer_api_wrapper(api_version);
+        auto ie_api_wrapper = create_infer_api_wrapper();
         // get_versions silently register plugin in `plugins` through `get_plugin`
         ie_api_wrapper->load_plugin(target_device);
         // Remove plugin for target_device from `plugins`
         ie_api_wrapper->unload_plugin(target_device);
     };
 }
 
-std::function<void()> read_cnnnetwork(const std::string &model, const int &api_version) {
+std::function<void()> read_cnnnetwork(const std::string &model) {
     return [&] {
-        auto ie_api_wrapper = create_infer_api_wrapper(api_version);
+        auto ie_api_wrapper = create_infer_api_wrapper();
         ie_api_wrapper->read_network(model);
     };
 }
 
-std::function<void()> cnnnetwork_reshape_batch_x2(const std::string &model, const int &iter, const int &api_version) {
+std::function<void()> cnnnetwork_reshape_batch_x2(const std::string &model, const int &iter) {
     return [&] {
-        auto ie_api_wrapper = create_infer_api_wrapper(api_version);
+        auto ie_api_wrapper = create_infer_api_wrapper();
         ie_api_wrapper->read_network(model);
         ie_api_wrapper->change_batch_size(2, iter);
     };
 }
 
-std::function<void()> set_input_params(const std::string &model, const int &api_version) {
+std::function<void()> set_input_params(const std::string &model) {
     return [&] {
-        auto ie_api_wrapper = create_infer_api_wrapper(api_version);
+        auto ie_api_wrapper = create_infer_api_wrapper();
         ie_api_wrapper->read_network(model);
         ie_api_wrapper->set_input_params(model);
     };
 }
 
 std::function<void()>
-create_compiled_model(const std::string &model, const std::string &target_device, const int &api_version) {
+create_compiled_model(const std::string &model, const std::string &target_device) {
     return [&] {
-        auto ie_api_wrapper = create_infer_api_wrapper(api_version);
+        auto ie_api_wrapper = create_infer_api_wrapper();
         ie_api_wrapper->read_network(model);
         ie_api_wrapper->load_network(target_device);
     };
 }
 
 std::function<void()> recreate_compiled_model(std::shared_ptr<InferApiBase> &ie_wrapper,
-                                              const std::string &target_device, const int &api_version) {
+                                              const std::string &target_device) {
     return [=] {
         ie_wrapper->load_network(target_device);
     };
 }
 
 
 std::function<void()>
-create_infer_request(const std::string &model, const std::string &target_device, const int &api_version) {
+create_infer_request(const std::string &model, const std::string &target_device) {
     return [&] {
-        auto ie_api_wrapper = create_infer_api_wrapper(api_version);
+        auto ie_api_wrapper = create_infer_api_wrapper();
         ie_api_wrapper->read_network(model);
         ie_api_wrapper->load_network(target_device);
         ie_api_wrapper->create_infer_request();
@@ -81,9 +81,9 @@ std::function<void()> recreate_infer_request(std::shared_ptr<InferApiBase> &ie_w
 
 
 std::function<void()>
-infer_request_inference(const std::string &model, const std::string &target_device, const int &api_version) {
+infer_request_inference(const std::string &model, const std::string &target_device) {
     return [&] {
-        auto ie_api_wrapper = create_infer_api_wrapper(api_version);
+        auto ie_api_wrapper = create_infer_api_wrapper();
         ie_api_wrapper->read_network(model);
         ie_api_wrapper->load_network(target_device);
         ie_api_wrapper->create_infer_request();
@@ -112,11 +112,10 @@ std::function<void()> recreate_and_infer_in_thread(std::shared_ptr<InferApiBase>
 }
 
 std::function<void()>
-inference_with_streams(const std::string &model, const std::string &target_device, const int &nstreams,
-                       const int &api_version) {
+inference_with_streams(const std::string &model, const std::string &target_device, const int &nstreams) {
     return [&] {
         unsigned int nireq = nstreams;
-        auto ie_api_wrapper = create_infer_api_wrapper(api_version);
+        auto ie_api_wrapper = create_infer_api_wrapper();
         ie_api_wrapper->load_plugin(target_device);
         ie_api_wrapper->set_config(target_device, ov::AnyMap{ov::num_streams(nstreams)});
         ie_api_wrapper->read_network(model);
diff --git a/tests/stress_tests/common/ie_pipelines/pipelines.h b/tests/stress_tests/common/ie_pipelines/pipelines.h
@@ -6,30 +6,28 @@
 #include <functional>
 #include "../infer_api/infer_api.h"
 
-std::function<void()> load_unload_plugin(const std::string &target_device, const int &api_version);
+std::function<void()> load_unload_plugin(const std::string &target_device);
 
-std::function<void()> read_cnnnetwork(const std::string &model, const int &api_version);
+std::function<void()> read_cnnnetwork(const std::string &model);
 
-std::function<void()> cnnnetwork_reshape_batch_x2(const std::string &model, const int &iter, const int &api_version);
+std::function<void()> cnnnetwork_reshape_batch_x2(const std::string &model, const int &iter);
 
-std::function<void()> set_input_params(const std::string &model, const int &api_version);
+std::function<void()> set_input_params(const std::string &model);
 
 std::function<void()>
-create_compiled_model(const std::string &model, const std::string &target_device, const int &api_version);
+create_compiled_model(const std::string &model, const std::string &target_device);
 
 std::function<void()>
-create_infer_request(const std::string &model, const std::string &target_device, const int &api_version);
+create_infer_request(const std::string &model, const std::string &target_device);
 
 std::function<void()>
-infer_request_inference(const std::string &model, const std::string &target_device, const int &api_version);
+infer_request_inference(const std::string &model, const std::string &target_device);
 
 std::function<void()>
-inference_with_streams(const std::string &model, const std::string &target_device, const int &nstreams,
-                       const int &api_version);
+inference_with_streams(const std::string &model, const std::string &target_device, const int &nstreams);
 
 std::function<void()>
-recreate_compiled_model(std::shared_ptr<InferApiBase> &ie_wrapper, const std::string &target_device,
-                        const int &api_version);
+recreate_compiled_model(std::shared_ptr<InferApiBase> &ie_wrapper, const std::string &target_device);
 
 std::function<void()> recreate_infer_request(std::shared_ptr<InferApiBase> &ie_wrapper);
 
diff --git a/tests/stress_tests/common/infer_api/infer_api.cpp b/tests/stress_tests/common/infer_api/infer_api.cpp
@@ -84,10 +84,6 @@ void InferAPI2::set_input_params(const std::string &model) {
     inputs = network->inputs();
 }
 
-std::shared_ptr<InferApiBase> create_infer_api_wrapper(const int &api_version) {
-    if (api_version == 2) {
-        return std::make_shared<InferAPI2>(InferAPI2());
-    } else {
-        throw std::logic_error("Unsupported API version");
-    }
+std::shared_ptr<InferApiBase> create_infer_api_wrapper() {
+    return std::make_shared<InferAPI2>(InferAPI2());
 }
diff --git a/tests/stress_tests/common/infer_api/infer_api.h b/tests/stress_tests/common/infer_api/infer_api.h
@@ -70,4 +70,4 @@ class InferAPI2 : public InferApiBase {
     std::map<std::string, ov::Any> config;
 };
 
-std::shared_ptr<InferApiBase> create_infer_api_wrapper(const int &api_version);
+std::shared_ptr<InferApiBase> create_infer_api_wrapper();
diff --git a/tests/stress_tests/common/tests_utils.cpp b/tests/stress_tests/common/tests_utils.cpp
@@ -19,7 +19,7 @@ std::vector<TestCase> generateTestsParams(std::initializer_list<std::string> fie
     std::vector<TestCase> tests_cases;
     const pugi::xml_document &test_config = Environment::Instance().getTestConfig();
 
-    std::vector<int> processes, threads, iterations, api_versions;
+    std::vector<int> processes, threads, iterations;
     std::vector<std::string> devices, models, models_names, precisions;
 
     pugi::xml_node values;
@@ -40,10 +40,6 @@ std::vector<TestCase> generateTestsParams(std::initializer_list<std::string> fie
             values = test_config.child("attributes").child("devices");
             for (pugi::xml_node val = values.first_child(); val; val = val.next_sibling())
                 devices.emplace_back(val.text().as_string());
-        } else if (field == "api_versions") {
-            values = test_config.child("attributes").child("api_versions");
-            for (pugi::xml_node val = values.first_child(); val; val = val.next_sibling())
-                api_versions.push_back(val.text().as_int());
         } else if (field == "models") {
             values = test_config.child("attributes").child("models");
             for (pugi::xml_node val = values.first_child(); val; val = val.next_sibling()) {
@@ -66,7 +62,6 @@ std::vector<TestCase> generateTestsParams(std::initializer_list<std::string> fie
     processes = !processes.empty() ? processes : std::vector<int>{1};
     threads = !threads.empty() ? threads : std::vector<int>{1};
     iterations = !iterations.empty() ? iterations : std::vector<int>{1};
-    api_versions = !api_versions.empty() ? api_versions : std::vector<int>{1, 2};
     devices = !devices.empty() ? devices : std::vector<std::string>{"NULL"};
     models = !models.empty() ? models : std::vector<std::string>{"NULL"};
     precisions = !precisions.empty() ? precisions : std::vector<std::string>{"NULL"};
@@ -75,11 +70,10 @@ std::vector<TestCase> generateTestsParams(std::initializer_list<std::string> fie
     for (auto &numprocesses: processes)
         for (auto &numthreads: threads)
             for (auto &numiters: iterations)
-                for (auto &api_version: api_versions)
-                    for (auto &device: devices)
-                        for (int i = 0; i < models.size(); i++)
-                            tests_cases.emplace_back(numprocesses, numthreads, numiters, api_version, device, models[i],
-                                                     models_names[i], precisions[i]);
+                for (auto &device: devices)
+                    for (int i = 0; i < models.size(); i++)
+                        tests_cases.emplace_back(numprocesses, numthreads, numiters, device, models[i],
+                                                    models_names[i], precisions[i]);
     return tests_cases;
 }
 
@@ -99,7 +93,6 @@ std::vector<MemLeaksTestCase> generateTestsParamsMemLeaks() {
         numprocesses = device.attribute("processes").as_int(1);
         numthreads = device.attribute("threads").as_int(1);
         numiterations = device.attribute("iterations").as_int(1);
-        std::vector<int> api_versions{1, 2};
 
         std::vector<std::map<std::string, std::string>> models;
 
@@ -117,9 +110,7 @@ std::vector<MemLeaksTestCase> generateTestsParamsMemLeaks() {
                                                          {"precision", precision}};
             models.push_back(model_map);
         }
-        for (auto api_version: api_versions) {
-            tests_cases.emplace_back(numprocesses, numthreads, numiterations, api_version, device_name, models);
-        }
+        tests_cases.emplace_back(numprocesses, numthreads, numiterations, device_name, models);
     }
 
     return tests_cases;
@@ -133,16 +124,16 @@ std::string getTestCaseNameMemLeaks(const testing::TestParamInfo<MemLeaksTestCas
     return obj.param.test_case_name;
 }
 
-void test_wrapper(const std::function<void(std::string, std::string, int, int)> &tests_pipeline,
+void test_wrapper(const std::function<void(std::string, std::string, int)> &tests_pipeline,
                   const TestCase &params) {
-    tests_pipeline(params.model, params.device, params.numiters, params.api_version);
+    tests_pipeline(params.model, params.device, params.numiters);
 }
 
-void _runTest(const std::function<void(std::string, std::string, int, int)> &tests_pipeline, const TestCase &params) {
+void _runTest(const std::function<void(std::string, std::string, int)> &tests_pipeline, const TestCase &params) {
     run_in_threads(params.numthreads, test_wrapper, tests_pipeline, params);
 }
 
-void runTest(const std::function<void(std::string, std::string, int, int)> &tests_pipeline, const TestCase &params) {
+void runTest(const std::function<void(std::string, std::string, int)> &tests_pipeline, const TestCase &params) {
 #if DEBUG_MODE
     tests_pipeline(params.model, params.device, params.numiters);
 #else
diff --git a/tests/stress_tests/common/tests_utils.h b/tests/stress_tests/common/tests_utils.h
@@ -24,7 +24,6 @@ class TestCaseBase {
     int numprocesses;
     int numthreads;
     int numiters;
-    int api_version;
     std::string precision;
     std::string test_case_name;
     std::string model_name;
@@ -45,29 +44,27 @@ class TestCase : public TestCaseBase {
 public:
     std::string model;
 
-    TestCase(int _numprocesses, int _numthreads, int _numiters, int _api_version, std::string _device,
+    TestCase(int _numprocesses, int _numthreads, int _numiters, std::string _device,
              const std::string &_model,
              const std::string &_model_name, const std::string &_precision) {
-        numprocesses = _numprocesses, numthreads = _numthreads, numiters = _numiters, api_version = _api_version,
+        numprocesses = _numprocesses, numthreads = _numthreads, numiters = _numiters,
         device = _device, model = _model, model_name = _model_name, precision = _precision;
         test_case_name = "Numprocesses_" + std::to_string(numprocesses) + "_Numthreads_" + std::to_string(numthreads) +
                          "_Numiters_" + std::to_string(numiters) + "_Device_" + update_item_for_name(device) +
-                         "_Precision_" + update_item_for_name(precision) + "_Model_" + update_item_for_name(model_name)
-                         + "_API_" + std::to_string(api_version);
+                         "_Precision_" + update_item_for_name(precision) + "_Model_" + update_item_for_name(model_name);
     }
 };
 
 class MemLeaksTestCase : public TestCaseBase {
 public:
     std::vector<std::map<std::string, std::string>> models;
 
-    MemLeaksTestCase(int _numprocesses, int _numthreads, int _numiters, int _api_version, std::string _device,
+    MemLeaksTestCase(int _numprocesses, int _numthreads, int _numiters, std::string _device,
                      std::vector<std::map<std::string, std::string>> _models) {
-        numprocesses = _numprocesses, numthreads = _numthreads, numiters = _numiters, api_version = _api_version,
+        numprocesses = _numprocesses, numthreads = _numthreads, numiters = _numiters,
         device = _device, models = _models;
         test_case_name = "Numprocesses_" + std::to_string(numprocesses) + "_Numthreads_" + std::to_string(numthreads) +
-                         "_Numiters_" + std::to_string(numiters) + "_Device_" + update_item_for_name(device) + "_API_" +
-                         std::to_string(api_version);
+                         "_Numiters_" + std::to_string(numiters) + "_Device_" + update_item_for_name(device);
         for (int i = 0; i < models.size(); i++) {
             test_case_name += "_Model" + std::to_string(i + 1) + "_" + update_item_for_name(models[i]["name"]) + "_" +
                               update_item_for_name(models[i]["precision"]);
@@ -106,9 +103,9 @@ std::string getTestCaseName(const testing::TestParamInfo<TestCase> &obj);
 
 std::string getTestCaseNameMemLeaks(const testing::TestParamInfo<MemLeaksTestCase> &obj);
 
-void runTest(const std::function<void(std::string, std::string, int, int)> &tests_pipeline, const TestCase &params);
+void runTest(const std::function<void(std::string, std::string, int)> &tests_pipeline, const TestCase &params);
 
-void _runTest(const std::function<void(std::string, std::string, int, int)> &tests_pipeline, const TestCase &params);
+void _runTest(const std::function<void(std::string, std::string, int)> &tests_pipeline, const TestCase &params);
 
-void test_wrapper(const std::function<void(std::string, std::string, int, int)> &tests_pipeline,
+void test_wrapper(const std::function<void(std::string, std::string, int)> &tests_pipeline,
                   const TestCase &params);
diff --git a/tests/stress_tests/memcheck_tests/tests.cpp b/tests/stress_tests/memcheck_tests/tests.cpp
@@ -49,7 +49,7 @@ TEST_P(MemCheckTestSuite, create_exenetwork) {
     auto test_params = GetParam();
     MemCheckPipeline memCheckPipeline;
     auto test_pipeline = [&] {
-        auto ie_api_wrapper = create_infer_api_wrapper(test_params.api_version);
+        auto ie_api_wrapper = create_infer_api_wrapper();
         ie_api_wrapper->load_plugin(device);
         ie_api_wrapper->read_network(model);
         ie_api_wrapper->load_network(device);
@@ -70,7 +70,7 @@ TEST_P(MemCheckTestSuite, infer_request_inference) {
     auto test_params = GetParam();
     MemCheckPipeline memCheckPipeline;
     auto test_pipeline = [&] {
-        auto ie_api_wrapper = create_infer_api_wrapper(test_params.api_version);
+        auto ie_api_wrapper = create_infer_api_wrapper();
         ie_api_wrapper->load_plugin(device);
         ie_api_wrapper->read_network(model);
         ie_api_wrapper->load_network(device);
@@ -107,7 +107,7 @@ TEST_P(MemCheckTestSuite, inference_with_streams) {
     auto test_pipeline = [&] {
         MemCheckPipeline memCheckPipeline;
         unsigned int nireq = nstreams;
-        auto ie_api_wrapper = create_infer_api_wrapper(test_params.api_version);
+        auto ie_api_wrapper = create_infer_api_wrapper();
         ie_api_wrapper->load_plugin(device);
         ie_api_wrapper->set_config(device, ov::AnyMap{ov::num_streams(nstreams)});
         ie_api_wrapper->read_network(model);
diff --git a/tests/stress_tests/memleaks_tests/tests.cpp b/tests/stress_tests/memleaks_tests/tests.cpp
diff --git a/tests/stress_tests/unittests/tests.cpp b/tests/stress_tests/unittests/tests.cpp
diff --git a/tests/stress_tests/unittests/tests_pipelines/tests_pipelines.cpp b/tests/stress_tests/unittests/tests_pipelines/tests_pipelines.cpp
diff --git a/tests/stress_tests/unittests/tests_pipelines/tests_pipelines.h b/tests/stress_tests/unittests/tests_pipelines/tests_pipelines.h
diff --git a/tests/stress_tests/unittests/tests_pipelines/tests_pipelines_full_pipeline.cpp b/tests/stress_tests/unittests/tests_pipelines/tests_pipelines_full_pipeline.cpp

Original file line number	Diff line number	Diff line change
`@@ -84,10 +84,6 @@ void InferAPI2::set_input_params(const std::string &model) {`
`84`	`84`	`inputs = network->inputs();`
`85`	`85`	`}`
`86`	`86`
`87`		`-std::shared_ptr<InferApiBase> create_infer_api_wrapper(const int &api_version) {`
`88`		`- if (api_version == 2) {`
`89`		`- return std::make_shared<InferAPI2>(InferAPI2());`
`90`		`- } else {`
`91`		`- throw std::logic_error("Unsupported API version");`
`92`		`- }`
	`87`	`+std::shared_ptr<InferApiBase> create_infer_api_wrapper() {`
	`88`	`+ return std::make_shared<InferAPI2>(InferAPI2());`
`93`	`89`	`}`