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

Moved functional tests to new API (#19488)

Browse Source 
* Moved functional tests to new API

* Renamed legacy tests

* Fixed test

* Fixed test
This commit is contained in:
Ilya Churaev 2023-09-01 06:58:03 +04:00 committed by GitHub
parent 05a24b1776
commit 7c751883fc
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 428 additions and 244 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/inference/tests/functional/core_threading.cpp
View File

@ -24,9 +24,9 @@
# endif
#endif
class CoreThreadingTests : public ::testing::Test {
class IECoreThreadingTests : public ::testing::Test {
protected:
std::string modelName = "CoreThreadingTests.xml", weightsName = "CoreThreadingTests.bin";
std::string modelName = "IECoreThreadingTests.xml", weightsName = "IECoreThreadingTests.bin";
public:
void SetUp() override {
@ -72,7 +72,7 @@ public:
};
// tested function: SetConfig
TEST_F(CoreThreadingTests, SetConfigPluginDoesNotExist) {
TEST_F(IECoreThreadingTests, SetConfigPluginDoesNotExist) {
InferenceEngine::Core ie;
std::map<std::string, std::string> localConfig = {
{CONFIG_KEY(PERF_COUNT), InferenceEngine::PluginConfigParams::YES}};
@ -88,7 +88,7 @@ TEST_F(CoreThreadingTests, SetConfigPluginDoesNotExist) {
#ifndef OPENVINO_STATIC_LIBRARY
// tested function: RegisterPlugin
TEST_F(CoreThreadingTests, RegisterPlugin) {
TEST_F(IECoreThreadingTests, RegisterPlugin) {
InferenceEngine::Core ie;
std::atomic<int> index{0};
runParallel(
@ -104,7 +104,7 @@ TEST_F(CoreThreadingTests, RegisterPlugin) {
}
// tested function: RegisterPlugins
TEST_F(CoreThreadingTests, RegisterPlugins) {
TEST_F(IECoreThreadingTests, RegisterPlugins) {
InferenceEngine::Core ie;
std::atomic<unsigned int> index{0};
@ -145,7 +145,7 @@ TEST_F(CoreThreadingTests, RegisterPlugins) {
// tested function: GetAvailableDevices, UnregisterPlugin
// TODO: some initialization (e.g. thread/dlopen) sporadically fails during such stress-test scenario
TEST_F(CoreThreadingTests, GetAvailableDevices) {
TEST_F(IECoreThreadingTests, GetAvailableDevices) {
#ifdef OV_TEST_GLIBC_VERSION_LESS_2_34
GTEST_SKIP();
#endif
@ -170,7 +170,7 @@ TEST_F(CoreThreadingTests, GetAvailableDevices) {
#if defined(ENABLE_OV_IR_FRONTEND)
// tested function: ReadNetwork, AddExtension
TEST_F(CoreThreadingTests, ReadNetwork) {
TEST_F(IECoreThreadingTests, ReadNetwork) {
InferenceEngine::Core ie;
auto network = ie.ReadNetwork(modelName, weightsName);

36
src/inference/tests/functional/local_test.cpp
View File

@ -4,13 +4,12 @@
#include <gtest/gtest.h>
#include <ie_core.hpp>
#include "ngraph/ops.hpp"
#include "openvino/op/roi_align.hpp"
#include "openvino/op/util/rnn_cell_base.hpp"
#include "openvino/runtime/core.hpp"
using namespace ::testing;
using namespace std;
using namespace InferenceEngine;
class LocaleTests : public ::testing::Test {
std::string originalLocale;
@ -18,9 +17,9 @@ class LocaleTests : public ::testing::Test {
<net name="model" version="10">
<layers>
<layer id="0" name="input" type="Parameter" version="opset1">
<data shape="1,256,200,272" element_type="f16"/>
<data shape="1,256,200,272" element_type="f32"/>
<output>
<port id="0" precision="FP16" names="input">
<port id="0" precision="FP32" names="input">
<dim>1</dim>
<dim>256</dim>
<dim>200</dim>
@ -29,9 +28,9 @@ class LocaleTests : public ::testing::Test {
</output>
</layer>
<layer id="1" name="rois" type="Parameter" version="opset1">
<data shape="1000,4" element_type="f16"/>
<data shape="1000,4" element_type="f32"/>
<output>
<port id="0" precision="FP16" names="rois">
<port id="0" precision="FP32" names="rois">
<dim>1000</dim>
<dim>4</dim>
</port>
@ -63,7 +62,7 @@ class LocaleTests : public ::testing::Test {
</port>
</input>
<output>
<port id="3" precision="FP16" names="output">
<port id="3" precision="FP32" names="output">
<dim>1000</dim>
<dim>256</dim>
<dim>7</dim>
@ -224,19 +223,17 @@ protected:
}
void testBody(bool isLSTM = false) const {
InferenceEngine::Core core;
ov::Core core;
std::string model = isLSTM ? _model_LSTM : _model;
auto blob = make_shared_blob<uint8_t>(TensorDesc(Precision::U8, {26000000}, Layout::C));
blob->allocate();
auto net = core.ReadNetwork(model, blob);
std::string model_str = isLSTM ? _model_LSTM : _model;
auto tensor = ov::Tensor(ov::element::u8, {26000000});
auto model = core.read_model(model_str, tensor);
auto funcs = net.getFunction();
for (const auto& op : funcs->get_ops()) {
for (const auto& op : model->get_ops()) {
if (!isLSTM) {
if (op->get_friendly_name() == "output") {
const auto roi = std::dynamic_pointer_cast<ngraph::op::v3::ROIAlign>(op);
const auto roi = std::dynamic_pointer_cast<ov::op::v3::ROIAlign>(op);
ASSERT_TRUE(roi);
ASSERT_EQ(roi->get_pooled_h(), 7);
ASSERT_EQ(roi->get_pooled_w(), 7);
ASSERT_EQ(roi->get_sampling_ratio(), 2);
@ -244,7 +241,8 @@ protected:
}
} else {
if (op->get_friendly_name() == "LSTMCell") {
const auto lstm_seq = std::dynamic_pointer_cast<ngraph::op::util::RNNCellBase>(op);
const auto lstm_seq = std::dynamic_pointer_cast<ov::op::util::RNNCellBase>(op);
ASSERT_TRUE(lstm_seq);
ASSERT_EQ(lstm_seq->get_clip(), 0.0f);
ASSERT_EQ(lstm_seq->get_hidden_size(), 256);
}

268
src/inference/tests/functional/matmul_sr_tests.cpp
View File

@ -4,20 +4,25 @@
#include <gtest/gtest.h>
#include <common_test_utils/ov_test_utils.hpp>
#include <map>
#include <memory>
#include <ngraph/function.hpp>
#include <ngraph/opsets/opset4.hpp>
#include <ngraph/pass/manager.hpp>
#include <string>
#include <transformations/init_node_info.hpp>
#include <transformations/smart_reshape/matmul_sr.hpp>
#include "cnn_network_ngraph_impl.hpp"
#include "common_test_utils/graph_comparator.hpp"
#include "common_test_utils/test_common.hpp"
#include "ie_common.h"
#include "openvino/op/constant.hpp"
#include "openvino/op/matmul.hpp"
#include "openvino/op/parameter.hpp"
#include "openvino/op/reshape.hpp"
#include "openvino/op/transpose.hpp"
#include "openvino/op/variadic_split.hpp"
#include "openvino/pass/manager.hpp"
#include "transformations/init_node_info.hpp"
#include "transformations/smart_reshape/matmul_sr.hpp"
using namespace testing;
using namespace InferenceEngine;
namespace {
@ -25,7 +30,7 @@ using reshape_map = std::map<std::string, std::vector<size_t>>;
struct ReshapeMatMulTestCase {
bool reshape_is_A_input;
ngraph::PartialShape A_shape, B_shape;
ov::PartialShape A_shape, B_shape;
std::vector<int64_t> reshape_pattern;
bool transpose_a, transpose_b;
reshape_map new_shapes;
@ -66,46 +71,45 @@ public:
void SetUp() override {
const auto& test_case = std::get<0>(GetParam());
std::shared_ptr<ngraph::Function> ngraph;
std::shared_ptr<ov::Model> model;
{
auto input_A = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, test_case.A_shape);
auto input_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, test_case.A_shape);
input_A->set_friendly_name("input_A");
auto input_B = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, test_case.B_shape);
auto input_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, test_case.B_shape);
input_B->set_friendly_name("input_B");
auto reshape_pattern =
std::make_shared<ngraph::opset4::Constant>(ngraph::element::i64,
ngraph::Shape{test_case.reshape_pattern.size()},
auto reshape_pattern = std::make_shared<ov::op::v0::Constant>(ov::element::i64,
ov::Shape{test_case.reshape_pattern.size()},
test_case.reshape_pattern);
reshape_pattern->set_friendly_name("reshape_pattern");
auto reshape = std::make_shared<ngraph::opset4::Reshape>(test_case.reshape_is_A_input ? input_A : input_B,
auto reshape = std::make_shared<ov::op::v1::Reshape>(test_case.reshape_is_A_input ? input_A : input_B,
reshape_pattern,
true);
reshape->set_friendly_name("reshape");
auto mat_mul = std::make_shared<ngraph::opset4::MatMul>(
auto mat_mul = std::make_shared<ov::op::v0::MatMul>(
test_case.reshape_is_A_input ? reshape->output(0) : input_A->output(0),
test_case.reshape_is_A_input ? input_B->output(0) : reshape->output(0),
test_case.transpose_a,
test_case.transpose_b);
reshape->set_friendly_name("matmul");
auto result = std::make_shared<ngraph::op::Result>(mat_mul);
ngraph::ParameterVector params = {input_A, input_B};
ngraph::ResultVector results = {result};
ngraph = std::make_shared<ngraph::Function>(results, params);
auto result = std::make_shared<ov::op::v0::Result>(mat_mul);
ov::ParameterVector params = {input_A, input_B};
ov::ResultVector results = {result};
model = std::make_shared<ov::Model>(results, params);
}
InferenceEngine::details::CNNNetworkNGraphImpl network(ngraph);
InferenceEngine::details::CNNNetworkNGraphImpl network(model);
const auto& resp = network.reshape(test_case.new_shapes, nullptr);
ASSERT_EQ(resp, StatusCode::OK);
ASSERT_EQ(resp, InferenceEngine::StatusCode::OK);
}
};
TEST_P(SmartReshapeMatMulTests, ReshapeMatMul) {}
INSTANTIATE_TEST_SUITE_P(
NGraph,
OVModel,
SmartReshapeMatMulTests,
testing::Values(
ReshapeMatMulTestCase{true, {1, 20, 30}, {30, 40}, {20, -1}, false, false, {{"input_A", {2, 20, 30}}}},
@ -120,14 +124,14 @@ INSTANTIATE_TEST_SUITE_P(
} // namespace
TEST(SmartReshapeTransposeMatMulTests, TransposeAMatMulFuse) {
std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
std::shared_ptr<ov::Model> f(nullptr), f_ref(nullptr);
{
auto data_A = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 2});
auto data_B = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 5});
auto order = ngraph::opset4::Constant::create(ngraph::element::i64, ngraph::Shape{3}, {0, 2, 1});
auto transpose = std::make_shared<ngraph::opset4::Transpose>(data_A, order);
auto matmul = std::make_shared<ngraph::opset4::MatMul>(transpose, data_B, false, false);
f = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{data_A, data_B});
auto data_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 3, 2});
auto data_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 3, 5});
auto order = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{3}, {0, 2, 1});
auto transpose = std::make_shared<ov::op::v1::Transpose>(data_A, order);
auto matmul = std::make_shared<ov::op::v0::MatMul>(transpose, data_B, false, false);
f = std::make_shared<ov::Model>(ov::NodeVector{matmul}, ov::ParameterVector{data_A, data_B});
ov::pass::Manager m;
m.register_pass<ov::pass::InitNodeInfo>();
@ -136,10 +140,10 @@ TEST(SmartReshapeTransposeMatMulTests, TransposeAMatMulFuse) {
ASSERT_NO_THROW(check_rt_info(f));
}
{
auto data_A = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 2});
auto data_B = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 5});
auto matmul = std::make_shared<ngraph::opset4::MatMul>(data_A, data_B, true, false);
f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{data_A, data_B});
auto data_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 3, 2});
auto data_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 3, 5});
auto matmul = std::make_shared<ov::op::v0::MatMul>(data_A, data_B, true, false);
f_ref = std::make_shared<ov::Model>(ov::NodeVector{matmul}, ov::ParameterVector{data_A, data_B});
}
auto res = compare_functions(f, f_ref);
@ -147,26 +151,26 @@ TEST(SmartReshapeTransposeMatMulTests, TransposeAMatMulFuse) {
}
TEST(SmartReshapeTransposeMatMulTests, TransposeBMatMulFuse) {
std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
std::shared_ptr<ov::Model> f(nullptr), f_ref(nullptr);
{
auto data_A = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 2, 3});
auto data_B = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 5, 3});
auto order = ngraph::opset4::Constant::create(ngraph::element::i64, ngraph::Shape{3}, {0, 2, 1});
auto transpose = std::make_shared<ngraph::opset4::Transpose>(data_B, order);
auto matmul = std::make_shared<ngraph::opset4::MatMul>(data_A, transpose, false, false);
f = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{data_A, data_B});
auto data_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 2, 3});
auto data_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 5, 3});
auto order = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{3}, {0, 2, 1});
auto transpose = std::make_shared<ov::op::v1::Transpose>(data_B, order);
auto matmul = std::make_shared<ov::op::v0::MatMul>(data_A, transpose, false, false);
f = std::make_shared<ov::Model>(ov::NodeVector{matmul}, ov::ParameterVector{data_A, data_B});
ngraph::pass::Manager m;
ov::pass::Manager m;
m.register_pass<ov::pass::InitNodeInfo>();
m.register_pass<ov::pass::TransposeMatMul>();
m.run_passes(f);
ASSERT_NO_THROW(check_rt_info(f));
}
{
auto data_A = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 2, 3});
auto data_B = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 5, 3});
auto matmul = std::make_shared<ngraph::opset4::MatMul>(data_A, data_B, false, true);
f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{data_A, data_B});
auto data_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 2, 3});
auto data_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 5, 3});
auto matmul = std::make_shared<ov::op::v0::MatMul>(data_A, data_B, false, true);
f_ref = std::make_shared<ov::Model>(ov::NodeVector{matmul}, ov::ParameterVector{data_A, data_B});
}
auto res = compare_functions(f, f_ref);
@ -174,26 +178,26 @@ TEST(SmartReshapeTransposeMatMulTests, TransposeBMatMulFuse) {
}
TEST(SmartReshapeTransposeMatMulTests, TransposeAMatMulWithAttrFuse) {
std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
std::shared_ptr<ov::Model> f(nullptr), f_ref(nullptr);
{
auto data_A = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 2, 3});
auto data_B = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 5});
auto order = ngraph::opset4::Constant::create(ngraph::element::i64, ngraph::Shape{3}, {0, 2, 1});
auto transpose = std::make_shared<ngraph::opset4::Transpose>(data_A, order);
auto matmul = std::make_shared<ngraph::opset4::MatMul>(transpose, data_B, true, false);
f = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{data_A, data_B});
auto data_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 2, 3});
auto data_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 3, 5});
auto order = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{3}, {0, 2, 1});
auto transpose = std::make_shared<ov::op::v1::Transpose>(data_A, order);
auto matmul = std::make_shared<ov::op::v0::MatMul>(transpose, data_B, true, false);
f = std::make_shared<ov::Model>(ov::NodeVector{matmul}, ov::ParameterVector{data_A, data_B});
ngraph::pass::Manager m;
ov::pass::Manager m;
m.register_pass<ov::pass::InitNodeInfo>();
m.register_pass<ov::pass::TransposeMatMul>();
m.run_passes(f);
ASSERT_NO_THROW(check_rt_info(f));
}
{
auto data_A = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 2, 3});
auto data_B = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 5});
auto matmul = std::make_shared<ngraph::opset4::MatMul>(data_A, data_B, false, false);
f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{data_A, data_B});
auto data_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 2, 3});
auto data_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 3, 5});
auto matmul = std::make_shared<ov::op::v0::MatMul>(data_A, data_B, false, false);
f_ref = std::make_shared<ov::Model>(ov::NodeVector{matmul}, ov::ParameterVector{data_A, data_B});
}
auto res = compare_functions(f, f_ref);
@ -201,52 +205,52 @@ TEST(SmartReshapeTransposeMatMulTests, TransposeAMatMulWithAttrFuse) {
}
TEST(SmartReshapeTransposeMatMulTests, TransposeBMatMulWithAttrFuse) {
std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
std::shared_ptr<ov::Model> f(nullptr), f_ref(nullptr);
{
auto data_A = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 2, 3});
auto data_B = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 5});
auto order = ngraph::opset4::Constant::create(ngraph::element::i64, ngraph::Shape{3}, {0, 2, 1});
auto transpose = std::make_shared<ngraph::opset4::Transpose>(data_B, order);
auto matmul = std::make_shared<ngraph::opset4::MatMul>(data_A, transpose, false, true);
f = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{data_A, data_B});
auto data_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 2, 3});
auto data_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 3, 5});
auto order = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{3}, {0, 2, 1});
auto transpose = std::make_shared<ov::op::v1::Transpose>(data_B, order);
auto matmul = std::make_shared<ov::op::v0::MatMul>(data_A, transpose, false, true);
f = std::make_shared<ov::Model>(ov::NodeVector{matmul}, ov::ParameterVector{data_A, data_B});
ngraph::pass::Manager m;
ov::pass::Manager m;
m.register_pass<ov::pass::InitNodeInfo>();
m.register_pass<ov::pass::TransposeMatMul>();
m.run_passes(f);
ASSERT_NO_THROW(check_rt_info(f));
}
{
auto data_A = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 2, 3});
auto data_B = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 5});
auto matmul = std::make_shared<ngraph::opset4::MatMul>(data_A, data_B, false, false);
f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{data_A, data_B});
auto data_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 2, 3});
auto data_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 3, 5});
auto matmul = std::make_shared<ov::op::v0::MatMul>(data_A, data_B, false, false);
f_ref = std::make_shared<ov::Model>(ov::NodeVector{matmul}, ov::ParameterVector{data_A, data_B});
}
auto res = compare_functions(f, f_ref);
ASSERT_TRUE(res.first) << res.second;
}
TEST(SmartReshapeTransposeMatMulTests, TransposeAMatMulSideAttrFuse) {
std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
std::shared_ptr<ov::Model> f(nullptr), f_ref(nullptr);
{
auto data_A = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 2, 3});
auto data_B = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 5, 3});
auto order = ngraph::opset4::Constant::create(ngraph::element::i64, ngraph::Shape{3}, {0, 2, 1});
auto transpose = std::make_shared<ngraph::opset4::Transpose>(data_A, order);
auto matmul = std::make_shared<ngraph::opset4::MatMul>(transpose, data_B, true, true);
f = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{data_A, data_B});
auto data_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 2, 3});
auto data_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 5, 3});
auto order = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{3}, {0, 2, 1});
auto transpose = std::make_shared<ov::op::v1::Transpose>(data_A, order);
auto matmul = std::make_shared<ov::op::v0::MatMul>(transpose, data_B, true, true);
f = std::make_shared<ov::Model>(ov::NodeVector{matmul}, ov::ParameterVector{data_A, data_B});
ngraph::pass::Manager m;
ov::pass::Manager m;
m.register_pass<ov::pass::InitNodeInfo>();
m.register_pass<ov::pass::TransposeMatMul>();
m.run_passes(f);
ASSERT_NO_THROW(check_rt_info(f));
}
{
auto data_A = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 2, 3});
auto data_B = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 5, 3});
auto matmul = std::make_shared<ngraph::opset4::MatMul>(data_A, data_B, false, true);
f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{data_A, data_B});
auto data_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 2, 3});
auto data_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 5, 3});
auto matmul = std::make_shared<ov::op::v0::MatMul>(data_A, data_B, false, true);
f_ref = std::make_shared<ov::Model>(ov::NodeVector{matmul}, ov::ParameterVector{data_A, data_B});
}
auto res = compare_functions(f, f_ref);
@ -254,26 +258,26 @@ TEST(SmartReshapeTransposeMatMulTests, TransposeAMatMulSideAttrFuse) {
}
TEST(SmartReshapeTransposeMatMulTests, TransposeBMatMulSideAttrFuse) {
std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
std::shared_ptr<ov::Model> f(nullptr), f_ref(nullptr);
{
auto data_A = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 2});
auto data_B = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 5});
auto order = ngraph::opset4::Constant::create(ngraph::element::i64, ngraph::Shape{3}, {0, 2, 1});
auto transpose = std::make_shared<ngraph::opset4::Transpose>(data_B, order);
auto matmul = std::make_shared<ngraph::opset4::MatMul>(data_A, transpose, true, true);
f = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{data_A, data_B});
auto data_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 3, 2});
auto data_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 3, 5});
auto order = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{3}, {0, 2, 1});
auto transpose = std::make_shared<ov::op::v1::Transpose>(data_B, order);
auto matmul = std::make_shared<ov::op::v0::MatMul>(data_A, transpose, true, true);
f = std::make_shared<ov::Model>(ov::NodeVector{matmul}, ov::ParameterVector{data_A, data_B});
ngraph::pass::Manager m;
ov::pass::Manager m;
m.register_pass<ov::pass::InitNodeInfo>();
m.register_pass<ov::pass::TransposeMatMul>();
m.run_passes(f);
ASSERT_NO_THROW(check_rt_info(f));
}
{
auto data_A = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 2});
auto data_B = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 5});
auto matmul = std::make_shared<ngraph::opset4::MatMul>(data_A, data_B, true, false);
f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{data_A, data_B});
auto data_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 3, 2});
auto data_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 3, 5});
auto matmul = std::make_shared<ov::op::v0::MatMul>(data_A, data_B, true, false);
f_ref = std::make_shared<ov::Model>(ov::NodeVector{matmul}, ov::ParameterVector{data_A, data_B});
}
auto res = compare_functions(f, f_ref);
@ -281,70 +285,70 @@ TEST(SmartReshapeTransposeMatMulTests, TransposeBMatMulSideAttrFuse) {
}
TEST(SmartReshapeTransposeMatMulTests, TransposeBothMatMulFuse) {
std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
std::shared_ptr<ov::Model> f(nullptr), f_ref(nullptr);
{
auto data_A = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 2});
auto data_B = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 5, 3});
auto order = ngraph::opset4::Constant::create(ngraph::element::i64, ngraph::Shape{3}, {0, 2, 1});
auto transpose_A = std::make_shared<ngraph::opset4::Transpose>(data_A, order);
auto transpose_B = std::make_shared<ngraph::opset4::Transpose>(data_B, order);
auto matmul = std::make_shared<ngraph::opset4::MatMul>(transpose_A, transpose_B, false, false);
f = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{data_A, data_B});
auto data_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 3, 2});
auto data_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 5, 3});
auto order = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{3}, {0, 2, 1});
auto transpose_A = std::make_shared<ov::op::v1::Transpose>(data_A, order);
auto transpose_B = std::make_shared<ov::op::v1::Transpose>(data_B, order);
auto matmul = std::make_shared<ov::op::v0::MatMul>(transpose_A, transpose_B, false, false);
f = std::make_shared<ov::Model>(ov::NodeVector{matmul}, ov::ParameterVector{data_A, data_B});
ngraph::pass::Manager m;
ov::pass::Manager m;
m.register_pass<ov::pass::InitNodeInfo>();
m.register_pass<ov::pass::TransposeMatMul>();
m.run_passes(f);
ASSERT_NO_THROW(check_rt_info(f));
}
{
auto data_A = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 2});
auto data_B = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{1, 5, 3});
auto matmul = std::make_shared<ngraph::opset4::MatMul>(data_A, data_B, true, true);
f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{data_A, data_B});
auto data_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 3, 2});
auto data_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1, 5, 3});
auto matmul = std::make_shared<ov::op::v0::MatMul>(data_A, data_B, true, true);
f_ref = std::make_shared<ov::Model>(ov::NodeVector{matmul}, ov::ParameterVector{data_A, data_B});
}
auto res = compare_functions(f, f_ref);
ASSERT_TRUE(res.first) << res.second;
}
TEST(SmartReshapeTransposeMatMulTests, TransposeBothMatMulWithAttrFuse) {
std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
std::shared_ptr<ov::Model> f(nullptr), f_ref(nullptr);
{
auto data_A = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{2, 3, 2});
auto split_A = std::make_shared<ngraph::opset4::VariadicSplit>(
auto data_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 2});
auto split_A = std::make_shared<ov::op::v1::VariadicSplit>(
data_A,
ngraph::opset4::Constant::create(ngraph::element::i64, ngraph::Shape{}, {0}),
ngraph::opset4::Constant::create(ngraph::element::i64, ngraph::Shape{2}, {1, 1}));
auto data_B = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{2, 3, 5});
auto split_B = std::make_shared<ngraph::opset4::VariadicSplit>(
ov::op::v0::Constant::create(ov::element::i64, ov::Shape{}, {0}),
ov::op::v0::Constant::create(ov::element::i64, ov::Shape{2}, {1, 1}));
auto data_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 5});
auto split_B = std::make_shared<ov::op::v1::VariadicSplit>(
data_B,
ngraph::opset4::Constant::create(ngraph::element::i64, ngraph::Shape{}, {0}),
ngraph::opset4::Constant::create(ngraph::element::i64, ngraph::Shape{2}, {1, 1}));
auto order = ngraph::opset4::Constant::create(ngraph::element::i64, ngraph::Shape{3}, {0, 2, 1});
auto transpose_A = std::make_shared<ngraph::opset4::Transpose>(split_A->output(0), order);
auto transpose_B = std::make_shared<ngraph::opset4::Transpose>(split_B->output(1), order);
auto matmul = std::make_shared<ngraph::opset4::MatMul>(transpose_A, transpose_B, false, true);
f = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{data_A, data_B});
ov::op::v0::Constant::create(ov::element::i64, ov::Shape{}, {0}),
ov::op::v0::Constant::create(ov::element::i64, ov::Shape{2}, {1, 1}));
auto order = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{3}, {0, 2, 1});
auto transpose_A = std::make_shared<ov::op::v1::Transpose>(split_A->output(0), order);
auto transpose_B = std::make_shared<ov::op::v1::Transpose>(split_B->output(1), order);
auto matmul = std::make_shared<ov::op::v0::MatMul>(transpose_A, transpose_B, false, true);
f = std::make_shared<ov::Model>(ov::NodeVector{matmul}, ov::ParameterVector{data_A, data_B});
ngraph::pass::Manager m;
ov::pass::Manager m;
m.register_pass<ov::pass::InitNodeInfo>();
m.register_pass<ov::pass::TransposeMatMul>();
m.run_passes(f);
ASSERT_NO_THROW(check_rt_info(f));
}
{
auto data_A = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{2, 3, 2});
auto split_A = std::make_shared<ngraph::opset4::VariadicSplit>(
auto data_A = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 2});
auto split_A = std::make_shared<ov::op::v1::VariadicSplit>(
data_A,
ngraph::opset4::Constant::create(ngraph::element::i64, ngraph::Shape{}, {0}),
ngraph::opset4::Constant::create(ngraph::element::i64, ngraph::Shape{2}, {1, 1}));
auto data_B = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{2, 3, 5});
auto split_B = std::make_shared<ngraph::opset4::VariadicSplit>(
ov::op::v0::Constant::create(ov::element::i64, ov::Shape{}, {0}),
ov::op::v0::Constant::create(ov::element::i64, ov::Shape{2}, {1, 1}));
auto data_B = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{2, 3, 5});
auto split_B = std::make_shared<ov::op::v1::VariadicSplit>(
data_B,
ngraph::opset4::Constant::create(ngraph::element::i64, ngraph::Shape{}, {0}),
ngraph::opset4::Constant::create(ngraph::element::i64, ngraph::Shape{2}, {1, 1}));
auto matmul = std::make_shared<ngraph::opset4::MatMul>(split_A->output(0), split_B->output(1), true, false);
f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{data_A, data_B});
ov::op::v0::Constant::create(ov::element::i64, ov::Shape{}, {0}),
ov::op::v0::Constant::create(ov::element::i64, ov::Shape{2}, {1, 1}));
auto matmul = std::make_shared<ov::op::v0::MatMul>(split_A->output(0), split_B->output(1), true, false);
f_ref = std::make_shared<ov::Model>(ov::NodeVector{matmul}, ov::ParameterVector{data_A, data_B});
}
auto res = compare_functions(f, f_ref);

