[Tests] Revise unit/apptests to sync with updated interfaces

This commit revises unit/apptests to sync with updated interfaces.

Signed-off-by: Dongju Chae <dongju.chae@samsung.com>

diff --git a/include/host/libnpuhost.h b/include/host/libnpuhost.h
index 03b34b2..74cebf3 100644 (file)
--- a/include/host/libnpuhost.h
+++ b/include/host/libnpuhost.h
@@ -227,7 +227,7 @@ typedef struct {
   /** @todo add more */
 } npuConstraint;
 
-#define DEFAULT_TIMEOUT (1000)  /**< default timeout, 1000ms */
+#define DEFAULT_TIMEOUT (3000)  /**< default timeout, 3000ms */
 #define DEFAULT_PRIORITY (NPU_PRIORITY_MID)
 
 /**

diff --git a/src/core/ne-host-input-service.c b/src/core/ne-host-input-service.c
index 1cd3117..857c4ca 100644 (file)
--- a/src/core/ne-host-input-service.c
+++ b/src/core/ne-host-input-service.c
@@ -45,9 +45,6 @@
 #define MAX_THREADS (8)
 #endif
 
-/** Default issue timeout in ms */
-#define DEFAULT_TIMEOUT (1000)
-
 /** Get the host inservice element */
 #define HOST_PRIV(INPUT_SERVICE) ((host_priv_t *) INPUT_SERVICE->pdata)
 

diff --git a/tests/apptests/async_callbacks.c b/tests/apptests/async_callbacks.c
index 74f0825..27f61c4 100644 (file)
--- a/tests/apptests/async_callbacks.c
+++ b/tests/apptests/async_callbacks.c
@@ -30,10 +30,9 @@
 #define TEST_WAIT()   pthread_cond_wait(&priv.cond, &priv.mutex)
 
 typedef struct {
-  uint64_t cur_sequence;
+  uint32_t num_callbacks;
   pthread_mutex_t mutex;
   pthread_cond_t cond;
-  int result;
 } test_priv;
 
 #if defined(ENABLE_EMUL)
@@ -53,9 +52,7 @@ callback (output_buffers *output, uint64_t sequence, void *data)
 {
   TEST_LOCK();
 
-  /** as async mode is NPUASYNC_WAIT, sequnce number should be matched */
-  if (sequence != ++priv.cur_sequence)
-    priv.result = -1;
+  ++priv.num_callbacks;
 
   free (output);
 
@@ -128,8 +125,7 @@ run_inference (npudev_h dev)
   if ((err = registerNPUmodel(dev, model, &model_id)) != 0)
     goto out_free_all;
 
-  priv.cur_sequence = 0;
-  priv.result = 0;
+  priv.num_callbacks = 0;
 
   /** run NPU inference */
   for (i = 0; i < num_tests; i++) {
@@ -142,9 +138,9 @@ run_inference (npudev_h dev)
 
   /** wait until all callbacks are called */
   TEST_LOCK();
-  while (priv.cur_sequence != num_tests && priv.result != -1)
+  while (priv.num_callbacks != num_tests)
     TEST_WAIT();
-  err = priv.result;
+  err = 0;
   TEST_UNLOCK();
 
 out_unregister:

diff --git a/tests/unittests/ne_core_comm_ip_test.cpp b/tests/unittests/ne_core_comm_ip_test.cpp
index f8e01e1..d2ad8de 100644 (file)
--- a/tests/unittests/ne_core_comm_ip_test.cpp
+++ b/tests/unittests/ne_core_comm_ip_test.cpp
@@ -249,6 +249,7 @@ TEST (ne_core_ip_test_default_conf, registerNPUmodel_large_size)
   ASSERT_EQ (ret, RET_SUCCESS);
 
   set_default_val_to_meta (&meta, "DummyModel");
+#ifdef ENABLE_BUFfERING
   /* Try a huge size of memory (set SIZE_MAX to buffer_size) */
   meta.buffer_size = SIZE_MAX;
   ret = -1;
@@ -259,6 +260,7 @@ TEST (ne_core_ip_test_default_conf, registerNPUmodel_large_size)
     model = NULL;
   }
   ASSERT_NE (ret, RET_SUCCESS);
+#endif
 
   /* Try a huge size of memory (almost UINT32_MAX) */
   set_default_val_to_meta (&meta, "DummyModel");

diff --git a/tests/unittests/ne_core_handler_test.cpp b/tests/unittests/ne_core_handler_test.cpp
index c0e1eb3..103d08b 100644 (file)
--- a/tests/unittests/ne_core_handler_test.cpp
+++ b/tests/unittests/ne_core_handler_test.cpp
@@ -174,12 +174,17 @@ TEST (ne_core_handler_test, start_stop_operation)
   EXPECT_EQ (host_handle->setOpMode(NPUINPUT_HOST, true, id[1], version[1],
         test_cb, ptr[1]), 0);
 
+#ifdef ENABLE_BUFFERING
   GET_MEM()->resize_buffers(NPUBIN_META_SIZE * 2);
   buffer_ptr = host_handle->getCurrentInputBuffer(NPUASYNC_WAIT, &err);
   EXPECT_EQ (err, 0);
-  EXPECT_EQ (host_handle->validateBuffer(buffer_ptr, DEFAULT_PRIORITY,
-        get_timestamp(DEFAULT_TIMEOUT)), 0);
+#else
+  buffer_ptr = GET_MEM()->create_buffer(NPUBIN_META_SIZE * 2, &err);
+  EXPECT_EQ (err, 0);
+#endif
+  EXPECT_EQ (host_handle->validateBuffer(buffer_ptr, NPU_PRIORITY_LOW, DEFAULT_TIMEOUT), 0);
   sleep (2);
+
   /** stop the model1 */
   EXPECT_EQ (host_handle->setOpMode(NPUINPUT_STOP, true, id[1], version[1],
         test_cb, ptr[1]), 0);
@@ -238,8 +243,6 @@ TEST (ne_core_handler_test, input_buffers_data_manipulation)
   }
 
   /* case 1: no data manipulation (depth == 64) */
