On Mon, Dec 08, 2014 at 11:49:46PM +0100, Ola Liljedahl wrote:
> Signed-off-by: Ola Liljedahl <[email protected]>
> ---
> (This document/code contribution attached is provided under the terms of
> agreement LES-LTM-21309)
> A new cunit test program test/validation/odp_timer.c for the updated timer
> API.
>
> test/validation/.gitignore | 1 +
> test/validation/Makefile.am | 4 +-
> test/validation/odp_timer.c | 336
> ++++++++++++++++++++++++++++++++++++++++++++
> 3 files changed, 340 insertions(+), 1 deletion(-)
> create mode 100644 test/validation/odp_timer.c
>
> diff --git a/test/validation/.gitignore b/test/validation/.gitignore
> index 37e2594..586def0 100644
> --- a/test/validation/.gitignore
> +++ b/test/validation/.gitignore
> @@ -4,3 +4,4 @@ odp_init
> odp_queue
> odp_crypto
> odp_shm
> +odp_timer
> diff --git a/test/validation/Makefile.am b/test/validation/Makefile.am
> index 8547085..043bf4c 100644
> --- a/test/validation/Makefile.am
> +++ b/test/validation/Makefile.am
> @@ -6,13 +6,14 @@ AM_LDFLAGS += -static
> if ODP_CUNIT_ENABLED
> TESTS = ${bin_PROGRAMS}
> check_PROGRAMS = ${bin_PROGRAMS}
> -bin_PROGRAMS = odp_init odp_queue odp_crypto odp_shm
> +bin_PROGRAMS = odp_init odp_queue odp_crypto odp_shm odp_timer
> odp_init_LDFLAGS = $(AM_LDFLAGS)
> odp_queue_LDFLAGS = $(AM_LDFLAGS)
> odp_crypto_CFLAGS = $(AM_CFLAGS) -I$(srcdir)/crypto
> odp_crypto_LDFLAGS = $(AM_LDFLAGS)
> odp_shm_CFLAGS = $(AM_CFLAGS)
> odp_shm_LDFLAGS = $(AM_LDFLAGS)
> +odp_timer_LDFLAGS = $(AM_LDFLAGS)
> endif
>
> dist_odp_init_SOURCES = odp_init.c
> @@ -22,3 +23,4 @@ dist_odp_crypto_SOURCES =
> crypto/odp_crypto_test_async_inp.c \
> crypto/odp_crypto_test_rng.c \
> odp_crypto.c common/odp_cunit_common.c
> dist_odp_shm_SOURCES = odp_shm.c common/odp_cunit_common.c
> +dist_odp_timer_SOURCES = odp_timer.c common/odp_cunit_common.c
> diff --git a/test/validation/odp_timer.c b/test/validation/odp_timer.c
> new file mode 100644
> index 0000000..4b6b872
> --- /dev/null
> +++ b/test/validation/odp_timer.c
> @@ -0,0 +1,336 @@
> +/* Copyright (c) 2014, Linaro Limited
> + * All rights reserved.
> + *
> + * SPDX-License-Identifier: BSD-3-Clause
> + */
> +
> +/**
> + * @file
> + */
> +
> +#include <assert.h>
> +#include <unistd.h>
> +#include <odp.h>
> +#include <odp_timer.h>
> +#include <odph_linux.h>
> +#include <odph_chksum.h>
> +#include "odp_cunit_common.h"
> +
> +/** @private Timeout range in milliseconds (ms) */
> +#define RANGE_MS 2000
> +
> +/** @private Number of timers per thread */
> +#define NTIMERS 2000
> +
> +/** @private Timeout pool size per thread */
> +#define TMO_POOL_SIZE (512 * NTIMERS)
> +
> +/** @private Barrier for thread synchronisation */
> +static odp_barrier_t test_barrier;
> +
> +/** @private Timeout buffer pool handle used by all threads */
> +static odp_buffer_pool_t tbp;
> +
> +/** @private Timer pool handle used by all threads */
> +static odp_timer_pool_t tp;
> +
> +/** @private min() function */
> +static int min(int a, int b)
> +{
> + return a < b ? a : b;
> +}
> +
> +/* @private Timer helper structure */
> +struct test_timer {
> + odp_timer_t tim; /* Timer handle */
> + odp_buffer_t buf; /* Timeout buffer */
> + odp_buffer_t buf2; /* Copy of buffer handle */
> + uint64_t tick; /* Expiration tick or ODP_TICK_INVALID */
> +};
> +
> +/* @private Handle a received (timeout) buffer */
> +static void handle_tmo(odp_buffer_t buf, bool stale, uint64_t prev_tick)
> +{
> + odp_timer_t tim = ODP_TIMER_INVALID;
> + uint64_t tick = ODP_TICK_INVALID;
> + struct test_timer *ttp = NULL;
> +
> + /* Use assert() for correctness check of test program itself */
> + assert(buf != ODP_BUFFER_INVALID);
> + if (!odp_timer_tmo_metadata(buf, &tim, &tick, (void **)&ttp)) {
> + /* Not a default timeout buffer */
> + CU_FAIL("Unexpected buffer type received");
> + return;
> + }
> +
> + if (tim == ODP_TIMER_INVALID)
> + CU_FAIL("odp_timer_tmo_metadata() invalid timer");
> + if (tick == ODP_TICK_INVALID)
> + CU_FAIL("odp_timer_tmo_metadata() invalid tick");
> + if (ttp == NULL)
> + CU_FAIL("odp_timer_tmo_metadata() null user ptr");
> +
> + if (ttp->buf2 != buf)
> + CU_FAIL("odp_timer_tmo_metadata() wrong user ptr");
> + if (ttp->tim != tim)
> + CU_FAIL("odp_timer_tmo_metadata() wrong timer");
> + if (stale) {
> + /* Stale timeout => timer must have invalid tick */
> + if (ttp->tick != ODP_TICK_INVALID)
> + CU_FAIL("Stale timeout for active timer");
> + } else {
> + /* Fresh timeout => timer must have matching tick */
> + if (ttp->tick != tick)
> + CU_FAIL("odp_timer_tmo_metadata() wrong tick");
> + /* Check that timeout was delivered 'timely' */
> + if (tick > odp_timer_current_tick(tp))
> + CU_FAIL("Timeout delivered too early");
> + if (tick < prev_tick)
> + CU_FAIL("Timeout delivered too late");
> + }
> +
> + /* Use assert() for correctness check of test program itself */
> + assert(ttp->buf == ODP_BUFFER_INVALID);
> + ttp->buf = buf;
> +}
> +
> +/* @private Worker thread entrypoint which performs timer
> alloc/set/cancel/free
> + * tests */
> +static void *worker_entrypoint(void *arg)
> +{
> + int thr = odp_thread_id();
> + uint32_t i;
> + unsigned seed = thr;
> + (void)arg;
> +
> + odp_queue_t queue = odp_queue_create("timer_queue",
> + ODP_QUEUE_TYPE_POLL,
> + NULL);
> + if (queue == ODP_QUEUE_INVALID)
> + CU_FAIL_FATAL("Queue create failed");
> +
> + struct test_timer *tt = malloc(sizeof(struct test_timer) * NTIMERS);
allocate the memory from odp shm mem to share between different worker threads
> + if (tt == NULL)
> + perror("malloc"), abort();
> +
> + /* Prepare all timers */
> + for (i = 0; i < NTIMERS; i++) {
> + tt[i].tim = odp_timer_alloc(tp, queue, &tt[i]);
> + if (tt[i].tim == ODP_TIMER_INVALID)
> + CU_FAIL_FATAL("Failed to allocate timer");
> + tt[i].buf = odp_buffer_alloc(tbp);
> + if (tt[i].buf == ODP_BUFFER_INVALID)
> + CU_FAIL_FATAL("Failed to allocate timeout buffer");
> + tt[i].buf2 = tt[i].buf;
> + tt[i].tick = ODP_TICK_INVALID;
> + }
> +
> + odp_barrier_wait(&test_barrier);
> +
> + /* Initial set all timers with a random expiration time */
> + uint32_t nset = 0;
> + for (i = 0; i < NTIMERS; i++) {
> + uint64_t tck = odp_timer_current_tick(tp) + 1 +
> + odp_timer_ns_to_tick(tp,
> + (rand_r(&seed) % RANGE_MS)
> + * 1000000ULL);
> + tt[i].tick = odp_timer_set_abs(tt[i].tim, tck, &tt[i].buf);
> + uint64_t rc = tt[i].tick;
> + if (rc == ODP_TICK_TOOEARLY ||
> + rc == ODP_TICK_TOOLATE ||
> + rc == ODP_TICK_INVALID) {
> + CU_FAIL("Failed to set timer");
> + }
> + nset++;
> + }
> +
> + /* Step through wall time, 1ms at a time and check for expired timers */
> + uint32_t nrcv = 0;
> + uint32_t nreset = 0;
> + uint32_t ncancel = 0;
> + uint32_t ntoolate = 0;
> + uint32_t ms;
> + uint64_t prev_tick = odp_timer_current_tick(tp);
> + for (ms = 0; ms < 7 * RANGE_MS / 10; ms++) {
> + odp_buffer_t buf;
> + while ((buf = odp_queue_deq(queue)) != ODP_BUFFER_INVALID) {
> + handle_tmo(buf, false, prev_tick - 1);
> + nrcv++;
> + }
> + prev_tick = odp_timer_current_tick(tp);
> + i = rand_r(&seed) % NTIMERS;
> + if (tt[i].buf == ODP_BUFFER_INVALID &&
> + (rand_r(&seed) % 2 == 0)) {
> + /* Timer active, cancel it */
> + tt[i].tick = odp_timer_cancel(tt[i].tim, &tt[i].buf);
> + if (tt[i].buf == ODP_BUFFER_INVALID) {
> + /* Cancel failed, timer already expired */
> + ntoolate++;
> + }
> + ncancel++;
> + } else {
> + if (tt[i].buf != ODP_BUFFER_INVALID)
> + /* Timer inactive => set */
> + nset++;
> + else
> + /* Timer active => reset */
> + nreset++;
> + uint64_t tck = 1 + odp_timer_ns_to_tick(tp,
> + (rand_r(&seed) % RANGE_MS) * 1000000ULL);
> + tt[i].tick = odp_timer_set_rel(tt[i].tim, tck,
> + &tt[i].buf);
> + uint64_t rc = tt[i].tick;
> + if (rc == ODP_TICK_TOOEARLY ||
> + rc == ODP_TICK_TOOLATE) {
> + CU_FAIL("Failed to set timer
> (tooearly/toolate)");
> + } else if (rc == ODP_TICK_INVALID) {
> + /* Reset failed, timer already expired */
> + ntoolate++;
> + }
> + }
> + if (usleep(1000/*1ms*/) < 0)
> + perror("usleep"), abort();
> + }
> +
> + /* Free (including cancel) all timers */
> + uint32_t nstale = 0;
> + for (i = 0; i < NTIMERS; i++) {
> + tt[i].tick = odp_timer_free(tt[i].tim, &tt[i].buf);
> + if (tt[i].buf == ODP_BUFFER_INVALID)
> + /* Cancel/free too late, timer already expired and
> + * timoeut buffer enqueued */
> + nstale++;
> + }
> +
> + printf("Thread %u: %u timers set\n", thr, nset);
> + printf("Thread %u: %u timers reset\n", thr, nreset);
> + printf("Thread %u: %u timers cancelled\n", thr, ncancel);
> + printf("Thread %u: %u timers reset/cancelled too late\n",
> + thr, ntoolate);
> + printf("Thread %u: %u timeouts received\n", thr, nrcv);
> + printf("Thread %u: %u stale timeout(s) after odp_timer_free()\n",
> + thr, nstale);
> +
> + /* Delay some more to ensure timeouts for expired timers can be
> + * received */
> + usleep(1000/*1ms*/);
> + while (nstale != 0) {
> + odp_buffer_t buf = odp_queue_deq(queue);
> + if (buf != ODP_BUFFER_INVALID) {
> + handle_tmo(buf, true, 0/*Dont' care for stale tmo's*/);
> + nstale--;
> + } else {
> + CU_FAIL("Failed to receive stale timeout");
> + break;
> + }
> + }
> + /* Check if there any more (unexpected) buffers */
> + odp_buffer_t buf = odp_queue_deq(queue);
> + if (buf != ODP_BUFFER_INVALID)
> + CU_FAIL("Unexpected buffer received");
> +
> + printf("Thread %u: exiting\n", thr);
> + return NULL;
> +}
> +
> +/* @private Timer test case entrypoint */
> +static void test_odp_timer_all(void)
> +{
> + odp_shm_t shm;
> + int num_workers = min(odp_sys_core_count(), MAX_WORKERS);
> +
> + /* Create timeout buffer pools */
> + shm = odp_shm_reserve("tmo_bufs",
> + TMO_POOL_SIZE * num_workers,
> + ODP_CACHE_LINE_SIZE, 0);
> + if (shm == ODP_SHM_INVALID)
> + CU_FAIL_FATAL("Timeout shared memory alloc failed");
> +
> + tbp = odp_buffer_pool_create("tmo_pool", odp_shm_addr(shm),
> + TMO_POOL_SIZE * num_workers,
> + 0,
> + ODP_CACHE_LINE_SIZE,
> + ODP_BUFFER_TYPE_TIMEOUT);
> + if (tbp == ODP_BUFFER_POOL_INVALID)
> + CU_FAIL_FATAL("Timeout buffer pool create failed");
> +
> +#define NAME "timer_pool"
> +#define RES (10 * ODP_TIME_MSEC / 3)
> +#define MIN (10 * ODP_TIME_MSEC / 3)
> +#define MAX (1000000 * ODP_TIME_MSEC)
> + /* Create a timer pool */
> + tp = odp_timer_pool_create(NAME, tbp,
> + RES, MIN, MAX,
> + num_workers * NTIMERS,
> + true, ODP_CLOCK_CPU);
> + if (tp == ODP_TIMER_POOL_INVALID)
> + CU_FAIL_FATAL("Timer pool create failed");
> +
> + /* Start all created timer pools */
> + odp_timer_pool_start();
> +
> + odp_timer_pool_info_t tpinfo;
> + size_t sz = odp_timer_pool_info(tp, &tpinfo, sizeof(tpinfo));
> + if (sz < offsetof(odp_timer_pool_info_t, name) + strlen(NAME) + 1)
> + CU_FAIL("odp_timer_pool_info");
> + CU_ASSERT(strcmp(tpinfo.name, NAME) == 0);
> + CU_ASSERT(tpinfo.resolution == RES);
> + CU_ASSERT(tpinfo.min_tmo == odp_timer_ns_to_tick(tp, MIN));
> + CU_ASSERT(tpinfo.max_tmo == odp_timer_ns_to_tick(tp, MAX));
> + printf("Timer pool\n");
> + printf("----------\n");
> + printf(" name: %s\n", tpinfo.name);
> + printf(" resolution: %"PRIu64" ns (%"PRIu64" us)\n",
> + tpinfo.resolution, tpinfo.resolution / 1000);
> + printf(" min tmo: %"PRIu64" tick(s)\n", tpinfo.min_tmo);
> + printf(" max tmo: %"PRIu64" ticks\n", tpinfo.max_tmo);
> + printf("\n");
> +
> + printf("#timers..: %u\n", NTIMERS);
> + printf("Tmo range: %u ms (%"PRIu64" ticks)\n", RANGE_MS,
> + odp_timer_ns_to_tick(tp, 1000000ULL * RANGE_MS));
> + printf("\n");
> +
> + uint64_t tick;
> + for (tick = 0; tick < 1000000000000ULL; tick += 1000000ULL) {
> + uint64_t ns = odp_timer_tick_to_ns(tp, tick);
> + uint64_t t2 = odp_timer_ns_to_tick(tp, ns);
> + if (tick != t2)
> + CU_FAIL("Invalid conversion tick->ns->tick");
> + }
> +
> + /* Initialize barrier used by worker threads for synchronization */
> + odp_barrier_init(&test_barrier, num_workers);
> +
> + /* Create and start worker threads */
> + pthrd_arg thrdarg;
> + thrdarg.testcase = 0;
> + thrdarg.numthrds = num_workers;
> + odp_cunit_thread_create(worker_entrypoint, &thrdarg);
> +
> + /* Wait for worker threads to exit */
> + odp_cunit_thread_exit(&thrdarg);
> +
> + /* Check some statistics after the test */
> + sz = odp_timer_pool_info(tp, &tpinfo, sizeof(tpinfo));
> + if (sz < offsetof(odp_timer_pool_info_t, name) + strlen(NAME) + 1)
> + CU_FAIL("odp_timer_pool_info");
> + CU_ASSERT(tpinfo.num_timers == (unsigned)num_workers * NTIMERS);
> + CU_ASSERT(tpinfo.cur_timers == 0);
> + CU_ASSERT(tpinfo.hwm_timers == (unsigned)num_workers * NTIMERS);
> +
> + /* Destroy timer pool, all timers must have been freed */
> + odp_timer_pool_destroy(tp);
> +
> + CU_PASS("ODP timer test");
> +}
> +
> +CU_TestInfo test_odp_timer[] = {
> + {"test_odp_timer_all", test_odp_timer_all},
> + CU_TEST_INFO_NULL,
> +};
> +
> +CU_SuiteInfo odp_testsuites[] = {
> + {"Timer", NULL, NULL, NULL, NULL, test_odp_timer},
> + CU_SUITE_INFO_NULL,
> +};
> --
> 1.9.1
>
>
> _______________________________________________
> lng-odp mailing list
> [email protected]
> http://lists.linaro.org/mailman/listinfo/lng-odp
_______________________________________________
lng-odp mailing list
[email protected]
http://lists.linaro.org/mailman/listinfo/lng-odp
