Plugin tests: check Kernel

inference-engine/tests/functional/plugin/cpu/shared_tests_instances/low_precision_transformations/convolution_transformation.cpp

@@ -31,19 +31,29 @@ const std::vector<LayerTestsDefinitions::ConvolutionTransformationParam> params
         { 256ul, ngraph::Shape { 1, 1, 1, 1 }, { 0.f }, { 255.f }, { 0.f }, { 25.5f } },
         false,
         {},
-        false
+        false,
+        "jit[0-9a-z_]*FP32"
     },
     {
         {},
         false,
         { 255ul, ngraph::Shape { 1, 1, 1, 1 }, { 0.f }, { 254.f }, { -12.7f }, { 12.7f } },
-        false
+        false,
+        "jit[0-9a-z_]*FP32"
     },
     {
         { 256ul, ngraph::Shape { 1, 1, 1, 1 }, { 0.f }, { 255.f }, { 0.f }, { 25.5f } },
         false,
         { 255ul, ngraph::Shape { 1, 1, 1, 1 }, { 0.f }, { 254.f }, { -12.7f }, { 12.7f } },
-        false
+        false,
+        "jit[0-9a-z_]*I8"
+    },
+    {
+        { 256ul, ngraph::Shape { 1, 1, 1, 1 }, { 0.f }, { 255.f }, { -12.7f }, { 12.8f } },
+        true,
+        { 255ul, ngraph::Shape { 1, 1, 1, 1 }, { 0.f }, { 254.f }, { -12.7f }, { 12.7f } },
+        false,
+        "jit[0-9a-z_]*I8"
     },
     //{
     //    { 256ul, ngraph::Shape { 1, 1, 1, 1 }, { 0.f }, { 255.f }, { 1.f }, { 25.5f } },

inference-engine/tests/functional/plugin/cpu/shared_tests_instances/low_precision_transformations/mat_mul_with_constant_transformation.cpp

@@ -23,7 +23,8 @@ std::vector<MatMulWithConstantTransformationTestValues> testValues = {
         { 256ul, ngraph::Shape({}), {0.f}, {25.5f}, {0.f}, {25.5f} },
         { 32, 10 },
         std::vector<float>(32 * 10, 1.f),
-        { 256ul, ngraph::Shape({}), {-12.8f}, {12.7f}, {-12.8f}, {12.7f} }
+        { 256ul, ngraph::Shape({}), {-12.8f}, {12.7f}, {-12.8f}, {12.7f} },
+        "jit[0-9a-z_]*I8"
     }
 };
 

inference-engine/tests/functional/plugin/shared/include/low_precision_transformations/convolution_transformation.hpp

@@ -19,6 +19,7 @@ class ConvolutionTransformationParam {
     bool asymmetricQuantizationOnData;
     ngraph::builder::subgraph::FakeQuantizeOnWeights fakeQuantizeOnWeights;
     bool asymmetricQuantizationOnWeights;
+    std::string kernel;
 };
 
 typedef std::tuple<

inference-engine/tests/functional/plugin/shared/include/low_precision_transformations/mat_mul_with_constant_transformation.hpp

@@ -21,6 +21,7 @@ class MatMulWithConstantTransformationTestValues {
     ngraph::Shape weightsConstShape;
     std::vector<float> weightsConstValues;
     ngraph::builder::subgraph::FakeQuantizeOnWeights fqOnWeights;
+    std::string kernel;
 };
 
 typedef std::tuple<

inference-engine/tests/functional/plugin/shared/src/low_precision_transformations/convolution_transformation.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2020 Intel Corporation
+// Copyright (C) 2020 Intel Corporation
 // SPDX-License-Identifier: Apache-2.0
 //
 
@@ -127,6 +127,10 @@ void ConvolutionTransformation::validateNGraph() {
 
 TEST_P(ConvolutionTransformation, CompareWithRefImpl) {
     Run();
+    if (targetDevice == "CPU") {
+        std::string kernel = std::get<5>(this->GetParam()).kernel;
+        checkKernel("Convolution", kernel);
+    }
 };
 
 }  // namespace LayerTestsDefinitions

inference-engine/tests/functional/plugin/shared/src/low_precision_transformations/mat_mul_with_constant_transformation.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2020 Intel Corporation
+// Copyright (C) 2020 Intel Corporation
 // SPDX-License-Identifier: Apache-2.0
 //
 
@@ -143,6 +143,10 @@ void MatMulWithConstantTransformation::validate() {
 
 TEST_P(MatMulWithConstantTransformation, CompareWithRefImpl) {
     Run();
+    if (targetDevice == "CPU") {
+        std::string kernel = std::get<3>(this->GetParam()).kernel;
+        checkKernel("FullyConnected", kernel);
+    }
 };
 
 }  // namespace LayerTestsDefinitions

inference-engine/tests/ie_test_utils/functional_test_utils/layer_test_utils.cpp

@@ -1,7 +1,9 @@
-// Copyright (C) 2019-2020 Intel Corporation
+// Copyright (C) 2019-2020 Intel Corporation
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include <regex>
+
 #include <transformations/convert_batch_to_space.hpp>
 #include <transformations/convert_space_to_batch.hpp>
 
@@ -209,6 +211,34 @@ void LayerTestsCommon::Validate() {
     Compare(expectedOutputs, actualOutputs);
 }
 
+void LayerTestsCommon::checkKernel(std::string layerType, std::string permissibleKernel) {
+    std::vector<std::string> opNames;
+    auto perfomanceCounters = inferRequest.GetPerformanceCounts();
+    for (auto& pc : perfomanceCounters) {
+        if (pc.second.layer_type == layerType) {
+            opNames.push_back(pc.first);
+        }
+    }
+    ASSERT_TRUE(!opNames.empty())
+        << "layer with type " << layerType << " does not exist";
+
+    const std::regex expectedKernel(permissibleKernel);
+    for (auto& targetOperationName : opNames) {
+        auto targetOperationKernel = getKernel(targetOperationName);
+        EXPECT_TRUE(std::regex_search(targetOperationKernel.begin(), targetOperationKernel.end(), expectedKernel))
+            << "Unexpected kernel. Actual: \"" << targetOperationKernel << "\" Expected: \"" << permissibleKernel << "\""
+            << " (Layer type: " << layerType << ", Layer name: " << targetOperationName << ")";
+    }
+}
+
+std::string LayerTestsCommon::getKernel(std::string layerName) {
+    auto perfomanceCounters = inferRequest.GetPerformanceCounts();
+    auto it = perfomanceCounters.find(layerName);
+
+    return  it->second.exec_type;
+}
+
+
 void LayerTestsCommon::SetRefMode(RefMode mode) {
     refMode = mode;
 }

inference-engine/tests/ie_test_utils/functional_test_utils/layer_test_utils.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2019-2020 Intel Corporation
+// Copyright (C) 2019-2020 Intel Corporation
 // SPDX-License-Identifier: Apache-2.0
 //
 
@@ -60,6 +60,10 @@ class LayerTestsCommon : public CommonTestUtils::TestsCommon {
 
     virtual void SetRefMode(RefMode mode);
 
+    void checkKernel(std::string layerType, std::string permissibleKernel);
+
+    std::string getKernel(std::string layerName);
+
 protected:
     LayerTestsCommon();