-  GET_MEM()->resize_buffers(2 * num_tensors * size_tensor);
-
   for (uint32_t i = 0; i < num_tensors; i++) {
     /* let's assume those tensors are 'size_tensor' apart from each other */
     meta.input_offsets[i] = 2 * i * size_tensor;
@@ -250,7 +253,12 @@ TEST (ne_core_handler_test, input_buffers_data_manipulation)
     meta.input_dims[i][3] = 64;
   }
 
+#ifdef ENABLE_BUFFERING
+  GET_MEM()->resize_buffers(2 * num_tensors * size_tensor);
   buffer_ptr = host_handle->getCurrentInputBuffer(NPUASYNC_WAIT, &err);
+#else
+  buffer_ptr = GET_MEM()->create_buffer (2 * num_tensors * size_tensor, &err);
+#endif
   EXPECT_EQ (err, 0);
   ASSERT_EQ (host_handle->feedInputBuffer (&meta, &info, &input, buffer_ptr), 0);
 
@@ -265,8 +273,6 @@ TEST (ne_core_handler_test, input_buffers_data_manipulation)
   GET_MEM()->reset_buffer(buffer_ptr);
 
   /* case 2: data manipulation (depth == 16) */
-  GET_MEM()->resize_buffers(2 * 4 * num_tensors * size_tensor);
-
   for (uint32_t i = 0; i < num_tensors; i++) {
     /* let's assume those tensors are 'size_tensor' apart from each other */
     meta.input_offsets[i] = 2 * 4 * i * size_tensor;
@@ -277,7 +283,12 @@ TEST (ne_core_handler_test, input_buffers_data_manipulation)
     meta.input_dims[i][3] = 16;
   }
 
+#ifdef ENABLE_BUFFERING
+  GET_MEM()->resize_buffers(2 * 4 * num_tensors * size_tensor);
   buffer_ptr = host_handle->getCurrentInputBuffer(NPUASYNC_WAIT, &err);
+#else
+  buffer_ptr = GET_MEM()->create_buffer (2 * 4 * num_tensors * size_tensor, &err);
+#endif
   EXPECT_EQ (err, 0);
   ASSERT_EQ (host_handle->feedInputBuffer (&meta, &info, &input, buffer_ptr), 0);
 
