inference-engine/tests/unit/inference_engine_tests/cpp_interfaces/task_tests.cpp

   1 // Copyright (C) 2018-2019 Intel Corporation
   2 // SPDX-License-Identifier: Apache-2.0
   3 //
   4
   5 #include <gtest/gtest.h>
   6 #include <gmock/gmock-spec-builders.h>
   7 #include <thread>
   8
   9 #include <ie_common.h>
  10 #include <details/ie_exception.hpp>
  11 #include <cpp_interfaces/ie_task.hpp>
  12 #include <cpp_interfaces/ie_task_synchronizer.hpp>
  13 #include "task_tests_utils.hpp"
  14
  15
  16 using namespace ::testing;
  17 using namespace std;
  18 using namespace InferenceEngine;
  19 using namespace InferenceEngine::details;
  20
  21
  22 class TaskTests : public ::testing::Test {
  23 protected:
  24     Task::Ptr _task = std::make_shared<Task>();
  25 };
  26
  27 TEST_F(TaskTests, canRunWithTaskSync) {
  28     TaskSynchronizer::Ptr taskSynchronizer = std::make_shared<TaskSynchronizer>();
  29     ASSERT_NO_THROW(_task->runWithSynchronizer(taskSynchronizer));
  30     ASSERT_EQ(_task->getStatus(), Task::TS_DONE);
  31 }
  32
  33 TEST_F(TaskTests, canRunWithTaskSyncAndWait) {
  34     TaskSynchronizer::Ptr taskSynchronizer = std::make_shared<TaskSynchronizer>();
  35     ASSERT_NO_THROW(_task->runWithSynchronizer(taskSynchronizer));
  36     Task::Status status = _task->wait(-1);
  37     ASSERT_EQ(status, Task::TS_DONE);
  38 }
  39
  40 // TODO: CVS-11695
  41 TEST_F(TaskTests, DISABLED_returnBusyStatusWhenStartTaskWhichIsRunning) {
  42     TaskSynchronizer::Ptr taskSynchronizer = std::make_shared<TaskSynchronizer>();
  43     std::vector<Task::Status> statuses;
  44     std::vector<MetaThread::Ptr> metaThreads;
  45     // otherwise push_back to the vector won't be thread-safe
  46     statuses.reserve(MAX_NUMBER_OF_TASKS_IN_QUEUE);
  47     _task->occupy();
  48
  49     for (int i = 0; i < MAX_NUMBER_OF_TASKS_IN_QUEUE; i++) {
  50         metaThreads.push_back(make_shared<MetaThread>([&]() {
  51             statuses.push_back(_task->runWithSynchronizer(taskSynchronizer));
  52         }));
  53     }
  54
  55     for (auto &metaThread : metaThreads) metaThread->join();
  56     for (auto &status : statuses) ASSERT_EQ(Task::Status::TS_BUSY, status) << "Start task never return busy status";
  57 }
  58
  59 TEST_F(TaskTests, canSyncNThreadsUsingTaskSync) {
  60     TaskSynchronizer::Ptr taskSynchronizer = std::make_shared<TaskSynchronizer>();
  61     int sharedVar = 0;
  62     size_t THREAD_NUMBER = MAX_NUMBER_OF_TASKS_IN_QUEUE;
  63     size_t NUM_INTERNAL_ITERATIONS = 5000;
  64     std::vector<Task::Status> statuses;
  65     std::vector<MetaThread::Ptr> metaThreads;
  66     // otherwise push_back to the vector won't be thread-safe
  67     statuses.reserve(THREAD_NUMBER);
  68
  69     for (int i = 0; i < THREAD_NUMBER; i++) {
  70         metaThreads.push_back(make_shared<MetaThread>([&]() {
  71             auto status = Task([&]() {
  72                 for (int k = 0; k < NUM_INTERNAL_ITERATIONS; k++) sharedVar++;
  73             }).runWithSynchronizer(taskSynchronizer);
  74             statuses.push_back(status);
  75         }));
  76     }
  77
  78     for (auto &metaThread : metaThreads) metaThread->join();
  79     for (auto &status : statuses) ASSERT_NE(Task::Status::TS_BUSY, status);
  80     ASSERT_EQ(sharedVar, THREAD_NUMBER * NUM_INTERNAL_ITERATIONS);
  81 }