-/*-
- * 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.
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2010-2014 Intel Corporation
+ * Copyright(c) 2019 Arm Limited
*/
#include <rte_ring.h>
#include <rte_cycles.h>
#include <rte_launch.h>
-
-#include <cmdline_parse.h>
+#include <rte_pause.h>
+#include <string.h>
#include "test.h"
+#include "test_ring.h"
/*
- * Ring
- * ====
- *
- * Measures performance of various operations using rdtsc
- * * Empty ring dequeue
- * * Enqueue/dequeue of bursts in 1 threads
- * * Enqueue/dequeue of bursts in 2 threads
+ * Ring performance test cases, measures performance of various operations
+ * using rdtsc for legacy and 16B size ring elements.
*/
#define RING_NAME "RING_PERF"
#define RING_SIZE 4096
#define MAX_BURST 32
-/*
+/*
* the sizes to enqueue and dequeue in testing
* (marked volatile so they won't be seen as compile-time constants)
*/
static const volatile unsigned bulk_sizes[] = { 8, 32 };
-/* The ring structure used for tests */
-static struct rte_ring *r;
-
struct lcore_pair {
unsigned c1, c2;
};
static volatile unsigned lcore_count = 0;
+static void
+test_ring_print_test_string(unsigned int api_type, int esize,
+ unsigned int bsz, double value)
+{
+ if (esize == -1)
+ printf("legacy APIs");
+ else
+ printf("elem APIs: element size %dB", esize);
+
+ if (api_type == TEST_RING_IGNORE_API_TYPE)
+ return;
+
+ if ((api_type & TEST_RING_THREAD_DEF) == TEST_RING_THREAD_DEF)
+ printf(": default enqueue/dequeue: ");
+ else if ((api_type & TEST_RING_THREAD_SPSC) == TEST_RING_THREAD_SPSC)
+ printf(": SP/SC: ");
+ else if ((api_type & TEST_RING_THREAD_MPMC) == TEST_RING_THREAD_MPMC)
+ printf(": MP/MC: ");
+
+ if ((api_type & TEST_RING_ELEM_SINGLE) == TEST_RING_ELEM_SINGLE)
+ printf("single: ");
+ else if ((api_type & TEST_RING_ELEM_BULK) == TEST_RING_ELEM_BULK)
+ printf("bulk (size: %u): ", bsz);
+ else if ((api_type & TEST_RING_ELEM_BURST) == TEST_RING_ELEM_BURST)
+ printf("burst (size: %u): ", bsz);
+
+ printf("%.2F\n", value);
+}
+
/**** Functions to analyse our core mask to get cores for different tests ***/
static int
RTE_LCORE_FOREACH(id2) {
if (id1 == id2)
continue;
- c1 = lcore_config[id1].core_id;
- c2 = lcore_config[id2].core_id;
- s1 = lcore_config[id1].socket_id;
- s2 = lcore_config[id2].socket_id;
+
+ c1 = rte_lcore_to_cpu_id(id1);
+ c2 = rte_lcore_to_cpu_id(id2);
+ s1 = rte_lcore_to_socket_id(id1);
+ s2 = rte_lcore_to_socket_id(id2);
if ((c1 == c2) && (s1 == s2)){
lcp->c1 = id1;
lcp->c2 = id2;
RTE_LCORE_FOREACH(id2) {
if (id1 == id2)
continue;
- c1 = lcore_config[id1].core_id;
- c2 = lcore_config[id2].core_id;
- s1 = lcore_config[id1].socket_id;
- s2 = lcore_config[id2].socket_id;
+
+ c1 = rte_lcore_to_cpu_id(id1);
+ c2 = rte_lcore_to_cpu_id(id2);
+ s1 = rte_lcore_to_socket_id(id1);
+ s2 = rte_lcore_to_socket_id(id2);
if ((c1 != c2) && (s1 == s2)){
lcp->c1 = id1;
lcp->c2 = id2;
RTE_LCORE_FOREACH(id2) {
if (id1 == id2)
continue;
- s1 = lcore_config[id1].socket_id;
- s2 = lcore_config[id2].socket_id;
+ s1 = rte_lcore_to_socket_id(id1);
+ s2 = rte_lcore_to_socket_id(id2);
if (s1 != s2){
lcp->c1 = id1;
lcp->c2 = id2;
/* Get cycle counts for dequeuing from an empty ring. Should be 2 or 3 cycles */
static void
-test_empty_dequeue(void)
+test_empty_dequeue(struct rte_ring *r, const int esize,
+ const unsigned int api_type)
{
- const unsigned iter_shift = 26;
- const unsigned iterations = 1<<iter_shift;
- unsigned i = 0;
+ const unsigned int iter_shift = 26;
+ const unsigned int iterations = 1 << iter_shift;
+ unsigned int i = 0;
void *burst[MAX_BURST];
- const uint64_t sc_start = rte_rdtsc();
+ const uint64_t start = rte_rdtsc();
for (i = 0; i < iterations; i++)
- rte_ring_sc_dequeue_bulk(r, burst, bulk_sizes[0]);
- const uint64_t sc_end = rte_rdtsc();
+ test_ring_dequeue(r, burst, esize, bulk_sizes[0], api_type);
+ const uint64_t end = rte_rdtsc();
- const uint64_t mc_start = rte_rdtsc();
- for (i = 0; i < iterations; i++)
- rte_ring_mc_dequeue_bulk(r, burst, bulk_sizes[0]);
- const uint64_t mc_end = rte_rdtsc();
-
- printf("SC empty dequeue: %.2F\n",
- (double)(sc_end-sc_start) / iterations);
- printf("MC empty dequeue: %.2F\n",
- (double)(mc_end-mc_start) / iterations);
+ test_ring_print_test_string(api_type, esize, bulk_sizes[0],
+ ((double)(end - start)) / iterations);
}
-/*
+/*
* for the separate enqueue and dequeue threads they take in one param
* and return two. Input = burst size, output = cycle average for sp/sc & mp/mc
*/
struct thread_params {
+ struct rte_ring *r;
unsigned size; /* input value, the burst size */
double spsc, mpmc; /* output value, the single or multi timings */
};
-/*
- * Function that uses rdtsc to measure timing for ring enqueue. Needs pair
- * thread running dequeue_bulk function
+/*
+ * Helper function to call bulk SP/MP enqueue functions.
+ * flag == 0 -> enqueue
+ * flag == 1 -> dequeue
*/
-static int
-enqueue_bulk(void *p)
+static __rte_always_inline int
+enqueue_dequeue_bulk_helper(const unsigned int flag, const int esize,
+ struct thread_params *p)
{
- const unsigned iter_shift = 23;
- const unsigned iterations = 1<<iter_shift;
- struct thread_params *params = p;
- const unsigned size = params->size;
- unsigned i;
- void *burst[MAX_BURST] = {0};
+ int ret;
+ const unsigned int iter_shift = 23;
+ const unsigned int iterations = 1 << iter_shift;
+ struct rte_ring *r = p->r;
+ unsigned int bsize = p->size;
+ unsigned int i;
+ void *burst = NULL;
- if ( __sync_add_and_fetch(&lcore_count, 1) != 2 )
+#ifdef RTE_USE_C11_MEM_MODEL
+ if (__atomic_add_fetch(&lcore_count, 1, __ATOMIC_RELAXED) != 2)
+#else
+ if (__sync_add_and_fetch(&lcore_count, 1) != 2)
+#endif
while(lcore_count != 2)
rte_pause();
+ burst = test_ring_calloc(MAX_BURST, esize);
+ if (burst == NULL)
+ return -1;
+
const uint64_t sp_start = rte_rdtsc();
for (i = 0; i < iterations; i++)
- while (rte_ring_sp_enqueue_bulk(r, burst, size) != 0)
- rte_pause();
+ do {
+ if (flag == 0)
+ ret = test_ring_enqueue(r, burst, esize, bsize,
+ TEST_RING_THREAD_SPSC |
+ TEST_RING_ELEM_BULK);
+ else if (flag == 1)
+ ret = test_ring_dequeue(r, burst, esize, bsize,
+ TEST_RING_THREAD_SPSC |
+ TEST_RING_ELEM_BULK);
+ if (ret == 0)
+ rte_pause();
+ } while (!ret);
const uint64_t sp_end = rte_rdtsc();
const uint64_t mp_start = rte_rdtsc();
for (i = 0; i < iterations; i++)
- while (rte_ring_mp_enqueue_bulk(r, burst, size) != 0)
- rte_pause();
+ do {
+ if (flag == 0)
+ ret = test_ring_enqueue(r, burst, esize, bsize,
+ TEST_RING_THREAD_MPMC |
+ TEST_RING_ELEM_BULK);
+ else if (flag == 1)
+ ret = test_ring_dequeue(r, burst, esize, bsize,
+ TEST_RING_THREAD_MPMC |
+ TEST_RING_ELEM_BULK);
+ if (ret == 0)
+ rte_pause();
+ } while (!ret);
const uint64_t mp_end = rte_rdtsc();
- params->spsc = ((double)(sp_end - sp_start))/(iterations*size);
- params->mpmc = ((double)(mp_end - mp_start))/(iterations*size);
+ p->spsc = ((double)(sp_end - sp_start))/(iterations * bsize);
+ p->mpmc = ((double)(mp_end - mp_start))/(iterations * bsize);
return 0;
}
-/*
+/*
+ * Function that uses rdtsc to measure timing for ring enqueue. Needs pair
+ * thread running dequeue_bulk function
+ */
+static int
+enqueue_bulk(void *p)
+{
+ struct thread_params *params = p;
+
+ return enqueue_dequeue_bulk_helper(0, -1, params);
+}
+
+static int
+enqueue_bulk_16B(void *p)
+{
+ struct thread_params *params = p;
+
+ return enqueue_dequeue_bulk_helper(0, 16, params);
+}
+
+/*
* Function that uses rdtsc to measure timing for ring dequeue. Needs pair
- * thread running enqueue_bulk function
+ * thread running enqueue_bulk function
*/
static int
dequeue_bulk(void *p)
{
- const unsigned iter_shift = 23;
- const unsigned iterations = 1<<iter_shift;
struct thread_params *params = p;
- const unsigned size = params->size;
- unsigned i;
- void *burst[MAX_BURST] = {0};
- if ( __sync_add_and_fetch(&lcore_count, 1) != 2 )
- while(lcore_count != 2)
- rte_pause();
-
- const uint64_t sc_start = rte_rdtsc();
- for (i = 0; i < iterations; i++)
- while (rte_ring_sc_dequeue_bulk(r, burst, size) != 0)
- rte_pause();
- const uint64_t sc_end = rte_rdtsc();
+ return enqueue_dequeue_bulk_helper(1, -1, params);
+}
- const uint64_t mc_start = rte_rdtsc();
- for (i = 0; i < iterations; i++)
- while (rte_ring_mc_dequeue_bulk(r, burst, size) != 0)
- rte_pause();
- const uint64_t mc_end = rte_rdtsc();
+static int
+dequeue_bulk_16B(void *p)
+{
+ struct thread_params *params = p;
- params->spsc = ((double)(sc_end - sc_start))/(iterations*size);
- params->mpmc = ((double)(mc_end - mc_start))/(iterations*size);
- return 0;
+ return enqueue_dequeue_bulk_helper(1, 16, params);
}
-/*
+/*
* Function that calls the enqueue and dequeue bulk functions on pairs of cores.
* used to measure ring perf between hyperthreads, cores and sockets.
*/
-static void
-run_on_core_pair(struct lcore_pair *cores,
- lcore_function_t f1, lcore_function_t f2)
+static int
+run_on_core_pair(struct lcore_pair *cores, struct rte_ring *r, const int esize)
{
- struct thread_params param1 = {.size = 0}, param2 = {.size = 0};
+ lcore_function_t *f1, *f2;
+ struct thread_params param1 = {0}, param2 = {0};
unsigned i;
- for (i = 0; i < sizeof(bulk_sizes)/sizeof(bulk_sizes[0]); i++) {
+
+ if (esize == -1) {
+ f1 = enqueue_bulk;
+ f2 = dequeue_bulk;
+ } else {
+ f1 = enqueue_bulk_16B;
+ f2 = dequeue_bulk_16B;
+ }
+
+ for (i = 0; i < RTE_DIM(bulk_sizes); i++) {
lcore_count = 0;
param1.size = param2.size = bulk_sizes[i];
+ param1.r = param2.r = r;
if (cores->c1 == rte_get_master_lcore()) {
rte_eal_remote_launch(f2, ¶m2, cores->c2);
f1(¶m1);
} else {
rte_eal_remote_launch(f1, ¶m1, cores->c1);
rte_eal_remote_launch(f2, ¶m2, cores->c2);
- rte_eal_wait_lcore(cores->c1);
- rte_eal_wait_lcore(cores->c2);
+ if (rte_eal_wait_lcore(cores->c1) < 0)
+ return -1;
+ if (rte_eal_wait_lcore(cores->c2) < 0)
+ return -1;
}
- printf("SP/SC bulk enq/dequeue (size: %u): %.2F\n", bulk_sizes[i],
- param1.spsc + param2.spsc);
- printf("MP/MC bulk enq/dequeue (size: %u): %.2F\n", bulk_sizes[i],
- param1.mpmc + param2.mpmc);
+ test_ring_print_test_string(
+ TEST_RING_THREAD_SPSC | TEST_RING_ELEM_BULK,
+ esize, bulk_sizes[i], param1.spsc + param2.spsc);
+ test_ring_print_test_string(
+ TEST_RING_THREAD_MPMC | TEST_RING_ELEM_BULK,
+ esize, bulk_sizes[i], param1.mpmc + param2.mpmc);
}
+
+ return 0;
}
-/*
- * Test function that determines how long an enqueue + dequeue of a single item
- * takes on a single lcore. Result is for comparison with the bulk enq+deq.
- */
-static void
-test_single_enqueue_dequeue(void)
+static rte_atomic32_t synchro;
+static uint64_t queue_count[RTE_MAX_LCORE];
+
+#define TIME_MS 100
+
+static int
+load_loop_fn_helper(struct thread_params *p, const int esize)
{
- const unsigned iter_shift = 24;
- const unsigned iterations = 1<<iter_shift;
- unsigned i = 0;
+ uint64_t time_diff = 0;
+ uint64_t begin = 0;
+ uint64_t hz = rte_get_timer_hz();
+ uint64_t lcount = 0;
+ const unsigned int lcore = rte_lcore_id();
+ struct thread_params *params = p;
void *burst = NULL;
- const uint64_t sc_start = rte_rdtsc();
- for (i = 0; i < iterations; i++) {
- rte_ring_sp_enqueue(r, burst);
- rte_ring_sc_dequeue(r, &burst);
- }
- const uint64_t sc_end = rte_rdtsc();
+ burst = test_ring_calloc(MAX_BURST, esize);
+ if (burst == NULL)
+ return -1;
- const uint64_t mc_start = rte_rdtsc();
- for (i = 0; i < iterations; i++) {
- rte_ring_mp_enqueue(r, burst);
- rte_ring_mc_dequeue(r, &burst);
+ /* wait synchro for slaves */
+ if (lcore != rte_get_master_lcore())
+ while (rte_atomic32_read(&synchro) == 0)
+ rte_pause();
+
+ begin = rte_get_timer_cycles();
+ while (time_diff < hz * TIME_MS / 1000) {
+ test_ring_enqueue(params->r, burst, esize, params->size,
+ TEST_RING_THREAD_MPMC | TEST_RING_ELEM_BULK);
+ test_ring_dequeue(params->r, burst, esize, params->size,
+ TEST_RING_THREAD_MPMC | TEST_RING_ELEM_BULK);
+ lcount++;
+ time_diff = rte_get_timer_cycles() - begin;
}
- const uint64_t mc_end = rte_rdtsc();
+ queue_count[lcore] = lcount;
- printf("SP/SC single enq/dequeue: %"PRIu64"\n",
- (sc_end-sc_start) >> iter_shift);
- printf("MP/MC single enq/dequeue: %"PRIu64"\n",
- (mc_end-mc_start) >> iter_shift);
+ rte_free(burst);
+
+ return 0;
}
-/*
- * Test that does both enqueue and dequeue on a core using the burst() API calls
- * instead of the bulk() calls used in other tests. Results should be the same
- * as for the bulk function called on a single lcore.
- */
-static void
-test_burst_enqueue_dequeue(void)
+static int
+load_loop_fn(void *p)
{
- const unsigned iter_shift = 23;
- const unsigned iterations = 1<<iter_shift;
- unsigned sz, i = 0;
- void *burst[MAX_BURST] = {0};
+ struct thread_params *params = p;
- for (sz = 0; sz < sizeof(bulk_sizes)/sizeof(bulk_sizes[0]); sz++) {
- const uint64_t sc_start = rte_rdtsc();
- for (i = 0; i < iterations; i++) {
- rte_ring_sp_enqueue_burst(r, burst, bulk_sizes[sz]);
- rte_ring_sc_dequeue_burst(r, burst, bulk_sizes[sz]);
- }
- const uint64_t sc_end = rte_rdtsc();
+ return load_loop_fn_helper(params, -1);
+}
- const uint64_t mc_start = rte_rdtsc();
- for (i = 0; i < iterations; i++) {
- rte_ring_mp_enqueue_burst(r, burst, bulk_sizes[sz]);
- rte_ring_mc_dequeue_burst(r, burst, bulk_sizes[sz]);
- }
- const uint64_t mc_end = rte_rdtsc();
+static int
+load_loop_fn_16B(void *p)
+{
+ struct thread_params *params = p;
- uint64_t mc_avg = ((mc_end-mc_start) >> iter_shift) / bulk_sizes[sz];
- uint64_t sc_avg = ((sc_end-sc_start) >> iter_shift) / bulk_sizes[sz];
+ return load_loop_fn_helper(params, 16);
+}
- printf("SP/SC burst enq/dequeue (size: %u): %"PRIu64"\n", bulk_sizes[sz],
- sc_avg);
- printf("MP/MC burst enq/dequeue (size: %u): %"PRIu64"\n", bulk_sizes[sz],
- mc_avg);
+static int
+run_on_all_cores(struct rte_ring *r, const int esize)
+{
+ uint64_t total;
+ struct thread_params param;
+ lcore_function_t *lcore_f;
+ unsigned int i, c;
+
+ if (esize == -1)
+ lcore_f = load_loop_fn;
+ else
+ lcore_f = load_loop_fn_16B;
+
+ memset(¶m, 0, sizeof(struct thread_params));
+ for (i = 0; i < RTE_DIM(bulk_sizes); i++) {
+ total = 0;
+ printf("\nBulk enq/dequeue count on size %u\n", bulk_sizes[i]);
+ param.size = bulk_sizes[i];
+ param.r = r;
+
+ /* clear synchro and start slaves */
+ rte_atomic32_set(&synchro, 0);
+ if (rte_eal_mp_remote_launch(lcore_f, ¶m, SKIP_MASTER) < 0)
+ return -1;
+
+ /* start synchro and launch test on master */
+ rte_atomic32_set(&synchro, 1);
+ lcore_f(¶m);
+
+ rte_eal_mp_wait_lcore();
+
+ RTE_LCORE_FOREACH(c) {
+ printf("Core [%u] count = %"PRIu64"\n",
+ c, queue_count[c]);
+ total += queue_count[c];
+ }
+
+ printf("Total count (size: %u): %"PRIu64"\n",
+ bulk_sizes[i], total);
}
+
+ return 0;
}
-/* Times enqueue and dequeue on a single lcore */
-static void
-test_bulk_enqueue_dequeue(void)
+/*
+ * Test function that determines how long an enqueue + dequeue of a single item
+ * takes on a single lcore. Result is for comparison with the bulk enq+deq.
+ */
+static int
+test_single_enqueue_dequeue(struct rte_ring *r, const int esize,
+ const unsigned int api_type)
{
- const unsigned iter_shift = 23;
- const unsigned iterations = 1<<iter_shift;
- unsigned sz, i = 0;
- void *burst[MAX_BURST] = {0};
+ const unsigned int iter_shift = 24;
+ const unsigned int iterations = 1 << iter_shift;
+ unsigned int i = 0;
+ void *burst = NULL;
- for (sz = 0; sz < sizeof(bulk_sizes)/sizeof(bulk_sizes[0]); sz++) {
- const uint64_t sc_start = rte_rdtsc();
- for (i = 0; i < iterations; i++) {
- rte_ring_sp_enqueue_bulk(r, burst, bulk_sizes[sz]);
- rte_ring_sc_dequeue_bulk(r, burst, bulk_sizes[sz]);
- }
- const uint64_t sc_end = rte_rdtsc();
+ /* alloc dummy object pointers */
+ burst = test_ring_calloc(1, esize);
+ if (burst == NULL)
+ return -1;
- const uint64_t mc_start = rte_rdtsc();
- for (i = 0; i < iterations; i++) {
- rte_ring_mp_enqueue_bulk(r, burst, bulk_sizes[sz]);
- rte_ring_mc_dequeue_bulk(r, burst, bulk_sizes[sz]);
- }
- const uint64_t mc_end = rte_rdtsc();
+ const uint64_t start = rte_rdtsc();
+ for (i = 0; i < iterations; i++) {
+ test_ring_enqueue(r, burst, esize, 1, api_type);
+ test_ring_dequeue(r, burst, esize, 1, api_type);
+ }
+ const uint64_t end = rte_rdtsc();
- double sc_avg = ((double)(sc_end-sc_start) /
- (iterations * bulk_sizes[sz]));
- double mc_avg = ((double)(mc_end-mc_start) /
- (iterations * bulk_sizes[sz]));
+ test_ring_print_test_string(api_type, esize, 1,
+ ((double)(end - start)) / iterations);
- printf("SP/SC bulk enq/dequeue (size: %u): %.2F\n", bulk_sizes[sz],
- sc_avg);
- printf("MP/MC bulk enq/dequeue (size: %u): %.2F\n", bulk_sizes[sz],
- mc_avg);
- }
+ rte_free(burst);
+
+ return 0;
}
-int
-test_ring_perf(void)
+/*
+ * Test that does both enqueue and dequeue on a core using the burst/bulk API
+ * calls Results should be the same as for the bulk function called on a
+ * single lcore.
+ */
+static int
+test_burst_bulk_enqueue_dequeue(struct rte_ring *r, const int esize,
+ const unsigned int api_type)
{
- struct lcore_pair cores;
- r = rte_ring_create(RING_NAME, RING_SIZE, rte_socket_id(), 0);
- if (r == NULL && (r = rte_ring_lookup(RING_NAME)) == NULL)
+ const unsigned int iter_shift = 23;
+ const unsigned int iterations = 1 << iter_shift;
+ unsigned int sz, i = 0;
+ void **burst = NULL;
+
+ burst = test_ring_calloc(MAX_BURST, esize);
+ if (burst == NULL)
return -1;
- printf("### Testing single element and burst enq/deq ###\n");
- test_single_enqueue_dequeue();
- test_burst_enqueue_dequeue();
+ for (sz = 0; sz < RTE_DIM(bulk_sizes); sz++) {
+ const uint64_t start = rte_rdtsc();
+ for (i = 0; i < iterations; i++) {
+ test_ring_enqueue(r, burst, esize, bulk_sizes[sz],
+ api_type);
+ test_ring_dequeue(r, burst, esize, bulk_sizes[sz],
+ api_type);
+ }
+ const uint64_t end = rte_rdtsc();
+
+ test_ring_print_test_string(api_type, esize, bulk_sizes[sz],
+ ((double)(end - start)) / iterations);
+ }
- printf("\n### Testing empty dequeue ###\n");
- test_empty_dequeue();
+ rte_free(burst);
- printf("\n### Testing using a single lcore ###\n");
- test_bulk_enqueue_dequeue();
+ return 0;
+}
+
+/* Run all tests for a given element size */
+static __rte_always_inline int
+test_ring_perf_esize(const int esize)
+{
+ struct lcore_pair cores;
+ struct rte_ring *r = NULL;
+
+ /*
+ * Performance test for legacy/_elem APIs
+ * SP-SC/MP-MC, single
+ */
+ r = test_ring_create(RING_NAME, esize, RING_SIZE, rte_socket_id(), 0);
+ if (r == NULL)
+ goto test_fail;
+
+ printf("\n### Testing single element enq/deq ###\n");
+ if (test_single_enqueue_dequeue(r, esize,
+ TEST_RING_THREAD_SPSC | TEST_RING_ELEM_SINGLE) < 0)
+ goto test_fail;
+ if (test_single_enqueue_dequeue(r, esize,
+ TEST_RING_THREAD_MPMC | TEST_RING_ELEM_SINGLE) < 0)
+ goto test_fail;
+
+ printf("\n### Testing burst enq/deq ###\n");
+ if (test_burst_bulk_enqueue_dequeue(r, esize,
+ TEST_RING_THREAD_SPSC | TEST_RING_ELEM_BURST) < 0)
+ goto test_fail;
+ if (test_burst_bulk_enqueue_dequeue(r, esize,
+ TEST_RING_THREAD_MPMC | TEST_RING_ELEM_BURST) < 0)
+ goto test_fail;
+
+ printf("\n### Testing bulk enq/deq ###\n");
+ if (test_burst_bulk_enqueue_dequeue(r, esize,
+ TEST_RING_THREAD_SPSC | TEST_RING_ELEM_BULK) < 0)
+ goto test_fail;
+ if (test_burst_bulk_enqueue_dequeue(r, esize,
+ TEST_RING_THREAD_MPMC | TEST_RING_ELEM_BULK) < 0)
+ goto test_fail;
+
+ printf("\n### Testing empty bulk deq ###\n");
+ test_empty_dequeue(r, esize,
+ TEST_RING_THREAD_SPSC | TEST_RING_ELEM_BULK);
+ test_empty_dequeue(r, esize,
+ TEST_RING_THREAD_MPMC | TEST_RING_ELEM_BULK);
if (get_two_hyperthreads(&cores) == 0) {
printf("\n### Testing using two hyperthreads ###\n");
- run_on_core_pair(&cores, enqueue_bulk, dequeue_bulk);
+ if (run_on_core_pair(&cores, r, esize) < 0)
+ goto test_fail;
}
+
if (get_two_cores(&cores) == 0) {
printf("\n### Testing using two physical cores ###\n");
- run_on_core_pair(&cores, enqueue_bulk, dequeue_bulk);
+ if (run_on_core_pair(&cores, r, esize) < 0)
+ goto test_fail;
}
if (get_two_sockets(&cores) == 0) {
printf("\n### Testing using two NUMA nodes ###\n");
- run_on_core_pair(&cores, enqueue_bulk, dequeue_bulk);
+ if (run_on_core_pair(&cores, r, esize) < 0)
+ goto test_fail;
}
+
+ printf("\n### Testing using all slave nodes ###\n");
+ if (run_on_all_cores(r, esize) < 0)
+ goto test_fail;
+
+ rte_ring_free(r);
+
+ return 0;
+
+test_fail:
+ rte_ring_free(r);
+
+ return -1;
+}
+
+static int
+test_ring_perf(void)
+{
+ /* Run all the tests for different element sizes */
+ if (test_ring_perf_esize(-1) == -1)
+ return -1;
+
+ if (test_ring_perf_esize(16) == -1)
+ return -1;
+
return 0;
}
+
+REGISTER_TEST_COMMAND(ring_perf_autotest, test_ring_perf);
git.droids-corp.org / dpdk.git / blobdiff