@@ -295,8 +306,6 @@ TEST (ne_core_handler_test, input_buffers_data_manipulation)
   GET_MEM()->reset_buffer(buffer_ptr);
 
   /* case 3: data manipulation (depth == 32) */
-  GET_MEM()->resize_buffers(2 * 2 * num_tensors * size_tensor);
-
   for (uint32_t i = 0; i < num_tensors; i++) {
     /* let's assume those tensors are 'size_tensor' apart from each other */
     meta.input_offsets[i] = 2 * 2 * i * size_tensor;
@@ -307,7 +316,12 @@ TEST (ne_core_handler_test, input_buffers_data_manipulation)
     meta.input_dims[i][3] = 32;
   }
 
+#ifdef ENABLE_BUFFERING
+  GET_MEM()->resize_buffers(2 * 2 * num_tensors * size_tensor);
   buffer_ptr = host_handle->getCurrentInputBuffer(NPUASYNC_WAIT, &err);
+#else
+  buffer_ptr = GET_MEM()->create_buffer (2 * 2 * num_tensors * size_tensor, &err);
+#endif
   EXPECT_EQ (err, 0);
   ASSERT_EQ (host_handle->feedInputBuffer (&meta, &info, &input, buffer_ptr), 0);
 
@@ -325,8 +339,6 @@ TEST (ne_core_handler_test, input_buffers_data_manipulation)
   GET_MEM()->reset_buffer(buffer_ptr);
 
   /* case 4: data manipulation (depth == 128) */
-  GET_MEM()->resize_buffers(2 * num_tensors * size_tensor);
-
   for (uint32_t i = 0; i < num_tensors; i++) {
     /* let's assume those tensors are 'size_tensor' apart from each other */
     meta.input_offsets[i] = 2 * i * size_tensor;
@@ -337,7 +349,12 @@ TEST (ne_core_handler_test, input_buffers_data_manipulation)
     meta.input_dims[i][3] = 128;
   }
 
+#ifdef ENABLE_BUFFERING
+  GET_MEM()->resize_buffers(2 * num_tensors * size_tensor);
   buffer_ptr = host_handle->getCurrentInputBuffer(NPUASYNC_WAIT, &err);
+#else
+  buffer_ptr = GET_MEM()->create_buffer (2 * num_tensors * size_tensor, &err);
+#endif
   EXPECT_EQ (err, 0);
   ASSERT_EQ (host_handle->feedInputBuffer (&meta, &info, &input, buffer_ptr), 0);
 
@@ -408,8 +425,6 @@ TEST (ne_core_handler_test, input_buffers_quantization)
   }
 
   /* case 1: no data manipulation (depth == 64) */
-  GET_MEM()->resize_buffers(2 * num_tensors * size_tensor);
-
   for (uint32_t i = 0; i < num_tensors; i++) {
     /* let's assume those tensors are 'size_tensor' apart from each other */
     meta.input_offsets[i] = 2 * i * size_tensor;
@@ -423,7 +438,12 @@ TEST (ne_core_handler_test, input_buffers_quantization)
     meta.input_quant_z[i] = 127;
   }
 
+#ifdef ENABLE_BUFFERING
+  GET_MEM()->resize_buffers(2 * num_tensors * size_tensor);
   buffer_ptr = host_handle->getCurrentInputBuffer(NPUASYNC_WAIT, &err);
+#else
+  buffer_ptr = GET_MEM()->create_buffer (2 * num_tensors * size_tensor, &err);
+#endif
   EXPECT_EQ (err, 0);
   ASSERT_EQ (host_handle->feedInputBuffer (&meta, &info, &input, buffer_ptr), 0);
 
@@ -452,8 +472,6 @@ TEST (ne_core_handler_test, input_buffers_quantization)
   GET_MEM()->reset_buffer(buffer_ptr);
 
   /* case 2: data manipulation (depth == 32) */
-  GET_MEM()->resize_buffers(2 * 2 * num_tensors * size_tensor);
-
   for (uint32_t i = 0; i < num_tensors; i++) {
     /* let's assume those tensors are 'size_tensor' apart from each other */
     meta.input_offsets[i] = 2 * 2 * i * size_tensor;
@@ -467,7 +485,12 @@ TEST (ne_core_handler_test, input_buffers_quantization)
     meta.input_quant_z[i] = 127;
   }
 
