Signed-off-by: Ciprian Barbu <[email protected]>
---
The testcases are based almost entirely on the odp_example.
There are no alloc tests and I added a test case for odp_schedule_wait_time.
The major differencs between the odp_example and this cunit is the partition
into testcases, the odp_example calls every test case from one big function.
I had to work some magic in order to be able to pass arguments to test cases,
I hope is not too hard to follow.
configure.ac | 1 +
test/cunit/Makefile.am | 2 +
test/cunit/schedule/Makefile.am | 10 +
test/cunit/schedule/odp_schedule_test.c | 844 ++++++++++++++++++++++++++
test/cunit/schedule/odp_schedule_testsuites.c | 35 ++
test/cunit/schedule/odp_schedule_testsuites.h | 21 +
6 files changed, 913 insertions(+)
create mode 100644 test/cunit/schedule/Makefile.am
create mode 100644 test/cunit/schedule/odp_schedule_test.c
create mode 100644 test/cunit/schedule/odp_schedule_testsuites.c
create mode 100644 test/cunit/schedule/odp_schedule_testsuites.h
diff --git a/configure.ac b/configure.ac
index fcd7279..a47db72 100644
--- a/configure.ac
+++ b/configure.ac
@@ -173,6 +173,7 @@ AC_CONFIG_FILES([Makefile
test/Makefile
test/api_test/Makefile
test/cunit/Makefile
+ test/cunit/schedule/Makefile
pkgconfig/libodp.pc])
AC_SEARCH_LIBS([timer_create],[rt posix4])
diff --git a/test/cunit/Makefile.am b/test/cunit/Makefile.am
index 439e134..b6033ee 100644
--- a/test/cunit/Makefile.am
+++ b/test/cunit/Makefile.am
@@ -3,6 +3,8 @@ include $(top_srcdir)/test/Makefile.inc
AM_CFLAGS += -I$(CUNIT_PATH)/include
AM_LDFLAGS += -L$(CUNIT_PATH)/lib -static -lcunit
+SUBDIRS = schedule
+
if ODP_CUNIT_ENABLED
TESTS = ${bin_PROGRAMS}
check_PROGRAMS = ${bin_PROGRAMS}
diff --git a/test/cunit/schedule/Makefile.am b/test/cunit/schedule/Makefile.am
new file mode 100644
index 0000000..ad68b03
--- /dev/null
+++ b/test/cunit/schedule/Makefile.am
@@ -0,0 +1,10 @@
+include $(top_srcdir)/test/Makefile.inc
+
+if ODP_CUNIT_ENABLED
+bin_PROGRAMS = odp_schedule_test
+odp_schedule_test_LDFLAGS = $(AM_LDFLAGS) -L$(CUNIT_PATH)/lib -static -lcunit
+odp_schedule_test_CFLAGS = $(AM_CFLAGS) -I$(CUNIT_PATH)/include
+endif
+
+dist_odp_schedule_test_SOURCES = odp_schedule_test.c \
+ odp_schedule_testsuites.c
diff --git a/test/cunit/schedule/odp_schedule_test.c
b/test/cunit/schedule/odp_schedule_test.c
new file mode 100644
index 0000000..fa67f6e
--- /dev/null
+++ b/test/cunit/schedule/odp_schedule_test.c
@@ -0,0 +1,844 @@
+/* Copyright (c) 2014, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "odp_schedule_testsuites.h"
+#include <odph_linux.h>
+
+#define MAX_WORKERS 32 /**< Max worker threads */
+#define MSG_POOL_SIZE (4*1024*1024)
+#define QUEUES_PER_PRIO 64 /**< Queue per priority */
+#define QUEUE_ROUNDS (512*1024) /**< Queue test rounds */
+#define MULTI_BUFS_MAX 4 /**< Buffer burst size */
+#define BUF_SIZE 64
+
+#define SCHED_MSG "Test_buff_FOR_simple_schedule"
+
+/** Test arguments */
+typedef struct {
+ int core_count; /**< Core count */
+ int proc_mode; /**< Process mode */
+} test_args_t;
+
+typedef int (*test_case_routine)(const char *, int, odp_buffer_pool_t,
+ int, odp_barrier_t *);
+
+/** Scheduler test case arguments */
+typedef struct {
+ char name[64]; /**< test case name */
+ int prio;
+ test_case_routine func;
+} test_case_args_t;
+
+/** Test global variables */
+typedef struct {
+ odp_barrier_t barrier;/**< @private Barrier for test synchronisation */
+ test_args_t test_args;/**< @private Test case function and arguments */
+} test_globals_t;
+
+static void execute_parallel(void *(*func) (void *), test_case_args_t *);
+static int num_workers;
+
+/**
+ * @internal CUnit test case for verifying functionality of
+ * schedule_wait_time
+ */
+static void schedule_wait_time(void)
+{
+ uint64_t wait_time;
+
+ wait_time = odp_schedule_wait_time(0);
+ CU_ASSERT(wait_time > 0);
+ CU_PASS("schedule_wait_time(0)");
+
+ wait_time = odp_schedule_wait_time(1);
+ CU_ASSERT(wait_time > 0);
+ CU_PASS("schedule_wait_time(1)");
+
+ wait_time = odp_schedule_wait_time((uint64_t)-1LL);
+ CU_ASSERT(wait_time > 0);
+ CU_PASS("schedule_wait_time(MAX_LONG_INT)");
+}
+
+/**
+ * @internal Clear all scheduled queues. Retry to be sure that all
+ * buffers have been scheduled.
+ */
+static void clear_sched_queues(void)
+{
+ odp_buffer_t buf;
+
+ while (1) {
+ buf = odp_schedule(NULL, ODP_SCHED_NO_WAIT);
+
+ if (buf == ODP_BUFFER_INVALID)
+ break;
+
+ odp_buffer_free(buf);
+ }
+}
+
+/**
+ * @internal Create multiple queues from a pool of buffers
+ *
+ * @param thr Thread
+ * @param msg_pool Buffer pool
+ * @param prio Queue priority
+ *
+ * @return 0 if successful
+ */
+static int create_queues(int thr, odp_buffer_pool_t msg_pool, int prio)
+{
+ char name[] = "sched_XX_YY";
+ odp_buffer_t buf;
+ odp_queue_t queue;
+ int i;
+
+ name[6] = '0' + prio/10;
+ name[7] = '0' + prio - 10*(prio/10);
+
+ /* Alloc and enqueue a buffer per queue */
+ for (i = 0; i < QUEUES_PER_PRIO; i++) {
+ name[9] = '0' + i/10;
+ name[10] = '0' + i - 10*(i/10);
+
+ queue = odp_queue_lookup(name);
+
+ if (queue == ODP_QUEUE_INVALID) {
+ ODP_ERR(" [%i] Queue %s lookup failed.\n", thr, name);
+ return -1;
+ }
+
+ buf = odp_buffer_alloc(msg_pool);
+
+ if (!odp_buffer_is_valid(buf)) {
+ ODP_ERR(" [%i] msg_pool alloc failed\n", thr);
+ return -1;
+ }
+
+ if (odp_queue_enq(queue, buf)) {
+ ODP_ERR(" [%i] Queue enqueue failed.\n", thr);
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * @internal Create a single queue from a pool of buffers
+ *
+ * @param thr Thread
+ * @param msg_pool Buffer pool
+ * @param prio Queue priority
+ *
+ * @return 0 if successful
+ */
+static int create_queue(int thr, odp_buffer_pool_t msg_pool, int prio)
+{
+ char name[] = "sched_XX_00";
+ odp_buffer_t buf;
+ odp_queue_t queue;
+
+ buf = odp_buffer_alloc(msg_pool);
+
+ if (!odp_buffer_is_valid(buf)) {
+ ODP_ERR(" [%i] msg_pool alloc failed\n", thr);
+ return -1;
+ }
+
+ name[6] = '0' + prio/10;
+ name[7] = '0' + prio - 10*(prio/10);
+
+ queue = odp_queue_lookup(name);
+
+ if (queue == ODP_QUEUE_INVALID) {
+ ODP_ERR(" [%i] Queue %s lookup failed.\n", thr, name);
+ return -1;
+ }
+
+ if (odp_queue_enq(queue, buf)) {
+ ODP_ERR(" [%i] Queue enqueue failed.\n", thr);
+ return -1;
+ }
+
+ return 0;
+}
+
+/**
+ * @internal Test scheduling of a single queue - with odp_schedule_one()
+ *
+ * Enqueue a buffer to the shared queue. Schedule and enqueue the received
+ * buffer back into the queue.
+ *
+ * @param str Test case name string
+ * @param thr Thread
+ * @param msg_pool Buffer pool
+ * @param prio Priority
+ * @param barrier Barrier
+ *
+ * @return 0 if successful
+ */
+static int test_schedule_one_single(const char *str, int thr,
+ odp_buffer_pool_t msg_pool,
+ int prio, odp_barrier_t *barrier)
+{
+ odp_buffer_t buf;
+ odp_queue_t queue;
+ uint64_t t1, t2, cycles, ns;
+ uint32_t i;
+ uint32_t tot = 0;
+
+ if (create_queue(thr, msg_pool, prio)) {
+ CU_FAIL_FATAL("lookup queue");
+ return -1;
+ }
+
+ t1 = odp_time_get_cycles();
+
+ for (i = 0; i < QUEUE_ROUNDS; i++) {
+ buf = odp_schedule_one(&queue, ODP_SCHED_WAIT);
+
+ if (odp_queue_enq(queue, buf)) {
+ ODP_ERR(" [%i] Queue enqueue failed.\n", thr);
+ return -1;
+ }
+ }
+
+ if (odp_queue_sched_type(queue) == ODP_SCHED_SYNC_ATOMIC)
+ odp_schedule_release_atomic();
+
+ t2 = odp_time_get_cycles();
+ cycles = odp_time_diff_cycles(t1, t2);
+ ns = odp_time_cycles_to_ns(cycles);
+ tot = i;
+
+ odp_barrier_sync(barrier);
+ clear_sched_queues();
+
+ cycles = cycles/tot;
+ ns = ns/tot;
+
+ printf(" [%i] %s enq+deq %"PRIu64" cycles, %"PRIu64" ns\n",
+ thr, str, cycles, ns);
+
+ return 0;
+}
+
+/**
+ * @internal Test scheduling of multiple queues - with odp_schedule_one()
+ *
+ * Enqueue a buffer to each queue. Schedule and enqueue the received
+ * buffer back into the queue it came from.
+ *
+ * @param str Test case name string
+ * @param thr Thread
+ * @param msg_pool Buffer pool
+ * @param prio Priority
+ * @param barrier Barrier
+ *
+ * @return 0 if successful
+ */
+static int test_schedule_one_many(const char *str, int thr,
+ odp_buffer_pool_t msg_pool,
+ int prio, odp_barrier_t *barrier)
+{
+ odp_buffer_t buf;
+ odp_queue_t queue;
+ uint64_t t1 = 0;
+ uint64_t t2 = 0;
+ uint64_t cycles, ns;
+ uint32_t i;
+ uint32_t tot = 0;
+
+ if (create_queues(thr, msg_pool, prio))
+ return -1;
+
+ /* Start sched-enq loop */
+ t1 = odp_time_get_cycles();
+
+ for (i = 0; i < QUEUE_ROUNDS; i++) {
+ buf = odp_schedule_one(&queue, ODP_SCHED_WAIT);
+
+ if (odp_queue_enq(queue, buf)) {
+ ODP_ERR(" [%i] Queue enqueue failed.\n", thr);
+ return -1;
+ }
+ }
+
+ if (odp_queue_sched_type(queue) == ODP_SCHED_SYNC_ATOMIC)
+ odp_schedule_release_atomic();
+
+ t2 = odp_time_get_cycles();
+ cycles = odp_time_diff_cycles(t1, t2);
+ ns = odp_time_cycles_to_ns(cycles);
+ tot = i;
+
+ odp_barrier_sync(barrier);
+ clear_sched_queues();
+
+ cycles = cycles/tot;
+ ns = ns/tot;
+
+ printf(" [%i] %s enq+deq %"PRIu64" cycles, %"PRIu64" ns\n",
+ thr, str, cycles, ns);
+
+ return 0;
+}
+
+/**
+ * @internal Test scheduling of a single queue - with odp_schedule()
+ *
+ * Enqueue a buffer to the shared queue. Schedule and enqueue the received
+ * buffer back into the queue.
+ *
+ * @param str Test case name string
+ * @param thr Thread
+ * @param msg_pool Buffer pool
+ * @param prio Priority
+ * @param barrier Barrier
+ *
+ * @return 0 if successful
+ */
+static int test_schedule_single(const char *str, int thr,
+ odp_buffer_pool_t msg_pool,
+ int prio, odp_barrier_t *barrier)
+{
+ odp_buffer_t buf;
+ odp_queue_t queue;
+ uint64_t t1, t2, cycles, ns;
+ uint32_t i;
+ uint32_t tot = 0;
+
+ if (create_queue(thr, msg_pool, prio))
+ return -1;
+
+ t1 = odp_time_get_cycles();
+
+ for (i = 0; i < QUEUE_ROUNDS; i++) {
+ buf = odp_schedule(&queue, ODP_SCHED_WAIT);
+
+ if (odp_queue_enq(queue, buf)) {
+ ODP_ERR(" [%i] Queue enqueue failed.\n", thr);
+ return -1;
+ }
+ }
+
+ /* Clear possible locally stored buffers */
+ odp_schedule_pause();
+
+ tot = i;
+
+ while (1) {
+ buf = odp_schedule(&queue, ODP_SCHED_NO_WAIT);
+
+ if (buf == ODP_BUFFER_INVALID)
+ break;
+
+ tot++;
+
+ if (odp_queue_enq(queue, buf)) {
+ ODP_ERR(" [%i] Queue enqueue failed.\n", thr);
+ return -1;
+ }
+ }
+
+ odp_schedule_resume();
+
+ t2 = odp_time_get_cycles();
+ cycles = odp_time_diff_cycles(t1, t2);
+ ns = odp_time_cycles_to_ns(cycles);
+
+ odp_barrier_sync(barrier);
+ clear_sched_queues();
+
+ cycles = cycles/tot;
+ ns = ns/tot;
+
+ printf(" [%i] %s enq+deq %"PRIu64" cycles, %"PRIu64" ns\n",
+ thr, str, cycles, ns);
+
+ return 0;
+}
+
+/**
+ * @internal Test scheduling of multiple queues - with odp_schedule()
+ *
+ * Enqueue a buffer to each queue. Schedule and enqueue the received
+ * buffer back into the queue it came from.
+ *
+ * @param str Test case name string
+ * @param thr Thread
+ * @param msg_pool Buffer pool
+ * @param prio Priority
+ * @param barrier Barrier
+ *
+ * @return 0 if successful
+ */
+static int test_schedule_many(const char *str, int thr,
+ odp_buffer_pool_t msg_pool,
+ int prio, odp_barrier_t *barrier)
+{
+ odp_buffer_t buf;
+ odp_queue_t queue;
+ uint64_t t1 = 0;
+ uint64_t t2 = 0;
+ uint64_t cycles, ns;
+ uint32_t i;
+ uint32_t tot = 0;
+
+ if (create_queues(thr, msg_pool, prio))
+ return -1;
+
+ /* Start sched-enq loop */
+ t1 = odp_time_get_cycles();
+
+ for (i = 0; i < QUEUE_ROUNDS; i++) {
+ buf = odp_schedule(&queue, ODP_SCHED_WAIT);
+
+ if (odp_queue_enq(queue, buf)) {
+ ODP_ERR(" [%i] Queue enqueue failed.\n", thr);
+ return -1;
+ }
+ }
+
+ /* Clear possible locally stored buffers */
+ odp_schedule_pause();
+
+ tot = i;
+
+ while (1) {
+ buf = odp_schedule(&queue, ODP_SCHED_NO_WAIT);
+
+ if (buf == ODP_BUFFER_INVALID)
+ break;
+
+ tot++;
+
+ if (odp_queue_enq(queue, buf)) {
+ ODP_ERR(" [%i] Queue enqueue failed.\n", thr);
+ return -1;
+ }
+ }
+
+ odp_schedule_resume();
+
+ t2 = odp_time_get_cycles();
+ cycles = odp_time_diff_cycles(t1, t2);
+ ns = odp_time_cycles_to_ns(cycles);
+
+ odp_barrier_sync(barrier);
+ clear_sched_queues();
+
+ cycles = cycles/tot;
+ ns = ns/tot;
+
+ printf(" [%i] %s enq+deq %"PRIu64" cycles, %"PRIu64" ns\n",
+ thr, str, cycles, ns);
+
+ return 0;
+}
+
+/**
+ * @internal Test scheduling of multiple queues with multi_sched and multi_enq
+ *
+ * @param str Test case name string
+ * @param thr Thread
+ * @param msg_pool Buffer pool
+ * @param prio Priority
+ * @param barrier Barrier
+ *
+ * @return 0 if successful
+ */
+static int test_schedule_multi(const char *str, int thr,
+ odp_buffer_pool_t msg_pool,
+ int prio, odp_barrier_t *barrier)
+{
+ odp_buffer_t buf[MULTI_BUFS_MAX];
+ odp_queue_t queue;
+ uint64_t t1 = 0;
+ uint64_t t2 = 0;
+ uint64_t cycles, ns;
+ int i, j;
+ int num;
+ uint32_t tot = 0;
+ char name[] = "sched_XX_YY";
+
+ name[6] = '0' + prio/10;
+ name[7] = '0' + prio - 10*(prio/10);
+
+ /* Alloc and enqueue a buffer per queue */
+ for (i = 0; i < QUEUES_PER_PRIO; i++) {
+ name[9] = '0' + i/10;
+ name[10] = '0' + i - 10*(i/10);
+
+ queue = odp_queue_lookup(name);
+
+ if (queue == ODP_QUEUE_INVALID) {
+ ODP_ERR(" [%i] Queue %s lookup failed.\n", thr, name);
+ return -1;
+ }
+
+ for (j = 0; j < MULTI_BUFS_MAX; j++) {
+ buf[j] = odp_buffer_alloc(msg_pool);
+
+ if (!odp_buffer_is_valid(buf[j])) {
+ ODP_ERR(" [%i] msg_pool alloc failed\n", thr);
+ return -1;
+ }
+ }
+
+ if (odp_queue_enq_multi(queue, buf, MULTI_BUFS_MAX)) {
+ ODP_ERR(" [%i] Queue enqueue failed.\n", thr);
+ return -1;
+ }
+ }
+
+ /* Start sched-enq loop */
+ t1 = odp_time_get_cycles();
+
+ for (i = 0; i < QUEUE_ROUNDS; i++) {
+ num = odp_schedule_multi(&queue, ODP_SCHED_WAIT, buf,
+ MULTI_BUFS_MAX);
+
+ tot += num;
+
+ if (odp_queue_enq_multi(queue, buf, num)) {
+ ODP_ERR(" [%i] Queue enqueue failed.\n", thr);
+ return -1;
+ }
+ }
+
+ /* Clear possible locally stored buffers */
+ odp_schedule_pause();
+
+ while (1) {
+ num = odp_schedule_multi(&queue, ODP_SCHED_NO_WAIT, buf,
+ MULTI_BUFS_MAX);
+
+ if (num == 0)
+ break;
+
+ tot += num;
+
+ if (odp_queue_enq_multi(queue, buf, num)) {
+ ODP_ERR(" [%i] Queue enqueue failed.\n", thr);
+ return -1;
+ }
+ }
+
+ odp_schedule_resume();
+
+
+ t2 = odp_time_get_cycles();
+ cycles = odp_time_diff_cycles(t1, t2);
+ ns = odp_time_cycles_to_ns(cycles);
+
+ odp_barrier_sync(barrier);
+ clear_sched_queues();
+
+ if (tot) {
+ cycles = cycles/tot;
+ ns = ns/tot;
+ } else {
+ cycles = 0;
+ ns = 0;
+ }
+
+ printf(" [%i] %s enq+deq %"PRIu64" cycles, %"PRIu64" ns\n",
+ thr, str, cycles, ns);
+
+ return 0;
+}
+
+/**
+ * Template function for running the scheduler tests.
+ * The main reason for having this function is that CUnit does not offer a way
+ * to pass arguments to a testcase function.
+ * The other reason is that there are common steps for all testcases.
+ */
+static void *exec_template(void *arg)
+{
+ odp_buffer_pool_t msg_pool;
+ odp_shm_t shm;
+ test_globals_t *globals;
+ odp_barrier_t *barrier;
+ test_case_args_t *args = (test_case_args_t*) arg;
+
+ shm = odp_shm_lookup("test_globals");
+ globals = odp_shm_addr(shm);
+
+ CU_ASSERT(globals != NULL);
+
+ barrier = &globals->barrier;
+
+ /*
+ * Sync before start
+ */
+ odp_barrier_sync(barrier);
+
+ /*
+ * Find the buffer pool
+ */
+ msg_pool = odp_buffer_pool_lookup("msg_pool");
+
+ CU_ASSERT(msg_pool != ODP_BUFFER_POOL_INVALID);
+
+ odp_barrier_sync(barrier);
+
+ /*
+ * Now run the testcase routine passing the arguments
+ */
+ args->func(args->name, odp_thread_id(), msg_pool,
+ args->prio, barrier);
+
+ return arg;
+}
+
+/* Low prio */
+
+static void schedule_one_single_lo(void)
+{
+ test_case_args_t args;
+ snprintf(args.name, sizeof(args.name), "sched_one_s_lo");
+ args.prio = ODP_SCHED_PRIO_LOWEST;
+ args.func = test_schedule_one_single;
+ execute_parallel(exec_template, &args);
+}
+
+static void schedule_single_lo(void)
+{
+ test_case_args_t args;
+ snprintf(args.name, sizeof(args.name), "sched_____s_lo");
+ args.prio = ODP_SCHED_PRIO_LOWEST;
+ args.func = test_schedule_single;
+ execute_parallel(exec_template, &args);
+}
+
+static void schedule_one_many_lo(void)
+{
+ test_case_args_t args;
+ snprintf(args.name, sizeof(args.name), "sched_one_m_lo");
+ args.prio = ODP_SCHED_PRIO_LOWEST;
+ args.func = test_schedule_one_many;
+ execute_parallel(exec_template, &args);
+}
+
+static void schedule_many_lo(void)
+{
+ test_case_args_t args;
+ snprintf(args.name, sizeof(args.name), "sched_____m_lo");
+ args.prio = ODP_SCHED_PRIO_LOWEST;
+ args.func = test_schedule_many;
+ execute_parallel(exec_template, &args);
+}
+
+static void schedule_multi_lo(void)
+{
+ test_case_args_t args;
+ snprintf(args.name, sizeof(args.name), "sched_____m_lo");
+ args.prio = ODP_SCHED_PRIO_LOWEST;
+ args.func = test_schedule_multi;
+ execute_parallel(exec_template, &args);
+}
+
+/* High prio */
+
+static void schedule_one_single_hi(void)
+{
+ test_case_args_t args;
+ snprintf(args.name, sizeof(args.name), "sched_one_s_hi");
+ args.prio = ODP_SCHED_PRIO_HIGHEST;
+ args.func = test_schedule_single;
+ execute_parallel(exec_template, &args);
+}
+
+static void schedule_single_hi(void)
+{
+ test_case_args_t args;
+ snprintf(args.name, sizeof(args.name), "sched_____s_hi");
+ args.prio = ODP_SCHED_PRIO_HIGHEST;
+ args.func = test_schedule_single;
+ execute_parallel(exec_template, &args);
+}
+
+static void schedule_one_many_hi(void)
+{
+ test_case_args_t args;
+ snprintf(args.name, sizeof(args.name), "sched_one_m_hi");
+ args.prio = ODP_SCHED_PRIO_HIGHEST;
+ args.func = test_schedule_one_many;
+ execute_parallel(exec_template, &args);
+}
+
+static void schedule_many_hi(void)
+{
+ test_case_args_t args;
+ snprintf(args.name, sizeof(args.name), "sched_____m_hi");
+ args.prio = ODP_SCHED_PRIO_HIGHEST;
+ args.func = test_schedule_many;
+ execute_parallel(exec_template, &args);
+}
+
+static void schedule_multi_hi(void)
+{
+ test_case_args_t args;
+ snprintf(args.name, sizeof(args.name), "sched_multi_hi");
+ args.prio = ODP_SCHED_PRIO_HIGHEST;
+ args.func = test_schedule_multi;
+ execute_parallel(exec_template, &args);
+}
+
+static void execute_parallel(void *(*start_routine) (void *),
+ test_case_args_t *test_case_args)
+{
+ odph_linux_pthread_t thread_tbl[MAX_WORKERS];
+ int first_core;
+
+ memset(thread_tbl, 0, sizeof(thread_tbl));
+
+ /*
+ * By default core #0 runs Linux kernel background tasks.
+ * Start mapping thread from core #1
+ */
+ first_core = 1;
+
+ if (odp_sys_core_count() == 1)
+ first_core = 0;
+
+ odph_linux_pthread_create(thread_tbl, num_workers, first_core,
+ start_routine, test_case_args);
+
+ /* Wait for worker threads to terminate */
+ odph_linux_pthread_join(thread_tbl, num_workers);
+}
+
+static odp_buffer_pool_t test_odp_buffer_pool_init(void)
+{
+ void *pool_base;
+ odp_shm_t shm;
+ odp_buffer_pool_t pool;
+
+ shm = odp_shm_reserve("msg_pool",
+ MSG_POOL_SIZE, ODP_CACHE_LINE_SIZE, 0);
+
+ pool_base = odp_shm_addr(shm);
+
+ if (NULL == pool_base) {
+ printf("Shared memory reserve failed.\n");
+ return -1;
+ }
+
+ pool = odp_buffer_pool_create("msg_pool", pool_base, MSG_POOL_SIZE,
+ BUF_SIZE, ODP_CACHE_LINE_SIZE,
+ ODP_BUFFER_TYPE_RAW);
+
+ if (ODP_BUFFER_POOL_INVALID == pool) {
+ printf("Pool create failed.\n");
+ return -1;
+ }
+ return pool;
+}
+
+int schedule_test_init(void)
+{
+ test_args_t args;
+ odp_shm_t shm;
+ test_globals_t *globals;
+ int i, j;
+ int prios;
+
+ if (0 != odp_init_global(NULL, NULL)) {
+ printf("odp_init_global fail.\n");
+ return -1;
+ }
+ if (0 != odp_init_local()) {
+ printf("odp_init_local fail.\n");
+ return -1;
+ }
+ if (ODP_BUFFER_POOL_INVALID == test_odp_buffer_pool_init()) {
+ printf("test_odp_buffer_pool_init fail.\n");
+ return -1;
+ }
+
+ /* A worker thread per core */
+ num_workers = odp_sys_core_count();
+
+ if (args.core_count)
+ num_workers = args.core_count;
+
+ /* force to max core count */
+ if (num_workers > MAX_WORKERS)
+ num_workers = MAX_WORKERS;
+ shm = odp_shm_reserve("test_globals",
+ sizeof(test_globals_t), ODP_CACHE_LINE_SIZE, 0);
+
+ globals = odp_shm_addr(shm);
+
+ if (globals == NULL) {
+ ODP_ERR("Shared memory reserve failed.\n");
+ return -1;
+ }
+
+ memset(globals, 0, sizeof(test_globals_t));
+
+ /* Barrier to sync test case execution */
+ odp_barrier_init_count(&globals->barrier, num_workers);
+
+ prios = odp_schedule_num_prio();
+
+ for (i = 0; i < prios; i++) {
+ odp_queue_param_t param;
+ odp_queue_t queue;
+ char name[] = "sched_XX_YY";
+
+ if (i != ODP_SCHED_PRIO_HIGHEST &&
+ i != ODP_SCHED_PRIO_LOWEST)
+ continue;
+
+ name[6] = '0' + i/10;
+ name[7] = '0' + i - 10*(i/10);
+
+ param.sched.prio = i;
+ param.sched.sync = ODP_SCHED_SYNC_ATOMIC;
+ param.sched.group = ODP_SCHED_GROUP_DEFAULT;
+
+ for (j = 0; j < QUEUES_PER_PRIO; j++) {
+ name[9] = '0' + j/10;
+ name[10] = '0' + j - 10*(j/10);
+
+ queue = odp_queue_create(name, ODP_QUEUE_TYPE_SCHED,
+ ¶m);
+
+ if (queue == ODP_QUEUE_INVALID) {
+ ODP_ERR("Schedule queue create failed.\n");
+ return -1;
+ }
+ }
+ }
+ return 0;
+}
+
+int schedule_test_finalize(void)
+{
+ odp_term_local();
+ odp_term_global();
+ return 0;
+}
+
+struct CU_TestInfo schedule_tests[] = {
+ _CU_TEST_INFO(schedule_wait_time),
+ _CU_TEST_INFO(schedule_one_single_lo),
+ _CU_TEST_INFO(schedule_single_lo),
+ _CU_TEST_INFO(schedule_one_many_lo),
+ _CU_TEST_INFO(schedule_many_lo),
+ _CU_TEST_INFO(schedule_multi_lo),
+ _CU_TEST_INFO(schedule_one_single_hi),
+ _CU_TEST_INFO(schedule_single_hi),
+ _CU_TEST_INFO(schedule_one_many_hi),
+ _CU_TEST_INFO(schedule_many_hi),
+ _CU_TEST_INFO(schedule_multi_hi),
+ CU_TEST_INFO_NULL,
+};
diff --git a/test/cunit/schedule/odp_schedule_testsuites.c
b/test/cunit/schedule/odp_schedule_testsuites.c
new file mode 100644
index 0000000..1053069
--- /dev/null
+++ b/test/cunit/schedule/odp_schedule_testsuites.c
@@ -0,0 +1,35 @@
+/* Copyright (c) 2014, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "odp_schedule_testsuites.h"
+
+static CU_SuiteInfo suites[] = {
+ {
+ "Scheduler tests" ,
+ schedule_test_init,
+ schedule_test_finalize,
+ NULL,
+ NULL,
+ schedule_tests
+ },
+ CU_SUITE_INFO_NULL,
+};
+
+int main(void)
+{
+ /* initialize the CUnit test registry */
+ if (CUE_SUCCESS != CU_initialize_registry())
+ return CU_get_error();
+
+ /* register suites */
+ CU_register_suites(suites);
+ /* Run all tests using the CUnit Basic interface */
+ CU_basic_set_mode(CU_BRM_VERBOSE);
+ CU_basic_run_tests();
+ CU_cleanup_registry();
+
+ return CU_get_error();
+}
diff --git a/test/cunit/schedule/odp_schedule_testsuites.h
b/test/cunit/schedule/odp_schedule_testsuites.h
new file mode 100644
index 0000000..67a2a69
--- /dev/null
+++ b/test/cunit/schedule/odp_schedule_testsuites.h
@@ -0,0 +1,21 @@
+/* Copyright (c) 2014, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#ifndef ODP_SCHEDULE_TESTSUITES_H_
+#define ODP_SCHEDULE_TESTSUITES_H_
+
+#include "odp.h"
+#include <CUnit/Basic.h>
+
+/* Helper macro for CU_TestInfo initialization */
+#define _CU_TEST_INFO(test_func) {#test_func, test_func}
+
+extern struct CU_TestInfo schedule_tests[];
+
+extern int schedule_test_init(void);
+extern int schedule_test_finalize(void);
+
+#endif /* ODP_SCHEDULE_TESTSUITES_H_ */
--
1.8.3.2
_______________________________________________
lng-odp mailing list
[email protected]
http://lists.linaro.org/mailman/listinfo/lng-odp
