tests/unittests/ne_core_inf_test.cc

   1 /**
   2  * Proprietary
   3  * Copyright (C) 2019 Samsung Electronics
   4  * Copyright (C) 2019 Parichay Kapoor <pk.kapoor@samsung.com>
   5  * Copyright (C) 2019 Dongju Chae <dongju.chae@samsung.com>
   6  */
   7 /**
   8  * @file ne_core_inf_test.cc
   9  * @date 12 Aug 2019
  10  * @brief UnitTests to test functions in inference engine for NPU Engine
  11  * @author Parichay Kapoor <pk.kapoor@samsung.com>
  12  * @author Dongju Chae <dongju.chae@samsung.com>
  13  * @bug No known bugs except for NYI items
  14  */
  15
  16 #include <ne-inf.h>
  17 #include "ne_unittest_utils.h"
  18
  19 /**
  20  * @brief test invokeInputService ()
  21  */
  22 TEST (ne_core_inf_test, invoke)
  23 {
  24   std::unique_ptr<DriverAPI> api;
  25   api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
  26
  27   /** create dummy model & buffer */
  28   std::unique_ptr<Model> model (new Model (new HWmemDevice));
  29   model->setDriverAPI (api.get());
  30   EXPECT_EQ (model->alloc (4096), 0);
  31
  32   std::unique_ptr<Buffer> buffer (new Buffer (new HWmemDevice));
  33   buffer->setDriverAPI (api.get());
  34   EXPECT_EQ (buffer->alloc (4096), 0);
  35
  36   /** dummy segt */
  37   std::unique_ptr<SegmentTable> segt (new SegmentTable (new HWmemDevice));
  38   segt->setDriverAPI (api.get());
  39   EXPECT_EQ (segt->alloc (), 0);
  40
  41   EXPECT_EQ (InferenceEngine::invokeInputService (
  42         api.get(), NPUINPUT_HOST, 0, model.get(), buffer.get()), 0);
  43   EXPECT_EQ (InferenceEngine::invokeInputService (
  44         api.get(), NPUINPUT_HOST, 1, model.get(), segt.get()), 0);
  45
  46   usleep (TEST_SLEEP_MS);
  47 }
  48
  49 /**
  50  * @brief test invokeInputService () with TRIV2
  51  */
  52 TEST (ne_core_inf_test, invoke_triv2)
  53 {
  54   std::unique_ptr<DriverAPI> api;
  55   api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
  56
  57   /** create dummy model & segt */
  58   std::unique_ptr<Model> model (new Model (new HWmemDevice));
  59   model->setDriverAPI (api.get());
  60   EXPECT_EQ (model->alloc (4096), 0);
  61
  62   std::unique_ptr<SegmentTable> segt (new SegmentTable (new HWmemDevice));
  63   segt->setDriverAPI (api.get());
  64   EXPECT_EQ (segt->alloc (), 0);
  65
  66   EXPECT_EQ (InferenceEngine::invokeInputService (
  67         api.get(), NPUINPUT_HOST, 2, model.get(), segt.get()), 0);
  68   EXPECT_EQ (InferenceEngine::invokeInputService (
  69         api.get(), NPUINPUT_HW_RECURRING, 3, model.get(), segt.get()), 0);
  70
  71   usleep (TEST_SLEEP_MS);
  72 }
  73
  74 /**
  75  * @brief test invokeInputService () with error handling
  76  */
  77 TEST (ne_core_inf_test, invoke_opmode_n)
  78 {
  79   std::unique_ptr<DriverAPI> api;
  80   api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
  81
  82   /** create dummy model & buffer */
  83   std::unique_ptr<Model> model (new Model (new HWmemDevice));
  84   model->setDriverAPI (api.get());
  85   EXPECT_EQ (model->alloc (4096), 0);
  86
  87   std::unique_ptr<Buffer> buffer (new Buffer (new HWmemDevice));
  88   buffer->setDriverAPI (api.get());
  89   EXPECT_EQ (buffer->alloc (4096), 0);
  90
  91   std::unique_ptr<SegmentTable> segt (new SegmentTable (new HWmemDevice));
  92   segt->setDriverAPI (api.get());
  93   EXPECT_EQ (segt->alloc (), 0);
  94
  95   /** unsupported opmode */
  96   EXPECT_NE (InferenceEngine::invokeInputService (
  97         api.get(), NPUINPUT_STOP, 0, model.get(), buffer.get()), 0);
  98   EXPECT_NE (InferenceEngine::invokeInputService (
  99         api.get(), NPUINPUT_INTERNAL_CAM, 0, model.get(), buffer.get()), 0);
 100   EXPECT_NE (InferenceEngine::invokeInputService (
 101         api.get(), NPUINPUT_I2S_MIC, 0, model.get(), buffer.get()), 0);
 102
 103   EXPECT_NE (InferenceEngine::invokeInputService (
 104         api.get(), NPUINPUT_STOP, 0, model.get(), segt.get()), 0);
 105   EXPECT_NE (InferenceEngine::invokeInputService (
 106         api.get(), NPUINPUT_INTERNAL_CAM, 0, model.get(), segt.get()), 0);
 107   EXPECT_NE (InferenceEngine::invokeInputService (
 108         api.get(), NPUINPUT_I2S_MIC, 0, model.get(), segt.get()), 0);
 109
 110   /** HW_RECURRING works only with segment table */
 111   EXPECT_NE (InferenceEngine::invokeInputService (
 112         api.get(), NPUINPUT_HW_RECURRING, 0, model.get(), buffer.get()), 0);
 113
 114   usleep (TEST_SLEEP_MS);
 115 }
 116
 117 /**
 118  * @brief test invokeInputService () with error handling
 119  */
 120 TEST (ne_core_inf_test, invoke_args_n)
 121 {
 122   std::unique_ptr<DriverAPI> api;
 123   api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
 124
 125   /** create dummy model & buffer */
 126   std::unique_ptr<Model> model (new Model (new HWmemDevice));
 127   model->setDriverAPI (api.get());
 128   EXPECT_EQ (model->alloc (4096), 0);
 129
 130   std::unique_ptr<Buffer> buffer (new Buffer (new HWmemDevice));
 131   buffer->setDriverAPI (api.get());
 132   EXPECT_EQ (buffer->alloc (4096), 0);
 133
 134   std::unique_ptr<SegmentTable> segt (new SegmentTable (new HWmemDevice));
 135   segt->setDriverAPI (api.get());
 136   EXPECT_EQ (segt->alloc (), 0);
 137
 138   /** invalid args (api should be valid) */
 139   EXPECT_NE (InferenceEngine::invokeInputService (
 140         nullptr, NPUINPUT_HOST, 0, nullptr, (Buffer *) nullptr), 0);
 141   EXPECT_NE (InferenceEngine::invokeInputService (
 142         nullptr, NPUINPUT_HOST, 0, model.get(), (Buffer *) nullptr), 0);
 143   EXPECT_NE (InferenceEngine::invokeInputService (
 144         nullptr, NPUINPUT_HOST, 0, nullptr, buffer.get()), 0);
 145   EXPECT_NE (InferenceEngine::invokeInputService (
 146         nullptr, NPUINPUT_HOST, 0, model.get(), buffer.get()), 0);
 147
 148   EXPECT_NE (InferenceEngine::invokeInputService (
 149         nullptr, NPUINPUT_HOST, 0, nullptr, (SegmentTable *) nullptr), 0);
 150   EXPECT_NE (InferenceEngine::invokeInputService (
 151         nullptr, NPUINPUT_HOST, 0, model.get(), (SegmentTable *) nullptr), 0);
 152   EXPECT_NE (InferenceEngine::invokeInputService (
 153         nullptr, NPUINPUT_HOST, 0, nullptr, segt.get()), 0);
 154   EXPECT_NE (InferenceEngine::invokeInputService (
 155         nullptr, NPUINPUT_HOST, 0, model.get(), segt.get()), 0);
 156 }
 157
 158 /**
 159  * @brief test StopRequest ()
 160  */
 161 TEST (ne_core_inf_test, stop)
 162 {
 163   std::unique_ptr<DriverAPI> api;
 164   api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
 165
 166   /** create dummy model & buffer */
 167   std::unique_ptr<Model> model (new Model (new HWmemDevice));
 168   model->setDriverAPI (api.get());
 169   EXPECT_EQ (model->alloc (4096), 0);
 170
 171   std::unique_ptr<Buffer> buffer (new Buffer (new HWmemDevice));
 172   buffer->setDriverAPI (api.get());
 173   EXPECT_EQ (buffer->alloc (4096), 0);
 174
 175   int max_called = 16;  /** enough num to have pending requests */
 176   int num_called = 0;
 177   std::condition_variable cv;
 178   std::mutex m;
 179
 180   auto callback = std::bind (test_callback_sleep, &num_called, &m, &cv);
 181   for (int i = 0; i < max_called; i++)
 182     EXPECT_EQ (InferenceEngine::invokeInputService (
 183         api.get(), NPUINPUT_HOST, i, model.get(), buffer.get(), callback), 0);
 184
 185   EXPECT_EQ (InferenceEngine::stopRequest (NPUINPUT_HOST, max_called - 1), 0);
 186   max_called--;
 187
 188   wait_callbacks (num_called, max_called, m, cv);
 189   EXPECT_EQ (num_called, max_called);
 190 }
 191
 192 /**
 193  * @brief test StopRequest () with error handling
 194  */
 195 TEST (ne_core_inf_test, stop_opmode_n)
 196 {
 197   EXPECT_NE (InferenceEngine::stopRequest (NPUINPUT_STOP, 0), 0);
 198   EXPECT_NE (InferenceEngine::stopRequest (NPUINPUT_INTERNAL_CAM, 0), 0);
 199   EXPECT_NE (InferenceEngine::stopRequest (NPUINPUT_I2S_MIC, 0), 0);
 200 }
 201
 202 /**
 203  * @brief test StopRequest () with error handling
 204  */
 205 TEST (ne_core_inf_test, stop_not_started_n)
 206 {
 207   std::unique_ptr<DriverAPI> api;
 208   api = DriverAPI::createDriverAPI (NPUCOND_TRIV2_CONN_SOCIP, 0);
 209
 210   /** create dummy model & buffer */
 211   std::unique_ptr<Model> model (new Model (new HWmemDevice));
 212   model->setDriverAPI (api.get());
 213   EXPECT_EQ (model->alloc (4096), 0);
 214
 215   std::unique_ptr<Buffer> buffer (new Buffer (new HWmemDevice));
 216   buffer->setDriverAPI (api.get());
 217   EXPECT_EQ (buffer->alloc (4096), 0);
 218
 219   EXPECT_EQ (InferenceEngine::invokeInputService (
 220         api.get(), NPUINPUT_HOST, 0, model.get(), buffer.get()), 0);
 221   EXPECT_NE (InferenceEngine::stopRequest (NPUINPUT_HOST, 1), 0);
 222   EXPECT_NE (InferenceEngine::stopRequest (NPUINPUT_HOST, 2), 0);
 223   EXPECT_NE (InferenceEngine::stopRequest (NPUINPUT_HOST, 3), 0);
 224
 225   usleep (TEST_SLEEP_MS);
 226
 227   /** already handled */
 228   EXPECT_NE (InferenceEngine::stopRequest (NPUINPUT_HOST, 0), 0);
 229 }
 230
 231 /**
 232  * @brief main function for unit test
 233  */
 234 int
 235 main (int argc, char **argv)
 236 {
 237   return start_gtest (argc, argv);
 238 }