182
src/inference/tests/functional/ov_core_threading.cpp Normal file
View File

@ -0,0 +1,182 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include <gtest/gtest.h>
#include <atomic>
#include <chrono>
#include <fstream>
#include <mutex>
#include <thread>
#include "common_test_utils/common_utils.hpp"
#include "common_test_utils/file_utils.hpp"
#include "common_test_utils/test_assertions.hpp"
#include "functional_test_utils/test_model/test_model.hpp"
#include "openvino/runtime/core.hpp"
#include "openvino/util/file_util.hpp"
#ifdef __GLIBC__
# include <gnu/libc-version.h>
# if __GLIBC_MINOR__ < 34
# define OV_TEST_GLIBC_VERSION_LESS_2_34
# endif
#endif
class CoreThreadingTests : public ::testing::Test {
protected:
std::string modelName = "CoreThreadingTests.xml", weightsName = "CoreThreadingTests.bin";
public:
void SetUp() override {
auto prefix = ov::test::utils::generateTestFilePrefix();
modelName = prefix + modelName;
weightsName = prefix + weightsName;
FuncTestUtils::TestModel::generateTestModel(modelName, weightsName);
}
void TearDown() override {
ov::test::utils::removeIRFiles(modelName, weightsName);
}
void runParallel(std::function<void(void)> func,
const unsigned int iterations = 100,
const unsigned int threadsNum = 8) {
std::vector<std::thread> threads(threadsNum);
for (auto& thread : threads) {
thread = std::thread([&]() {
for (unsigned int i = 0; i < iterations; ++i) {
func();
}
});
}
for (auto& thread : threads) {
if (thread.joinable())
thread.join();
}
}
void safeAddExtension(ov::Core& core) {
try {
auto extension = std::make_shared<InferenceEngine::Extension>(
ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
std::string("template_extension") + IE_BUILD_POSTFIX));
core.add_extension(extension);
} catch (const ov::Exception& ex) {
ASSERT_STR_CONTAINS(ex.what(), "name: custom_opset. Opset");
}
}
};
// tested function: SetConfig
TEST_F(CoreThreadingTests, SetConfigPluginDoesNotExist) {
ov::Core core;
runParallel(
[&]() {
core.set_property(ov::enable_profiling(true));
},
10000);
}
// TODO: CVS-68982
#ifndef OPENVINO_STATIC_LIBRARY
// tested function: RegisterPlugin
TEST_F(CoreThreadingTests, RegisterPlugin) {
ov::Core core;
std::atomic<int> index{0};
runParallel(
[&]() {
const std::string deviceName = std::to_string(index++);
core.register_plugin(ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
std::string("mock_engine") + IE_BUILD_POSTFIX),
deviceName);
core.get_versions(deviceName);
core.unload_plugin(deviceName);
},
4000);
}
// tested function: RegisterPlugins
TEST_F(CoreThreadingTests, RegisterPlugins) {
ov::Core core;
std::atomic<unsigned int> index{0};
auto getPluginXml = [&]() -> std::tuple<std::string, std::string> {
std::string indexStr = std::to_string(index++);
std::string pluginsXML = "test_plugins" + indexStr + ".xml";
std::ofstream file(pluginsXML);
file << "<ie><plugins><plugin location=\"";
file << ov::test::utils::getExecutableDirectory();
file << ov::util::FileTraits<char>::file_separator;
file << ov::util::FileTraits<char>::library_prefix();
file << "mock_engine";
file << IE_BUILD_POSTFIX;
file << ov::util::FileTraits<char>::dot_symbol;
file << ov::util::FileTraits<char>::library_ext();
file << "\" name=\"";
file << indexStr;
file << "\"></plugin></plugins></ie>";
file.flush();
file.close();
return std::tie(pluginsXML, indexStr);
};
runParallel(
[&]() {
std::string fileName, deviceName;
std::tie(fileName, deviceName) = getPluginXml();
core.register_plugins(fileName);
core.get_versions(deviceName);
ASSERT_EQ(0, std::remove(fileName.c_str()));
},
1000);
}
#endif // !OPENVINO_STATIC_LIBRARY
// tested function: get_available_devices, unload_plugin
// TODO: some initialization (e.g. thread/dlopen) sporadically fails during such stress-test scenario
TEST_F(CoreThreadingTests, GetAvailableDevices) {
#ifdef OV_TEST_GLIBC_VERSION_LESS_2_34
GTEST_SKIP();
#endif
ov::Core core;
runParallel(
[&]() {
std::vector<std::string> devices = core.get_available_devices();
// unregister all the devices
for (auto&& deviceName : devices) {
try {
core.unload_plugin(deviceName);
} catch (const ov::Exception& ex) {
// if several threads unload plugin at once, the first thread does this
// while all others will throw an exception that plugin is not registered
ASSERT_STR_CONTAINS(ex.what(), "name is not registered in the");
}
}
},
30);
}
#if defined(ENABLE_OV_IR_FRONTEND)
// tested function: read_model and add_legacy_extension
TEST_F(CoreThreadingTests, ReadModel) {
ov::Core core;
auto model = core.read_model(modelName, weightsName);
runParallel(
[&]() {
safeAddExtension(core);
(void)core.read_model(modelName, weightsName);
},
100,
12);
}
#endif // defined(ENABLE_OV_IR_FRONTEND)