+#ifdef ENABLE_BUFFERING
+  GET_MEM()->resize_buffers(2 * 2 * num_tensors * size_tensor);
   buffer_ptr = host_handle->getCurrentInputBuffer(NPUASYNC_WAIT, &err);
+#else
+  buffer_ptr = GET_MEM()->create_buffer (2 * 2 * num_tensors * size_tensor, &err);
+#endif
   EXPECT_EQ (err, 0);
   ASSERT_EQ (host_handle->feedInputBuffer (&meta, &info, &input, buffer_ptr), 0);
 

diff --git a/tests/unittests/ne_core_inf_test.cpp b/tests/unittests/ne_core_inf_test.cpp
index 80d56d0..1c95469 100644 (file)
--- a/tests/unittests/ne_core_inf_test.cpp
+++ b/tests/unittests/ne_core_inf_test.cpp
@@ -84,9 +84,6 @@ static void destroy_model (model * model_ptr)
 void test_cb (buffer *buf, void *data)
 {
   model *model_ptr;
-  buffer *buffer_ptr;
-  int err;
-  buffer_state state;
 
   EXPECT_NE (data, nullptr);
 
@@ -97,12 +94,22 @@ void test_cb (buffer *buf, void *data)
   pthread_cond_broadcast (&cond);
   pthread_mutex_unlock (&mutex);
 
+#ifdef ENABLE_BUFFERING
+  int err;
+  buffer_state state;
+  buffer *buffer_ptr;
+
   buffer_ptr = GET_MEM()->get_next_buffer(NPUASYNC_WAIT, BUFFER_ROLE_OUTPUT, &err);
   EXPECT_EQ (err, 0);
+  EXPECT_EQ (buf, buffer_ptr);
+
   /** change to EMPTY */
   EXPECT_EQ (GET_MEM()->return_buffer(buffer_ptr), 0);
   state = buffer_get_state (buffer_ptr);
   EXPECT_EQ (state, BUFFER_STATE_EMPTY);
+#else
+  GET_MEM()->reset_buffer(buf);
+#endif
 }
 
 /**
@@ -125,14 +132,14 @@ TEST (ne_core_inf_test, validation_without_data)
   /** calling other functions without configure */
   EXPECT_LT (n4_start (SMODEL_OPS_NPU), 0);
   EXPECT_LT (n4_stop (SMODEL_OPS_NPU, STOP_PREEMPT), 0);
-  EXPECT_LT (n4_dataReady(DEFAULT_PRIORITY, get_timestamp(DEFAULT_TIMEOUT)), 0);
+  EXPECT_LT (n4_dataReady(NULL, NPU_PRIORITY_LOW, DEFAULT_TIMEOUT), 0);
 
   /** correct configuration */
   EXPECT_EQ (n4_configure (SMODEL_OPS_NPU, model_ptr, test_cb, model_ptr), 0);
 
   /** calling data ready without start */
   EXPECT_LT (n4_stop (SMODEL_OPS_NPU, STOP_PREEMPT), 0);
-  EXPECT_LT (n4_dataReady(DEFAULT_PRIORITY, get_timestamp(DEFAULT_TIMEOUT)), 0);
+  EXPECT_LT (n4_dataReady(NULL, NPU_PRIORITY_LOW, DEFAULT_TIMEOUT), 0);
   /** starting wrong device */
   EXPECT_LT (n4_start (SMODEL_OPS_END), 0);
 
@@ -187,13 +194,19 @@ TEST (ne_core_inf_test, validation_with_data)
 
   /** correct start device */
   EXPECT_EQ (n4_start (SMODEL_OPS_NPU), 0);
+#ifdef ENABLE_BUFFERING
   /** setup data */
   GET_MEM()->resize_buffers(NPUBIN_META_SIZE * 5);
   buffer_ptr = GET_MEM()->get_next_buffer(NPUASYNC_WAIT, BUFFER_ROLE_INPUT, &err);
   EXPECT_EQ (err, 0);
   EXPECT_EQ (GET_MEM()->return_buffer(buffer_ptr), 0);
   /** call n4_dataReady() here */
