From patchwork Wed May 27 17:39:11 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mike Holmes X-Patchwork-Id: 49022 Return-Path: X-Original-To: linaro@patches.linaro.org Delivered-To: linaro@patches.linaro.org Received: from mail-la0-f71.google.com (mail-la0-f71.google.com [209.85.215.71]) by ip-10-151-82-157.ec2.internal (Postfix) with ESMTPS id 7CE2F20BF2 for ; Wed, 27 May 2015 17:39:32 +0000 (UTC) Received: by lagv1 with SMTP id v1sf4754770lag.1 for ; Wed, 27 May 2015 10:39:31 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:delivered-to:delivered-to:from:to:date :message-id:cc:subject:precedence:list-id:list-unsubscribe :list-archive:list-post:list-help:list-subscribe:mime-version :content-type:content-transfer-encoding:errors-to:sender :x-original-sender:x-original-authentication-results:mailing-list; bh=OuZVx74CnBqZ6U5W3Tq5wDKtNT5M6is1BQUKaE4DTDs=; b=WMKXkoOf5OA43s6mduBYMeKgZEYT4KnaomG6KHOi8HdzP7nu81B5THwz8FExJpamfe ak7YLOgN4XXs1Ttdplger5TVpySpbTPe/WSeIvI6foClNLuTAUQc6C6VB4Rm+wyne6tk bbJ9ljcOOGDwNwQOUlqqmJ4pv9B51BPeh/hEZCdhphOWUIf7z04erjqKYvN7t3opTe/j 6htIb/ZXPh4VJU+zBJTeG+9U248Pxtq6Cads152tt/Hct0zJk1/Q+wJ2/gPVwr5fokEu fz/sr0rMfCGVaAmJPlnforLBLdNrvXavRkXqe3MVxr9T2enbro+6a/Dk1ZZBXNqA258z 5pYA== X-Gm-Message-State: ALoCoQkjnXAMU+KxmXsTd06TfowV+Lry/x9iS+Xs4GMK8fw2kg++yoo5npAi8CVLCu5kZZG45dNa X-Received: by 10.152.26.134 with SMTP id l6mr33128050lag.10.1432748371234; Wed, 27 May 2015 10:39:31 -0700 (PDT) X-BeenThere: patchwork-forward@linaro.org Received: by 10.152.246.35 with SMTP id xt3ls78123lac.37.gmail; Wed, 27 May 2015 10:39:30 -0700 (PDT) X-Received: by 10.112.29.36 with SMTP id g4mr27590695lbh.56.1432748370873; Wed, 27 May 2015 10:39:30 -0700 (PDT) Received: from mail-la0-f43.google.com (mail-la0-f43.google.com. [209.85.215.43]) by mx.google.com with ESMTPS id q10si4449584lbp.109.2015.05.27.10.39.30 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 27 May 2015 10:39:30 -0700 (PDT) Received-SPF: pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 209.85.215.43 as permitted sender) client-ip=209.85.215.43; Received: by labpy14 with SMTP id py14so1166767lab.0 for ; Wed, 27 May 2015 10:39:30 -0700 (PDT) X-Received: by 10.112.199.133 with SMTP id jk5mr29821482lbc.32.1432748370707; Wed, 27 May 2015 10:39:30 -0700 (PDT) X-Forwarded-To: patchwork-forward@linaro.org X-Forwarded-For: patch@linaro.org patchwork-forward@linaro.org Delivered-To: patch@linaro.org Received: by 10.112.108.230 with SMTP id hn6csp536788lbb; Wed, 27 May 2015 10:39:29 -0700 (PDT) X-Received: by 10.55.17.95 with SMTP id b92mr54135251qkh.16.1432748368557; Wed, 27 May 2015 10:39:28 -0700 (PDT) Received: from lists.linaro.org (lists.linaro.org. [54.225.227.206]) by mx.google.com with ESMTP id 105si15786198qgj.54.2015.05.27.10.39.27; Wed, 27 May 2015 10:39:28 -0700 (PDT) Received-SPF: pass (google.com: domain of lng-odp-bounces@lists.linaro.org designates 54.225.227.206 as permitted sender) client-ip=54.225.227.206; Received: by lists.linaro.org (Postfix, from userid 109) id 42A8661E6D; Wed, 27 May 2015 17:39:27 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on ip-10-142-244-252.ec2.internal X-Spam-Level: X-Spam-Status: No, score=-2.6 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H3, RCVD_IN_MSPIKE_WL, URIBL_BLOCKED autolearn=disabled version=3.4.0 Received: from ip-10-142-244-252.ec2.internal (localhost [127.0.0.1]) by lists.linaro.org (Postfix) with ESMTP id 623F261DD9; Wed, 27 May 2015 17:39:24 +0000 (UTC) X-Original-To: lng-odp@lists.linaro.org Delivered-To: lng-odp@lists.linaro.org Received: by lists.linaro.org (Postfix, from userid 109) id B69DF61E6C; Wed, 27 May 2015 17:39:21 +0000 (UTC) Received: from mail-qc0-f180.google.com (mail-qc0-f180.google.com [209.85.216.180]) by lists.linaro.org (Postfix) with ESMTPS id 2F02F61DD9 for ; Wed, 27 May 2015 17:39:20 +0000 (UTC) Received: by qchk10 with SMTP id k10so7017790qch.2 for ; Wed, 27 May 2015 10:39:19 -0700 (PDT) X-Received: by 10.55.18.9 with SMTP id c9mr65561811qkh.50.1432748359811; Wed, 27 May 2015 10:39:19 -0700 (PDT) Received: from mike-desktop.?.holmesfamily.ws (c-98-221-136-245.hsd1.nj.comcast.net. [98.221.136.245]) by mx.google.com with ESMTPSA id i91sm10490847qgd.46.2015.05.27.10.39.18 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Wed, 27 May 2015 10:39:19 -0700 (PDT) From: Mike Holmes To: christophe.milard@linaro.org Date: Wed, 27 May 2015 13:39:11 -0400 Message-Id: <1432748352-13524-1-git-send-email-mike.holmes@linaro.org> X-Mailer: git-send-email 2.1.4 X-Topics: patch Cc: lng-odp@lists.linaro.org Subject: [lng-odp] [PATCH 1/2] test: helper: add ring test X-BeenThere: lng-odp@lists.linaro.org X-Mailman-Version: 2.1.16 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: , List-Help: , List-Subscribe: , MIME-Version: 1.0 Errors-To: lng-odp-bounces@lists.linaro.org Sender: "lng-odp" X-Removed-Original-Auth: Dkim didn't pass. X-Original-Sender: mike.holmes@linaro.org X-Original-Authentication-Results: mx.google.com; spf=pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 209.85.215.43 as permitted sender) smtp.mail=patch+caf_=patchwork-forward=linaro.org@linaro.org Mailing-list: list patchwork-forward@linaro.org; contact patchwork-forward+owners@linaro.org X-Google-Group-Id: 836684582541 Signed-off-by: Mike Holmes --- helper/test/.gitignore | 1 + helper/test/Makefile.am | 4 +- helper/test/odp_ring.c | 556 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 560 insertions(+), 1 deletion(-) create mode 100644 helper/test/odp_ring.c diff --git a/helper/test/.gitignore b/helper/test/.gitignore index fe65f30..c4fd3d1 100644 --- a/helper/test/.gitignore +++ b/helper/test/.gitignore @@ -2,3 +2,4 @@ *.log odp_process odp_thread +odp_ring diff --git a/helper/test/Makefile.am b/helper/test/Makefile.am index f330533..a511f67 100644 --- a/helper/test/Makefile.am +++ b/helper/test/Makefile.am @@ -6,7 +6,8 @@ AM_LDFLAGS += -static TESTS_ENVIRONMENT = ODP_PLATFORM=${with_platform} TEST_DIR=${builddir} EXECUTABLES = odp_thread \ - odp_process + odp_process \ + odp_ring COMPILE_ONLY = @@ -23,3 +24,4 @@ bin_PROGRAMS = $(EXECUTABLES) $(COMPILE_ONLY) dist_odp_thread_SOURCES = odp_thread.c dist_odp_process_SOURCES = odp_process.c +dist_odp_ring_SOURCES = odp_ring.c diff --git a/helper/test/odp_ring.c b/helper/test/odp_ring.c new file mode 100644 index 0000000..5c4f229 --- /dev/null +++ b/helper/test/odp_ring.c @@ -0,0 +1,556 @@ +/* Copyright (c) 2015, Linaro Limited + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/*- + * BSD LICENSE + * + * Copyright(c) 2010-2013 Intel Corporation. All rights reserved. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * @file + * + * ODP test ring + */ + +#include +#include +#include +#include +#include +#include +#include + +#define RING_SIZE 4096 +#define MAX_BULK 32 + +#define RING_TEST_BASIC +#define MAX_WORKERS 32 /**< Maximum number of work threads */ + +/* Globals */ +static odph_linux_pthread_t thread_tbl[MAX_WORKERS]; /**< worker threads table*/ +static int num_workers; /**< number of workers */ + +typedef enum { + ODP_ATOMIC_TEST = 0, + ODP_SHM_TEST, + ODP_RING_TEST_BASIC, + ODP_RING_TEST_STRESS, + ODP_TIMER_PING_TEST, + ODP_MAX_TEST +} odp_test_case_e; + +/** + * Thread argument + */ +typedef struct { + int testcase; /**< specifies which set of API's to exercise */ + int numthrds; /**< no of pthreads to create */ +} pthrd_arg; + +/** + * Print system information + */ +static void odp_print_system_info(void) +{ + odp_cpumask_t cpumask; + char str[ODP_CPUMASK_STR_SIZE]; + + memset(str, 1, sizeof(str)); + + odp_cpumask_zero(&cpumask); + + odp_cpumask_from_str(&cpumask, "0x1"); + (void)odp_cpumask_to_str(&cpumask, str, sizeof(str)); + + printf("\n"); + printf("ODP system info\n"); + printf("---------------\n"); + printf("ODP API version: %s\n", odp_version_api_str()); + printf("CPU model: %s\n", odp_sys_cpu_model_str()); + printf("CPU freq (hz): %" PRIu64 "\n", odp_sys_cpu_hz()); + printf("Cache line size: %i\n", odp_sys_cache_line_size()); + printf("CPU count: %i\n", odp_cpu_count()); + printf("CPU mask: %s\n", str); + + printf("\n"); +} + +/** test init globals and call odp_init_global() */ +static int odp_test_global_init(void) +{ + memset(thread_tbl, 0, sizeof(thread_tbl)); + + if (odp_init_global(NULL, NULL)) { + LOG_ERR("ODP global init failed.\n"); + return -1; + } + + num_workers = odp_cpu_count(); + /* force to max CPU count */ + if (num_workers > MAX_WORKERS) + num_workers = MAX_WORKERS; + + return 0; +} + +/** create test thread */ +static int odp_test_thread_create(void *func_ptr(void *), pthrd_arg *arg) +{ + odp_cpumask_t cpumask; + + /* Create and init additional threads */ + odph_linux_cpumask_default(&cpumask, arg->numthrds); + odph_linux_pthread_create(thread_tbl, &cpumask, func_ptr, + (void *)arg); + + return 0; +} + +/** exit from test thread */ +static int odp_test_thread_exit(pthrd_arg *arg) +{ + /* Wait for other threads to exit */ + odph_linux_pthread_join(thread_tbl, arg->numthrds); + + return 0; +} + +static int test_ring_basic(odph_ring_t *r) +{ + void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL; + int ret; + unsigned i, num_elems; + + /* alloc dummy object pointers */ + src = malloc(RING_SIZE * 2 * sizeof(void *)); + if (!src) { + LOG_ERR("failed to allocate test ring src memory\n"); + goto fail; + } + for (i = 0; i < RING_SIZE * 2; i++) + src[i] = (void *)(unsigned long)i; + + cur_src = src; + + /* alloc some room for copied objects */ + dst = malloc(RING_SIZE * 2 * sizeof(void *)); + if (!dst) { + LOG_ERR("failed to allocate test ring dst memory\n"); + goto fail; + } + + memset(dst, 0, RING_SIZE * 2 * sizeof(void *)); + cur_dst = dst; + + printf("Test SP & SC basic functions\n"); + printf("enqueue 1 obj\n"); + ret = odph_ring_sp_enqueue_burst(r, cur_src, 1); + cur_src += 1; + if ((ret & ODPH_RING_SZ_MASK) != 1) { + LOG_ERR("sp_enq for 1 obj failed\n"); + goto fail; + } + + printf("enqueue 2 objs\n"); + ret = odph_ring_sp_enqueue_burst(r, cur_src, 2); + cur_src += 2; + if ((ret & ODPH_RING_SZ_MASK) != 2) { + LOG_ERR("sp_enq for 2 obj failed\n"); + goto fail; + } + + printf("enqueue MAX_BULK objs\n"); + ret = odph_ring_sp_enqueue_burst(r, cur_src, MAX_BULK); + if ((ret & ODPH_RING_SZ_MASK) != MAX_BULK) { + LOG_ERR("sp_enq for %d obj failed\n", MAX_BULK); + goto fail; + } + + printf("dequeue 1 obj\n"); + ret = odph_ring_sc_dequeue_burst(r, cur_dst, 1); + cur_dst += 1; + if ((ret & ODPH_RING_SZ_MASK) != 1) { + LOG_ERR("sc_deq for 1 obj failed\n"); + goto fail; + } + + printf("dequeue 2 objs\n"); + ret = odph_ring_sc_dequeue_burst(r, cur_dst, 2); + cur_dst += 2; + if ((ret & ODPH_RING_SZ_MASK) != 2) { + LOG_ERR("sc_deq for 2 obj failed\n"); + goto fail; + } + + printf("dequeue MAX_BULK objs\n"); + ret = odph_ring_sc_dequeue_burst(r, cur_dst, MAX_BULK); + cur_dst += MAX_BULK; + if ((ret & ODPH_RING_SZ_MASK) != MAX_BULK) { + LOG_ERR("sc_deq for %d obj failed\n", MAX_BULK); + goto fail; + } + + /* check data */ + if (memcmp(src, dst, cur_dst - dst)) { + LOG_ERR("data after dequeue is not the same\n"); + goto fail; + } + + cur_src = src; + cur_dst = dst; + + printf("Test MP & MC basic functions\n"); + + printf("enqueue 1 obj\n"); + ret = odph_ring_mp_enqueue_bulk(r, cur_src, 1); + cur_src += 1; + if (ret != 0) { + LOG_ERR("mp_enq for 1 obj failed\n"); + goto fail; + } + printf("enqueue 2 objs\n"); + ret = odph_ring_mp_enqueue_bulk(r, cur_src, 2); + cur_src += 2; + if (ret != 0) { + LOG_ERR("mp_enq for 2 obj failed\n"); + goto fail; + } + printf("enqueue MAX_BULK objs\n"); + ret = odph_ring_mp_enqueue_bulk(r, cur_src, MAX_BULK); + if (ret != 0) { + LOG_ERR("mp_enq for %d obj failed\n", MAX_BULK); + goto fail; + } + printf("dequeue 1 obj\n"); + ret = odph_ring_mc_dequeue_bulk(r, cur_dst, 1); + cur_dst += 1; + if (ret != 0) { + LOG_ERR("mc_deq for 1 obj failed\n"); + goto fail; + } + printf("dequeue 2 objs\n"); + ret = odph_ring_mc_dequeue_bulk(r, cur_dst, 2); + cur_dst += 2; + if (ret != 0) { + LOG_ERR("mc_deq for 2 obj failed\n"); + goto fail; + } + printf("dequeue MAX_BULK objs\n"); + ret = odph_ring_mc_dequeue_bulk(r, cur_dst, MAX_BULK); + cur_dst += MAX_BULK; + if (ret != 0) { + LOG_ERR("mc_deq for %d obj failed\n", MAX_BULK); + goto fail; + } + /* check data */ + if (memcmp(src, dst, cur_dst - dst)) { + LOG_ERR("data after dequeue is not the same\n"); + goto fail; + } + + printf("test watermark and default bulk enqueue / dequeue\n"); + odph_ring_set_water_mark(r, 20); + num_elems = 16; + + cur_src = src; + cur_dst = dst; + + ret = odph_ring_mp_enqueue_bulk(r, cur_src, num_elems); + cur_src += num_elems; + if (ret != 0) { + LOG_ERR("Cannot enqueue\n"); + goto fail; + } + ret = odph_ring_mp_enqueue_bulk(r, cur_src, num_elems); + if (ret != -EDQUOT) { + LOG_ERR("Watermark not exceeded\n"); + goto fail; + } + ret = odph_ring_mc_dequeue_bulk(r, cur_dst, num_elems); + cur_dst += num_elems; + if (ret != 0) { + LOG_ERR("Cannot dequeue\n"); + goto fail; + } + ret = odph_ring_mc_dequeue_bulk(r, cur_dst, num_elems); + cur_dst += num_elems; + if (ret != 0) { + LOG_ERR("Cannot dequeue2\n"); + goto fail; + } + + /* check data */ + if (memcmp(src, dst, cur_dst - dst)) { + LOG_ERR("data after dequeue is not the same\n"); + goto fail; + } + + printf("basic enqueu, dequeue test for ring <%s>@%p passed\n", + r->name, r); + + free(src); + free(dst); + return 0; + +fail: + free(src); + free(dst); + return -1; +} + +/* global shared ring used for stress testing */ +static odph_ring_t *r_stress; + +/* Stress func for Multi producer only */ +static int producer_fn(void) +{ + unsigned i; + + void **src = NULL; + + /* alloc dummy object pointers */ + src = malloc(MAX_BULK * 2 * sizeof(void *)); + if (!src) { + LOG_ERR("failed to allocate producer memory.\n"); + return -1; + } + for (i = 0; i < MAX_BULK; i++) + src[i] = (void *)(unsigned long)i; + + do { + i = odph_ring_mp_enqueue_bulk(r_stress, src, MAX_BULK); + if (i == 0) { + free(src); + return 0; + } + } while (1); +} + +/* Stress func for Multi consumer only */ +static int consumer_fn(void) +{ + unsigned i; + void **src = NULL; + + /* alloc dummy object pointers */ + src = malloc(MAX_BULK * 2 * sizeof(void *)); + if (!src) { + LOG_ERR("failed to allocate consumer memory.\n"); + return -1; + } + + do { + i = odph_ring_mc_dequeue_bulk(r_stress, src, MAX_BULK); + if (i == 0) { + for (i = 0; i < MAX_BULK; i++) { + if (src[i] != (void *)(unsigned long)i) { + free(src); + printf("data mismatch.. lockless ops fail\n"); + return -1; + } + } + free(src); + printf("\n Test OK !\n"); + return 0; + } + } while (1); +} + +/* + * Note : make sure that both enqueue and dequeue + * operation starts at same time so to avoid data corruption + * Its because atomic lock will protect only indexes, but if order of + * read or write operation incorrect then data mismatch will happen + * So its resposibility of application develop to take care of order of + * data read or write. +*/ +typedef enum { + one_enq_one_deq, /* One thread to enqueue one to + dequeu at same time */ + one_enq_rest_deq, /* one thread to enq rest to + dequeue at same time */ + one_deq_rest_enq, /* one to deq and rest enq at very same time */ + multi_enq_multi_deq /* multiple enq,deq */ +} stress_type_t; + +static void test_ring_stress(stress_type_t type) +{ + int thr; + + thr = odp_thread_id(); + + switch (type) { + case one_enq_one_deq: + + if (thr == 1) + producer_fn(); + if (thr == 2) + consumer_fn(); + break; + + case multi_enq_multi_deq: + if (thr % 2 == 0) + producer_fn(); + else + consumer_fn(); + break; + + case one_deq_rest_enq: + case one_enq_rest_deq:/*TBD*/ + default: + LOG_ERR("Invalid stress type or test case yet not supported\n"); + } +} + +/* local struct for ring_thread argument */ +typedef struct { + pthrd_arg thrdarg; + int stress_type; +} ring_arg_t; + +static void *test_ring(void *arg) +{ + ring_arg_t *parg = (ring_arg_t *)arg; + int thr; + char ring_name[ODPH_RING_NAMESIZE]; + odph_ring_t *r; + int result = 0; + + thr = odp_thread_id(); + + printf("Thread %i starts\n", thr); + + switch (parg->thrdarg.testcase) { + case ODP_RING_TEST_BASIC: + snprintf(ring_name, sizeof(ring_name), "test_ring_%i", thr); + + r = odph_ring_create(ring_name, RING_SIZE, + 0 /* not used, alignement + taken care inside func : todo */); + if (!r) { + LOG_ERR("ring create failed\n"); + result = -1; + break; + } + /* lookup ring from its name */ + if (odph_ring_lookup(ring_name) != r) { + LOG_ERR("ring lookup failed\n"); + result = -1; + break; + } + + /* basic operations */ + if (test_ring_basic(r) < 0) { + LOG_ERR("ring basic enqueue/dequeu ops failed\n"); + result = -1; + } + + /* dump ring stats */ + odph_ring_list_dump(); + + break; + + case ODP_RING_TEST_STRESS: + test_ring_stress(parg->stress_type); + + /* dump ring stats */ + odph_ring_list_dump(); + break; + + default: + LOG_ERR("Invalid test case [%d]\n", parg->thrdarg.testcase); + result = -1; + break; + } + + LOG_DBG("result = %d\n", result); + if (result == 0) + printf("test_ring Result:pass\n"); + else + printf("test_ring Result:fail\n"); + + fflush(stdout); + + return parg; +} + +int main(int argc __attribute__((__unused__)), + char *argv[] __attribute__((__unused__))) +{ + ring_arg_t rarg; + + if (odp_test_global_init() != 0) + return -1; + + odp_print_system_info(); + + odph_ring_tailq_init(); + + rarg.thrdarg.numthrds = odp_cpu_count(); + +#ifdef RING_TEST_BASIC + rarg.thrdarg.testcase = ODP_RING_TEST_BASIC; +#else + rarg.thrdarg.testcase = ODP_RING_TEST_STRESS; + rarg.stress_type = one_enq_one_deq; +/* rarg.stress_type = multi_enq_multi_deq;*/ + char ring_name[ODPH_RING_NAMESIZE]; + + printf("starting stess test type : %d..\n", rarg.stress_type); + /* create a ring */ + snprintf(ring_name, sizeof(ring_name), "test_ring_stress"); + + r_stress = odph_ring_create(ring_name, RING_SIZE, + 0 /* not used, alignement + taken care inside func : todo */); + if (!r_stress) { + LOG_ERR("ring create failed\n"); + goto fail; + } + /* lookup ring from its name */ + if (odph_ring_lookup(ring_name) != r_stress) { + LOG_ERR("ring lookup failed\n"); + goto fail; + } +#endif + odp_test_thread_create(test_ring, (pthrd_arg *)&rarg); + +#ifndef RING_TEST_BASIC +fail: +#endif + + odp_test_thread_exit(&rarg.thrdarg); + + return 0; +}