6159a5b0bc
* Generates tensor names
* Implement function helpers for Inputs/Outputs
* Fixed code style
* Share result tensor and add more tests
* Avoid not unique tensor names
* Print tensor name
* Fixed comment
* Fixed matmul transformation
* Fixed function evaluate
* Fixed typo
* Fixed interpreter backend
* Fixed comments
* Removed tensor names check
* Disabled negative tests
* Fixed NetworkContext_CNNNetwork tests
* Fixed GNA tests
* Remove reset names
* Fixed code style
* Temporary disable names generation
* Revert "Temporary disable names generation"
This reverts commit 133315a611.
* Fixed mapping generation and e2e tests
* Fixe Myriad tests
* Introduce AtomicGuard to fix possible thread issues
* Fixed comments
90 lines
2.6 KiB
C++
90 lines
2.6 KiB
C++
// Copyright (C) 2018-2021 Intel Corporation
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
//
|
|
|
|
#include <chrono>
|
|
#include <mutex>
|
|
#include <thread>
|
|
#include <vector>
|
|
|
|
#include "atomic_guard.hpp"
|
|
#include "gtest/gtest.h"
|
|
#include "ngraph/ngraph.hpp"
|
|
|
|
using namespace ngraph;
|
|
using namespace std;
|
|
|
|
TEST(threading, get_friendly_name) {
|
|
const size_t number = 20;
|
|
Shape shape{};
|
|
auto a = make_shared<op::Parameter>(element::i32, shape);
|
|
auto iconst0 = op::Constant::create(element::i32, Shape{}, {0});
|
|
auto add_a1 = make_shared<op::v1::Add>(a, iconst0);
|
|
auto add_a2 = make_shared<op::v1::Add>(add_a1, iconst0);
|
|
auto add_a3 = make_shared<op::v1::Add>(add_a2, iconst0);
|
|
auto abs_add_a3 = std::make_shared<op::Abs>(add_a3);
|
|
|
|
auto b = make_shared<op::Parameter>(element::i32, shape);
|
|
auto add_b1 = make_shared<op::v1::Add>(b, iconst0);
|
|
auto add_b2 = make_shared<op::v1::Add>(add_b1, iconst0);
|
|
auto abs_add_b2 = std::make_shared<op::Abs>(add_b2);
|
|
|
|
auto graph = make_shared<op::v1::Multiply>(abs_add_a3, abs_add_b2);
|
|
|
|
auto f = std::make_shared<Function>(ngraph::NodeVector{graph}, ParameterVector{a, b});
|
|
|
|
const auto compare_names = [](const std::vector<std::string>& names) {
|
|
static std::unordered_set<std::string> ref_names;
|
|
static std::once_flag flag;
|
|
std::call_once(flag, [&]() {
|
|
for (const auto& name : names)
|
|
ref_names.insert(name);
|
|
});
|
|
for (const auto& name : names) {
|
|
ASSERT_TRUE(ref_names.count(name));
|
|
}
|
|
};
|
|
|
|
const auto get_friendly_name = [&](const std::shared_ptr<ngraph::Function>& f) {
|
|
std::vector<std::string> names;
|
|
for (const auto& op : f->get_ops()) {
|
|
names.emplace_back(op->get_friendly_name());
|
|
}
|
|
compare_names(names);
|
|
};
|
|
|
|
std::vector<std::thread> threads(number);
|
|
|
|
for (auto&& thread : threads)
|
|
thread = std::thread(get_friendly_name, f);
|
|
|
|
for (auto&& th : threads) {
|
|
th.join();
|
|
}
|
|
}
|
|
|
|
TEST(threading, check_atomic_guard) {
|
|
std::atomic_bool test_val{false};
|
|
int result = 2;
|
|
const auto& thread1_fun = [&]() {
|
|
ov::AtomicGuard lock(test_val);
|
|
std::chrono::milliseconds ms{2000};
|
|
std::this_thread::sleep_for(ms);
|
|
result += 3;
|
|
};
|
|
const auto& thread2_fun = [&]() {
|
|
std::chrono::milliseconds ms{500};
|
|
std::this_thread::sleep_for(ms);
|
|
ov::AtomicGuard lock(test_val);
|
|
result *= 3;
|
|
};
|
|
std::vector<std::thread> threads(2);
|
|
threads[0] = std::thread(thread1_fun);
|
|
threads[1] = std::thread(thread2_fun);
|
|
|
|
for (auto&& th : threads) {
|
|
th.join();
|
|
}
|
|
ASSERT_EQ(result, 15);
|
|
}
|