[TEST] SubgraphBaseTest execution time optimizations

Author: nshchego

src/common/transformations/tests/skip_tests_config.cpp

@@ -7,9 +7,11 @@
 #include <string>
 #include <vector>
 
-std::vector<std::string> disabledTestPatterns() {
-    return {
+const std::vector<std::regex>& disabled_test_patterns() {
+    const static std::vector<std::regex> patterns = {
         // TODO: task 32568, enable after supporting constants outputs in plugins
-        ".*TransformationTests\\.ConstFoldingPriorBox.*",
+        std::regex(".*TransformationTests\\.ConstFoldingPriorBox.*"),
     };
+
+    return patterns;
 }

src/core/src/preprocess/pre_post_process.cpp

@@ -91,39 +91,49 @@ void transformation_pipeline(std::shared_ptr<ov::Model>& model) {
     RTInfoCache rt_info_cache;
     rt_info_cache.store(model);
 
-    Manager manager("pre_post_processing");
-    manager.set_per_pass_validation(false);
-
-    // prerequisite: the model structure optimization before applying of the markup
-    REGISTER_PASS(manager, SharedOpOptimization)
-
-    // 1. Set "disable_const_folding" attribute
-    // we have to add a call into the PrePostProcessing, it runs before compile_model call
-    REGISTER_PASS(manager, MarkGatherSubgraph, element::TypeVector{element::f8e4m3}, element::TypeVector{element::u4});
-    REGISTER_PASS(manager,
-                  MarkDequantization,
-                  TypeVector{i32, u32, i16, u16, i8, u8, u6, i4, u4, u3, u2, u1, nf4, f4e2m1, f8e4m3, f8e5m2, f8e8m0});
-    REGISTER_PASS(manager, DisableShapeOfConstantFolding, false);
-    REGISTER_PASS(manager, DisableRandomUniformConstantFolding)
-    // Mark quantized and f16/bf16 compressed constants to prevent CF for them,
-    // so that not extra memory is used for intermediate decompressed constants.
-    REGISTER_PASS(manager, MarkCompressedFloatConstants);
-    REGISTER_PASS(manager, DisableDecompressionConvertConstantFolding);
-
-    // 2. Fusion transformations:
-    REGISTER_PASS(manager, ConvertDivideWithConstant)
-    auto fusions = manager.register_pass<GraphRewrite>();
-    // Gelu fusion have to be executed before MulConv fusion because Mul(X, 0.5) might be fused to Conv weights
-    ADD_MATCHER(fusions, GeluFusion)
-    ADD_MATCHER(fusions, MultiplyConvolutionFusion)
-    ADD_MATCHER(fusions, MultiplyGroupConvolutionFusion)
-    ADD_MATCHER(fusions, MultiplyConvolutionBackpropDataFusion)
-    ADD_MATCHER(fusions, MultiplyGroupConvolutionBackpropDataFusion)
-    fusions->set_name("ov::pass::MultiplyFusions");
-    REGISTER_PASS(manager, ReverseInputChannelsFusion)
-
-    // 3. CF call due to detected perf degradations
-    REGISTER_PASS(manager, ConstantFolding)
+    auto get_manager = []() {
+        Manager manager("pre_post_processing");
+        manager.set_per_pass_validation(false);
+
+        // prerequisite: the model structure optimization before applying of the markup
+        REGISTER_PASS(manager, SharedOpOptimization)
+
+        // 1. Set "disable_const_folding" attribute
+        // we have to add a call into the PrePostProcessing, it runs before compile_model call
+        REGISTER_PASS(manager,
+                      MarkGatherSubgraph,
+                      element::TypeVector{element::f8e4m3},
+                      element::TypeVector{element::u4});
+        REGISTER_PASS(
+            manager,
+            MarkDequantization,
+            TypeVector{i32, u32, i16, u16, i8, u8, u6, i4, u4, u3, u2, u1, nf4, f4e2m1, f8e4m3, f8e5m2, f8e8m0});
+        REGISTER_PASS(manager, DisableShapeOfConstantFolding, false);
+        REGISTER_PASS(manager, DisableRandomUniformConstantFolding)
+        // Mark quantized and f16/bf16 compressed constants to prevent CF for them,
+        // so that not extra memory is used for intermediate decompressed constants.
+        REGISTER_PASS(manager, MarkCompressedFloatConstants);
+        REGISTER_PASS(manager, DisableDecompressionConvertConstantFolding);
+
+        // 2. Fusion transformations:
+        REGISTER_PASS(manager, ConvertDivideWithConstant)
+        auto fusions = manager.register_pass<GraphRewrite>();
+        // Gelu fusion have to be executed before MulConv fusion because Mul(X, 0.5) might be fused to Conv weights
+        ADD_MATCHER(fusions, GeluFusion)
+        ADD_MATCHER(fusions, MultiplyConvolutionFusion)
+        ADD_MATCHER(fusions, MultiplyGroupConvolutionFusion)
+        ADD_MATCHER(fusions, MultiplyConvolutionBackpropDataFusion)
+        ADD_MATCHER(fusions, MultiplyGroupConvolutionBackpropDataFusion)
+        fusions->set_name("ov::pass::MultiplyFusions");
+        REGISTER_PASS(manager, ReverseInputChannelsFusion)
+
+        // 3. CF call due to detected perf degradations
+        REGISTER_PASS(manager, ConstantFolding)
+
+        return manager;
+    };
+    static Manager manager = get_manager();
+
     manager.run_passes(model);
 
     // 4. Restore old RT info to not affect plugin compilation

src/frontends/onnx/tests/skip_tests_config.cpp

@@ -7,7 +7,7 @@
 #include <string>
 #include <vector>
 
-std::vector<std::string> disabledTestPatterns() {
+const std::vector<std::regex>& disabled_test_patterns() {
     return {
 #ifdef OPENVINO_STATIC_LIBRARY
         // Disable tests for static libraries

src/frontends/paddle/tests/skip_tests_config.cpp

@@ -7,7 +7,7 @@
 #include <string>
 #include <vector>
 
-std::vector<std::string> disabledTestPatterns() {
+const std::vector<std::regex>& disabled_test_patterns() {
     return {
 #ifdef OPENVINO_STATIC_LIBRARY
         // Disable tests for static libraries

src/inference/tests/functional/skip_tests_config.cpp

@@ -7,6 +7,8 @@
 #include <string>
 #include <vector>
 
-std::vector<std::string> disabledTestPatterns() {
-    return {};
+const std::vector<std::regex>& disabled_test_patterns() {
+    const static std::vector<std::regex> patterns = {};
+
+    return patterns;
 }

src/plugins/auto/tests/functional/shared_tests_instances/skip_tests_config.cpp

@@ -9,38 +9,42 @@
 
 #include "openvino/core/visibility.hpp"
 
-std::vector<std::string> disabledTestPatterns() {
-    std::vector<std::string> retVector{
+const std::vector<std::regex>& disabled_test_patterns() {
+    const static std::vector<std::regex> patterns = {
         // Not implemented yet:
-        R"(.*Behavior.*OVCompiledModelBaseTest.*canSetConfigToCompiledModel.*)",
-        R"(.*Behavior.*OVCompiledModelBaseTest.*canExportModel.*)",
-        R"(.*Behavior.*OVCompiledModelBaseTest.*canSetConfigToCompiledModelWithIncorrectConfig.*)",
+        std::regex(R"(.*Behavior.*OVCompiledModelBaseTest.*canSetConfigToCompiledModel.*)"),
+        std::regex(R"(.*Behavior.*OVCompiledModelBaseTest.*canExportModel.*)"),
+        std::regex(R"(.*Behavior.*OVCompiledModelBaseTest.*canSetConfigToCompiledModelWithIncorrectConfig.*)"),
         // requires export_model be implemented
-        R"(.*Behavior.*OVCompiledModelBaseTest.*import_from_weightless_blob.*targetDevice=(MULTI|AUTO).*)",
-        R"(.*Behavior.*OVCompiledModelBaseTest.*compile_from.*_blob.*targetDevice=(MULTI|AUTO).*)",
-        R"(.*Behavior.*OVCompiledModelBaseTest.*use_blob_hint.*targetDevice=(MULTI|AUTO).*)",
+        std::regex(R"(.*Behavior.*OVCompiledModelBaseTest.*import_from_weightless_blob.*targetDevice=(MULTI|AUTO).*)"),
+        std::regex(R"(.*Behavior.*OVCompiledModelBaseTest.*compile_from.*_blob.*targetDevice=(MULTI|AUTO).*)"),
+        std::regex(R"(.*Behavior.*OVCompiledModelBaseTest.*use_blob_hint.*targetDevice=(MULTI|AUTO).*)"),
 
         // unsupported metrics
-        R"(.*smoke_AutoOVGetMetricPropsTest.*OVGetMetricPropsTest.*(AVAILABLE_DEVICES|OPTIMIZATION_CAPABILITIES|RANGE_FOR_ASYNC_INFER_REQUESTS|RANGE_FOR_STREAMS).*)",
+        std::regex(
+            R"(.*smoke_AutoOVGetMetricPropsTest.*OVGetMetricPropsTest.*(AVAILABLE_DEVICES|OPTIMIZATION_CAPABILITIES|RANGE_FOR_ASYNC_INFER_REQUESTS|RANGE_FOR_STREAMS).*)"),
 
         // Issue:
         // New API tensor tests
-        R"(.*OVInferRequestCheckTensorPrecision.*type=i4.*)",
-        R"(.*OVInferRequestCheckTensorPrecision.*type=u1.*)",
-        R"(.*OVInferRequestCheckTensorPrecision.*type=u4.*)",
+        std::regex(R"(.*OVInferRequestCheckTensorPrecision.*type=i4.*)"),
+        std::regex(R"(.*OVInferRequestCheckTensorPrecision.*type=u1.*)"),
+        std::regex(R"(.*OVInferRequestCheckTensorPrecision.*type=u4.*)"),
 
         // AUTO does not support import / export
-        R"(.*smoke_Auto_BehaviorTests/OVCompiledGraphImportExportTest.*(mportExport|readFromV10IR).*/targetDevice=(AUTO).*)",
-        R"(.*Behavior.*OVInferRequestIOTensorTest.*canInferAfterIOBlobReallocation.*)",
-        R"(.*Behavior.*OVInferRequestDynamicTests.*InferUpperBoundNetworkAfterIOTensorsReshaping.*)",
+        std::regex(
+            R"(.*smoke_Auto_BehaviorTests/OVCompiledGraphImportExportTest.*(mportExport|readFromV10IR).*/targetDevice=(AUTO).*)"),
+        std::regex(R"(.*Behavior.*OVInferRequestIOTensorTest.*canInferAfterIOBlobReallocation.*)"),
+        std::regex(R"(.*Behavior.*OVInferRequestDynamicTests.*InferUpperBoundNetworkAfterIOTensorsReshaping.*)"),
         // template plugin doesn't support this case
-        R"(.*OVInferRequestPerfCountersTest.*CheckOperationInProfilingInfo.*)",
+        std::regex(R"(.*OVInferRequestPerfCountersTest.*CheckOperationInProfilingInfo.*)"),
         // model import is not supported
-        R"(.*OVCompiledModelBaseTest.import_from_.*)"};
+        std::regex(R"(.*OVCompiledModelBaseTest.import_from_.*)"),
 
 #if !defined(OPENVINO_ARCH_X86_64)
-    // very time-consuming test
-    retVector.emplace_back(R"(.*OVInferConsistencyTest.*)");
+        // very time-consuming test
+        std::regex(R"(.*OVInferConsistencyTest.*)"),
 #endif
-    return retVector;
+    };
+
+    return patterns;
 }

src/plugins/auto_batch/tests/functional/skip_tests_config.cpp

@@ -7,31 +7,31 @@
 #include <string>
 #include <vector>
 
-std::vector<std::string> disabledTestPatterns() {
-    std::vector<std::string> disabled_items = {
+const std::vector<std::regex>& disabled_test_patterns() {
+    const static std::vector<std::regex> patterns = {
         // TODO: for CVS-68949
         // Not implemented yet:
-        R"(.*Behavior.*ExecutableNetworkBaseTest.*canSetConfigToExecNet.*)",
-        R"(.*Behavior.*ExecutableNetworkBaseTest.*canExport.*)",
-        R"(.*OVExecutableNetworkBaseTest.*CanSetConfigToExecNet.*)",
-        R"(.*OVExecutableNetworkBaseTest.*CanSetConfigToExecNetAndCheckConfigAndCheck.*)",
+        std::regex(R"(.*Behavior.*ExecutableNetworkBaseTest.*canSetConfigToExecNet.*)"),
+        std::regex(R"(.*Behavior.*ExecutableNetworkBaseTest.*canExport.*)"),
+        std::regex(R"(.*OVExecutableNetworkBaseTest.*CanSetConfigToExecNet.*)"),
+        std::regex(R"(.*OVExecutableNetworkBaseTest.*CanSetConfigToExecNetAndCheckConfigAndCheck.*)"),
         // Not supported by TEMPLATE plugin
-        R"(.*OVExecutableNetworkBaseTest.*CheckExecGraphInfo.*)",
+        std::regex(R"(.*OVExecutableNetworkBaseTest.*CheckExecGraphInfo.*)"),
         // Issue: 90539
-        R"(.*OVInferRequestIOTensorTest.InferStaticNetworkSetChangedInputTensorThrow.*)",
-        R"(.*OVInferRequestIOTensorTest.canInferAfterIOBlobReallocation.*)",
-        R"(.*VirtualPlugin.*BehaviorTests.*OVHoldersTest.*)",
+        std::regex(R"(.*OVInferRequestIOTensorTest.InferStaticNetworkSetChangedInputTensorThrow.*)"),
+        std::regex(R"(.*OVInferRequestIOTensorTest.canInferAfterIOBlobReallocation.*)"),
+        std::regex(R"(.*VirtualPlugin.*BehaviorTests.*OVHoldersTest.*)"),
         // BATCH plugin doesn't support this case
-        R"(.*LoadNetworkCreateDefaultExecGraphResult.*)",
+        std::regex(R"(.*LoadNetworkCreateDefaultExecGraphResult.*)"),
         // BATCH/TEMPLATE plugin doesn't support this case
-        R"(.*OVInferRequestPerfCountersTest.*CheckOperationInProfilingInfo.*)",
+        std::regex(R"(.*OVInferRequestPerfCountersTest.*CheckOperationInProfilingInfo.*)"),
         // requires export_model be implemented
-        R"(.*Behavior.*OVCompiledModelBaseTest.*import_from_weightless_blob.*targetDevice=(BATCH).*)",
-        R"(.*Behavior.*OVCompiledModelBaseTest.*compile_from.*_blob.*targetDevice=(BATCH).*)",
-        R"(.*Behavior.*OVCompiledModelBaseTest.*use_blob_hint.*targetDevice=(BATCH).*)",
+        std::regex(R"(.*Behavior.*OVCompiledModelBaseTest.*import_from_weightless_blob.*targetDevice=(BATCH).*)"),
+        std::regex(R"(.*Behavior.*OVCompiledModelBaseTest.*compile_from.*_blob.*targetDevice=(BATCH).*)"),
+        std::regex(R"(.*Behavior.*OVCompiledModelBaseTest.*use_blob_hint.*targetDevice=(BATCH).*)"),
         // model import is not supported
-        R"(.*OVCompiledModelBaseTest.import_from_.*)"
+        std::regex(R"(.*OVCompiledModelBaseTest.import_from_.*)")
     };
 
-    return disabled_items;
+    return patterns;
 }

src/plugins/hetero/tests/functional/skip_tests_config.cpp

@@ -9,18 +9,22 @@
 
 #include "openvino/core/core_visibility.hpp"
 
-std::vector<std::string> disabledTestPatterns() {
-    std::vector<std::string> retVector{
-        R"(.*smoke_(Multi|Auto|Hetero)_BehaviorTests.*OVPropertiesTests.*SetCorrectProperties.*)",
-        R"(.*smoke_(Multi|Auto|Hetero)_BehaviorTests.*OVPropertiesTests.*canSetPropertyAndCheckGetProperty.*)",
-        R"(.*OVInferRequestCheckTensorPrecision.*get(Input|Output|Inputs|Outputs)From.*FunctionWith(Single|Several).*type=(u4|u1|i4|boolean).*)",
-        R"(.*OVGetMetricPropsTest.*OVGetMetricPropsTest.*GetMetricAndPrintNoThrow_AVAILABLE_DEVICES.*)",
+const std::vector<std::regex>& disabled_test_patterns() {
+    const static std::vector<std::regex> patterns = {
+        std::regex(R"(.*smoke_(Multi|Auto|Hetero)_BehaviorTests.*OVPropertiesTests.*SetCorrectProperties.*)"),
+        std::regex(
+            R"(.*smoke_(Multi|Auto|Hetero)_BehaviorTests.*OVPropertiesTests.*canSetPropertyAndCheckGetProperty.*)"),
+        std::regex(
+            R"(.*OVInferRequestCheckTensorPrecision.*get(Input|Output|Inputs|Outputs)From.*FunctionWith(Single|Several).*type=(u4|u1|i4|boolean).*)"),
+        std::regex(R"(.*OVGetMetricPropsTest.*OVGetMetricPropsTest.*GetMetricAndPrintNoThrow_AVAILABLE_DEVICES.*)"),
         // CACHE_MODE property is not supported on NPU
-        R"(.*OVCompiledModelBaseTest.*import_from_.*_blob.*targetDevice=(HETERO.NPU).*)",
-        R"(.*OVCompiledModelBaseTest.*compile_from_.*_blob.*targetDevice=(HETERO.NPU).*)",
-        R"(.*OVCompiledModelBaseTest.*compile_from_cached_weightless_blob.*targetDevice=(HETERO.NPU).*)",
-        R"(.*OVCompiledModelBaseTest.*use_blob_hint_.*targetDevice=CPU.*)",
+        std::regex(R"(.*OVCompiledModelBaseTest.*import_from_.*_blob.*targetDevice=(HETERO.NPU).*)"),
+        std::regex(R"(.*OVCompiledModelBaseTest.*compile_from_.*_blob.*targetDevice=(HETERO.NPU).*)"),
+        std::regex(R"(.*OVCompiledModelBaseTest.*compile_from_cached_weightless_blob.*targetDevice=(HETERO.NPU).*)"),
+        std::regex(R"(.*OVCompiledModelBaseTest.*use_blob_hint_.*targetDevice=CPU.*)"),
         // model import is not supported
-        R"(.*OVCompiledModelBaseTest.import_from_.*)"};
-    return retVector;
+        std::regex(R"(.*OVCompiledModelBaseTest.import_from_.*)"),
+    };
+
+    return patterns;
 }