-  EXPECT_EQ (n4_dataReady(DEFAULT_PRIORITY, get_timestamp(DEFAULT_TIMEOUT)), 0);
+  EXPECT_EQ (n4_dataReady(NULL, NPU_PRIORITY_LOW, DEFAULT_TIMEOUT), 0);
+#else
+  buffer_ptr = GET_MEM()->create_buffer(NPUBIN_META_SIZE * 5, &err);
+  EXPECT_EQ (err, 0);
+  EXPECT_EQ (n4_dataReady(buffer_ptr, NPU_PRIORITY_LOW, DEFAULT_TIMEOUT), 0);
+#endif
   /** let the completion callback be called */
   sleep(SLEEP_DURATION);
   /** correct stopping device */
@@ -203,13 +216,20 @@ TEST (ne_core_inf_test, validation_with_data)
 
   /** correct start device */
   EXPECT_EQ (n4_start (SMODEL_OPS_NPU), 0);
+#ifdef ENABLE_BUFFERING
   /** setup data */
   GET_MEM()->resize_buffers(NPUBIN_META_SIZE * 4);
   buffer_ptr = GET_MEM()->get_next_buffer(NPUASYNC_WAIT, BUFFER_ROLE_INPUT, &err);
   EXPECT_EQ (err, 0);
   EXPECT_EQ (GET_MEM()->return_buffer(buffer_ptr), 0);
   /** call n4_dataReady() here */
-  EXPECT_EQ (n4_dataReady(DEFAULT_PRIORITY, get_timestamp(DEFAULT_TIMEOUT)), 0);
+  EXPECT_EQ (n4_dataReady(NULL, NPU_PRIORITY_LOW, DEFAULT_TIMEOUT), 0);
+#else
+  buffer_ptr = GET_MEM()->create_buffer(NPUBIN_META_SIZE * 4, &err);
+  EXPECT_EQ (err, 0);
+  EXPECT_EQ (n4_dataReady(buffer_ptr, NPU_PRIORITY_LOW, DEFAULT_TIMEOUT), 0);
+#endif
+
   /** completion callback to be called */
   sleep(SLEEP_DURATION);
   /** correct stopping device */
@@ -219,12 +239,19 @@ TEST (ne_core_inf_test, validation_with_data)
 
   /** correct start device */
   EXPECT_EQ (n4_start (SMODEL_OPS_NPU), 0);
+#ifdef ENABLE_BUFFERING
   /** setup data */
   GET_MEM()->resize_buffers(NPUBIN_META_SIZE * 3);
   buffer_ptr = GET_MEM()->get_next_buffer(NPUASYNC_WAIT, BUFFER_ROLE_INPUT, &err);
   EXPECT_EQ (GET_MEM()->return_buffer(buffer_ptr), 0);
   /** call n4_dataReady() here */
-  EXPECT_EQ (n4_dataReady(DEFAULT_PRIORITY, get_timestamp(DEFAULT_TIMEOUT)), 0);
+  EXPECT_EQ (n4_dataReady(NULL, NPU_PRIORITY_LOW, DEFAULT_TIMEOUT), 0);
+#else
+  buffer_ptr = GET_MEM()->create_buffer(NPUBIN_META_SIZE * 3, &err);
+  EXPECT_EQ (err, 0);
+  EXPECT_EQ (n4_dataReady(buffer_ptr, NPU_PRIORITY_LOW, DEFAULT_TIMEOUT), 0);
+#endif
+
   /** wait for the device to stop and completion callback to be called */
   sleep(SLEEP_DURATION);
   /** correct stopping device */
@@ -259,19 +286,27 @@ TEST (ne_core_inf_test, multiple_inputs)
 
   /** correct start device */
   EXPECT_EQ (n4_start (SMODEL_OPS_NPU), 0);
+#ifdef ENABLE_BUFFERING
   GET_MEM()->resize_buffers(NPUBIN_META_SIZE * 2);
+#endif
 
   pthread_mutex_lock (&mutex);
   callback_count = 0;
   pthread_mutex_unlock (&mutex);
 
   for (idx = 0; idx < num_callbacks; idx ++) {
+#ifdef ENABLE_BUFFERING
     /** setup data */
     buffer_ptr = GET_MEM()->get_next_buffer(NPUASYNC_WAIT, BUFFER_ROLE_INPUT, &err);
     EXPECT_EQ (err, 0);
     EXPECT_EQ (GET_MEM()->return_buffer(buffer_ptr), 0);
     /** call n4_dataReady() here */
-    EXPECT_EQ (n4_dataReady(DEFAULT_PRIORITY, get_timestamp(DEFAULT_TIMEOUT)), 0);
+    EXPECT_EQ (n4_dataReady(NULL, NPU_PRIORITY_LOW, DEFAULT_TIMEOUT), 0);
+#else
+    buffer_ptr = GET_MEM()->create_buffer(NPUBIN_META_SIZE * 2, &err);
+    EXPECT_EQ (err, 0);
+    EXPECT_EQ (n4_dataReady(buffer_ptr, NPU_PRIORITY_LOW, DEFAULT_TIMEOUT), 0);
+#endif
   }
 
   pthread_mutex_lock (&mutex);

diff --git a/tests/unittests/ne_core_mem_test.cpp b/tests/unittests/ne_core_mem_test.cpp
index 17732e9..6e486cc 100644 (file)
--- a/tests/unittests/ne_core_mem_test.cpp
+++ b/tests/unittests/ne_core_mem_test.cpp
@@ -63,6 +63,7 @@ TEST (ne_core_mem_test, register_model_internal)
   ASSERT_EQ (hwmem->size, slice_size * 7);
   ASSERT_EQ (mem->get_used_size(), slice_size * 7);
 
+#ifdef ENABLE_BUFFERING
   /* config I/O buffer size (>= 3x size for triple buffering) */
   ASSERT_EQ (mem->resize_buffers (slice_size), 0);
   ASSERT_EQ (mem->get_used_size(), slice_size * 7 + slice_size * 3);
@@ -71,6 +72,7 @@ TEST (ne_core_mem_test, register_model_internal)
   ASSERT_NE (mem->resize_buffers (slice_size * 2), 0);
   ASSERT_EQ (mem->resize_buffers (0), 0);
   ASSERT_EQ (mem->get_used_size(), slice_size * 7);
+#endif
 
   mem->dealloc (hwmem);
   ASSERT_EQ (mem->get_used_size(), 0);
@@ -115,6 +117,7 @@ TEST (ne_core_mem_test, register_model_kernel_cma)
   ASSERT_EQ (hwmem->size, slice_size * 7);
   ASSERT_EQ (mem->get_used_size(), slice_size * 7);
 
+#ifdef ENABLE_BUFFERING
   /* config I/O buffer size (>= 3x size for triple buffering) */
   ASSERT_EQ (mem->resize_buffers (slice_size), 0);
   ASSERT_EQ (mem->get_used_size(), slice_size * 7 + slice_size * 3);
@@ -122,6 +125,7 @@ TEST (ne_core_mem_test, register_model_kernel_cma)
   ASSERT_EQ (mem->get_used_size(), slice_size * 7 + (slice_size / 2) * 3);
   ASSERT_EQ (mem->resize_buffers (0), 0);
   ASSERT_EQ (mem->get_used_size(), slice_size * 7);
+#endif
 
   mem->dealloc (hwmem);
   ASSERT_EQ (mem->get_used_size(), 0);
@@ -132,6 +136,7 @@ TEST (ne_core_mem_test, register_model_kernel_cma)
   mem->init (conf->reserved_mem_size, &pool_size);
 }
 
+#ifdef ENABLE_BUFFERING
 /**
  * @brief prepare input buffer
  */
@@ -343,6 +348,7 @@ TEST (ne_core_mem_test, running_parallel)
   pthread_join (thread[1], (void **)&status);
   pthread_join (thread[2], (void **)&status);
 }
+#endif
 
 /**
  * @brief test for memory compaction
@@ -426,6 +432,7 @@ TEST (ne_core_mem_test, memory_compaction)
   mem->dealloc (hwmem[3]);
 }
 
+#ifdef ENABLE_BUFFERING
 /**
  * @brief data struct to pass mode and sync primitive to helper thread */
 typedef struct {
@@ -611,6 +618,7 @@ TEST (ne_core_mem_test, get_next_buffer_modes)
 
   pthread_mutex_destroy (&mutex1);
 }
+#endif
 
 /**
  * @brief main function for unit test