Add new scheduling latency benchmark application. The application
measures delays (avg, min, max) for high and low priority events.
The test has a configurable number of TRAFFIC events and few SAMPLE events
(one common or one per priority). The scheduling latency is only measured
from the SAMPLE events to minimize measurement overhead.
The application's command line arguments enable configuring:
- Number of processing threads
- Number of high/low priority queues
- Number of high/low priority events
- Use separate SAMPLE events for each priority
- Scheduled queue type (PARALLEL, ATOMIC, ORDERED)
Signed-off-by: Matias Elo <matias....@nokia.com>
---
V2:
- Remove unnecessary 'num_workers' initialization (Maxim)
test/common_plat/performance/.gitignore | 1 +
test/common_plat/performance/Makefile.am | 4 +
test/common_plat/performance/odp_sched_latency.c | 767 +++++++++++++++++++++++
3 files changed, 772 insertions(+)
create mode 100644 test/common_plat/performance/odp_sched_latency.c
diff --git a/test/common_plat/performance/.gitignore
b/test/common_plat/performance/.gitignore
index edcc832..1527d25 100644
--- a/test/common_plat/performance/.gitignore
+++ b/test/common_plat/performance/.gitignore
@@ -4,4 +4,5 @@ odp_atomic
odp_crypto
odp_l2fwd
odp_pktio_perf
+odp_sched_latency
odp_scheduling
diff --git a/test/common_plat/performance/Makefile.am
b/test/common_plat/performance/Makefile.am
index d23bb3e..f5dd8dd 100644
--- a/test/common_plat/performance/Makefile.am
+++ b/test/common_plat/performance/Makefile.am
@@ -5,6 +5,7 @@ TESTS_ENVIRONMENT += TEST_DIR=${builddir}
EXECUTABLES = odp_crypto$(EXEEXT) odp_pktio_perf$(EXEEXT)
COMPILE_ONLY = odp_l2fwd$(EXEEXT) \
+ odp_sched_latency$(EXEEXT) \
odp_scheduling$(EXEEXT)
TESTSCRIPTS = odp_l2fwd_run.sh \
@@ -20,6 +21,8 @@ bin_PROGRAMS = $(EXECUTABLES) $(COMPILE_ONLY)
odp_crypto_LDFLAGS = $(AM_LDFLAGS) -static
odp_crypto_CFLAGS = $(AM_CFLAGS) -I${top_srcdir}/test
+odp_sched_latency_LDFLAGS = $(AM_LDFLAGS) -static
+odp_sched_latency_CFLAGS = $(AM_CFLAGS) -I${top_srcdir}/test
odp_scheduling_LDFLAGS = $(AM_LDFLAGS) -static
odp_scheduling_CFLAGS = $(AM_CFLAGS) -I${top_srcdir}/test
@@ -27,6 +30,7 @@ noinst_HEADERS = \
$(top_srcdir)/test/test_debug.h
dist_odp_crypto_SOURCES = odp_crypto.c
+dist_odp_sched_latency_SOURCES = odp_sched_latency.c
dist_odp_scheduling_SOURCES = odp_scheduling.c
dist_odp_pktio_perf_SOURCES = odp_pktio_perf.c
diff --git a/test/common_plat/performance/odp_sched_latency.c b/test/common_plat/performance/odp_sched_latency.c
new file mode 100644
index 0000000..063fb21
--- /dev/null
+++ b/test/common_plat/performance/odp_sched_latency.c
@@ -0,0 +1,767 @@
+/* Copyright (c) 2016, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+/**
+ * @file
+ *
+ * @example odp_sched_latency.c ODP scheduling latency benchmark application
+ */
+
+#include <string.h>
+#include <stdlib.h>
+#include <inttypes.h>
+
+#include <test_debug.h>
+
+/* ODP main header */
+#include <odp_api.h>
+
+/* ODP helper for Linux apps */
+#include <odp/helper/linux.h>
+
+/* GNU lib C */
+#include <getopt.h>
+
+#define MAX_WORKERS 64 /**< Maximum number of worker threads */
+#define MAX_QUEUES 4096 /**< Maximum number of queues */
+#define EVENT_POOL_SIZE (1024 * 1024) /**< Event pool size */
+#define TEST_ROUNDS (4 * 1024 * 1024) /**< Test rounds for each thread */
+#define MAIN_THREAD 1 /**< Thread ID performing maintenance tasks */
+
+/* Default values for command line arguments */
+#define SAMPLE_EVENT_PER_PRIO 0 /**< Allocate a separate sample event for
+ each priority */
+#define HI_PRIO_EVENTS 0 /**< Number of high priority events */
+#define LO_PRIO_EVENTS 32 /**< Number of low priority events */
+#define HI_PRIO_QUEUES 16 /**< Number of high priority queues */
+#define LO_PRIO_QUEUES 64 /**< Number of low priority queues */
+
+#define EVENTS_PER_HI_PRIO_QUEUE 0 /**< Alloc HI_PRIO_QUEUES x HI_PRIO_EVENTS
+ events */
+#define EVENTS_PER_LO_PRIO_QUEUE 1 /**< Alloc LO_PRIO_QUEUES x LO_PRIO_EVENTS
+ events */
+ODP_STATIC_ASSERT(HI_PRIO_QUEUES <= MAX_QUEUES, "Too many HI priority queues");
+ODP_STATIC_ASSERT(LO_PRIO_QUEUES <= MAX_QUEUES, "Too many LO priority queues");
+
+#define CACHE_ALIGN_ROUNDUP(x)\
+ ((ODP_CACHE_LINE_SIZE) * \
+ (((x) + ODP_CACHE_LINE_SIZE - 1) / (ODP_CACHE_LINE_SIZE)))
+
+/* Test priorities */
+#define NUM_PRIOS 2 /**< Number of tested priorities */
+#define HI_PRIO 0
+#define LO_PRIO 1
+
+/** Test event types */
+typedef enum {
+ WARM_UP, /**< Warm up event */
+ TRAFFIC, /**< Event used only as traffic load */
+ SAMPLE /**< Event used to measure latency */
+} event_type_t;
+
+/** Test event */
+typedef struct {
+ uint64_t ts; /**< Send timestamp */
+ event_type_t type; /**< Message type */
+ int src_idx[NUM_PRIOS]; /**< Source ODP queue */
+ int prio; /**< Source queue priority */
+} test_event_t;
+
+/** Test arguments */
+typedef struct {
+ int cpu_count; /**< CPU count */
+ odp_schedule_sync_t sync_type; /**< Scheduler sync type */
+ struct {
+ int queues; /**< Number of scheduling queues */
+ int events; /**< Number of events */
+ odp_bool_t events_per_queue; /**< Allocate 'queues' x 'events'
+ test events */
+ } prio[NUM_PRIOS];
+ odp_bool_t sample_per_prio; /**< Allocate a separate sample event for
+ each priority */
+} test_args_t;
+
+/** Latency measurements statistics */
+typedef struct {
+ uint64_t events; /**< Total number of received events */
+ uint64_t sample_events; /**< Number of received sample events */
+ uint64_t tot; /**< Total event latency. Sum of all events. */
+ uint64_t min; /**< Minimum event latency */
+ uint64_t max; /**< Maximum event latency */
+} test_stat_t;
+
+/** Performance test statistics (per core) */
+typedef union {
+ test_stat_t prio[NUM_PRIOS]; /**< Test statistics per priority */
+
+ uint8_t pad[CACHE_ALIGN_ROUNDUP(NUM_PRIOS * sizeof(test_stat_t))];
+} core_stat_t ODP_ALIGNED_CACHE;
+
+/** Test global variables */
+typedef struct {
+ core_stat_t core_stat[MAX_WORKERS]; /**< Core specific stats */
+ odp_barrier_t barrier; /**< Barrier for thread synchronization */
+ odp_pool_t pool; /**< Pool for allocating test events */
+ test_args_t args; /**< Parsed command line arguments */
+ odp_queue_t queue[NUM_PRIOS][MAX_QUEUES]; /**< Scheduled queues */
+} test_globals_t;
+
+/**
+ * Clear all scheduled queues.
+ *
+ * Retry to be sure that all buffers have been scheduled.
+ */
+static void clear_sched_queues(void)
+{
+ odp_event_t ev;
+
+ while (1) {
+ ev = odp_schedule(NULL, ODP_SCHED_NO_WAIT);
+
+ if (ev == ODP_EVENT_INVALID)
+ break;
+
+ odp_event_free(ev);
+ }
+}
+
+/**
+ * Enqueue events into queues
+ *
+ * @param prio Queue priority (HI_PRIO/LO_PRIO)
+ * @param num_queues Number of queues
+ * @param num_events Number of 'TRAFFIC' events
+ * @param num_samples Number of 'SAMPLE' events
+ * @param div_events If true, divide 'num_events' between 'num_queues'. if
+ * false, enqueue 'num_events' to each queue.
+ * @param globals Test shared data
+ *
+ * @retval 0 on success
+ * @retval -1 on failure
+ */
+static int enqueue_events(int prio, int num_queues, int num_events,
+ int num_samples, odp_bool_t div_events,
+ test_globals_t *globals)
+{
+ odp_buffer_t buf[num_events + num_samples];
+ odp_event_t ev[num_events + num_samples];
+ odp_queue_t queue;
+ test_event_t *event;
+ int i, j, ret;
+ int enq_events;
+ int events_per_queue;
+ int tot_events;
+ int rdy_events = 0;
+
+ tot_events = num_events + num_samples;
+
+ if (!num_queues || !tot_events)
+ return 0;
+
+ events_per_queue = tot_events;
+ if (div_events)
+ events_per_queue = (tot_events + num_queues - 1) / num_queues;
+
+ for (i = 0; i < num_queues; i++) {
+ queue = globals->queue[prio][i];
+
+ ret = odp_buffer_alloc_multi(globals->pool, buf,
+ events_per_queue);
+ if (ret != events_per_queue) {
+ LOG_ERR("Buffer alloc failed. Try increasing
EVENT_POOL_SIZE.\n");
+ ret = ret < 0 ? 0 : ret;
+ odp_buffer_free_multi(buf, ret);
+ return -1;
+ }
+ for (j = 0; j < events_per_queue; j++) {
+ if (!odp_buffer_is_valid(buf[j])) {
+ LOG_ERR("Buffer alloc failed\n");
+ odp_buffer_free_multi(buf, events_per_queue);
+ return -1;
+ }
+
+ event = odp_buffer_addr(buf[j]);
+ memset(event, 0, sizeof(test_event_t));
+
+ /* Latency isn't measured from the first processing
+ * round. */
+ if (num_samples > 0) {
+ event->type = WARM_UP;
+ num_samples--;
+ } else {
+ event->type = TRAFFIC;
+ }
+ event->src_idx[prio] = i;
+ event->prio = prio;
+ ev[j] = odp_buffer_to_event(buf[j]);
+ }
+
+ enq_events = 0;
+ do {
+ ret = odp_queue_enq_multi(queue, &ev[enq_events],
+ events_per_queue -
+ enq_events);
+ if (ret < 0) {
+ LOG_ERR("Queue enqueue failed.\n");
+ return -1;
+ }
+ enq_events += ret;
+ } while (enq_events < events_per_queue);
+
+ rdy_events += events_per_queue;
+ if (div_events && rdy_events >= tot_events)
+ return 0;
+ }
+ return 0;
+}
+
+/**
+ * Print latency measurement results
+ *
+ * @param globals Test shared data
+ */
+static void print_results(test_globals_t *globals)
+{
+ test_stat_t *lat;
+ odp_schedule_sync_t stype;
+ test_stat_t total;
+ test_args_t *args;
+ uint64_t avg;
+ int i, j;
+
+ args = &globals->args;
+ stype = globals->args.sync_type;
+
+ printf("\n%s queue scheduling latency\n",
+ (stype == ODP_SCHED_SYNC_ATOMIC) ? "ATOMIC" :
+ ((stype == ODP_SCHED_SYNC_ORDERED) ? "ORDERED" : "PARALLEL"));
+
+ printf(" LO_PRIO queues: %i\n", args->prio[LO_PRIO].queues);
+ if (args->prio[LO_PRIO].events_per_queue)
+ printf(" LO_PRIO event per queue: %i\n",
+ args->prio[LO_PRIO].events);
+ else
+ printf(" LO_PRIO events: %i\n", args->prio[LO_PRIO].events);
+
+ printf(" HI_PRIO queues: %i\n", args->prio[HI_PRIO].queues);
+ if (args->prio[HI_PRIO].events_per_queue)
+ printf(" HI_PRIO event per queue: %i\n\n",
+ args->prio[HI_PRIO].events);
+ else
+ printf(" HI_PRIO events: %i\n\n", args->prio[HI_PRIO].events);
+
+ for (i = 0; i < NUM_PRIOS; i++) {
+ memset(&total, 0, sizeof(test_stat_t));
+ total.min = UINT64_MAX;
+
+ printf("%s priority\n"
+ "Thread Avg[ns] Min[ns] Max[ns] Samples
Total\n"
+
"---------------------------------------------------------------\n",
+ i == HI_PRIO ? "HIGH" : "LOW");
+ for (j = 1; j <= args->cpu_count; j++) {
+ lat = &globals->core_stat[j].prio[i];
+
+ if (lat->sample_events == 0) {
+ printf("%-8d N/A\n", j);
+ continue;
+ }
+
+ if (lat->max > total.max)
+ total.max = lat->max;
+ if (lat->min < total.min)
+ total.min = lat->min;
+ total.tot += lat->tot;
+ total.sample_events += lat->sample_events;
+ total.events += lat->events;
+
+ avg = lat->events ? lat->tot / lat->sample_events : 0;
+ printf("%-8d %-10" PRIu64 " %-10" PRIu64 " "
+ "%-10" PRIu64 " %-10" PRIu64 " %-10" PRIu64 "\n",
+ j, avg, lat->min, lat->max, lat->sample_events,
+ lat->events);
+ }
+
printf("---------------------------------------------------------------\n");
+ if (total.sample_events == 0) {
+ printf("Total N/A\n\n");
+ continue;
+ }
+ avg = total.events ? total.tot / total.sample_events : 0;
+ printf("Total %-10" PRIu64 " %-10" PRIu64 " %-10" PRIu64 " "
+ "%-10" PRIu64 " %-10" PRIu64 "\n\n", avg, total.min,
+ total.max, total.sample_events, total.events);
+ }
+}
+
+/**
+ * Measure latency of scheduled ODP events
+ *
+ * Schedule and enqueue events until 'TEST_ROUNDS' events have been processed.
+ * Scheduling latency is measured only from type 'SAMPLE' events. Other events
+ * are simply enqueued back to the scheduling queues.
+ *
+ * For 'TRAFFIC' type events the destination queue is selected from the same
+ * priority class as source queue. 'SAMPLE' type event may change priority
+ * depending on the command line arguments.
+ *
+ * @param thr Thread ID
+ * @param globals Test shared data
+ *
+ * @retval 0 on success
+ * @retval -1 on failure
+ */
+static int test_schedule(int thr, test_globals_t *globals)
+{
+ odp_event_t ev;
+ odp_buffer_t buf;
+ odp_queue_t src_queue;
+ odp_queue_t dst_queue;
+ uint64_t latency;
+ uint32_t i;
+ test_event_t *event;
+ test_stat_t *stats;
+ int dst_idx;
+
+ memset(&globals->core_stat[thr], 0, sizeof(core_stat_t));
+ globals->core_stat[thr].prio[HI_PRIO].min = UINT64_MAX;
+ globals->core_stat[thr].prio[LO_PRIO].min = UINT64_MAX;
+
+ for (i = 0; i < TEST_ROUNDS; i++) {
+ ev = odp_schedule(&src_queue, ODP_SCHED_WAIT);
+
+ buf = odp_buffer_from_event(ev);
+ event = odp_buffer_addr(buf);
+
+ stats = &globals->core_stat[thr].prio[event->prio];
+
+ if (event->type == SAMPLE) {
+ latency = odp_time_to_ns(odp_time_global()) - event->ts;
+
+ if (latency > stats->max)
+ stats->max = latency;
+ if (latency < stats->min)
+ stats->min = latency;
+ stats->tot += latency;
+ stats->sample_events++;
+
+ /* Move sample event to a different priority */
+ if (!globals->args.sample_per_prio &&
+ globals->args.prio[!event->prio].queues)
+ event->prio = !event->prio;
+ }
+
+ if (odp_unlikely(event->type == WARM_UP))
+ event->type = SAMPLE;
+ else
+ stats->events++;
+
+ /* Move event to next queue */
+ dst_idx = event->src_idx[event->prio] + 1;
+ if (dst_idx >= globals->args.prio[event->prio].queues)
+ dst_idx = 0;
+ event->src_idx[event->prio] = dst_idx;
+ dst_queue = globals->queue[event->prio][dst_idx];
+
+ if (event->type == SAMPLE)
+ event->ts = odp_time_to_ns(odp_time_global());
+
+ if (odp_queue_enq(dst_queue, ev)) {
+ LOG_ERR("[%i] Queue enqueue failed.\n", thr);
+ odp_event_free(ev);
+ return -1;
+ }
+ }
+
+ /* Clear possible locally stored buffers */
+ odp_schedule_pause();
+
+ while (1) {
+ ev = odp_schedule(&src_queue, ODP_SCHED_NO_WAIT);
+
+ if (ev == ODP_EVENT_INVALID)
+ break;
+
+ if (odp_queue_enq(src_queue, ev)) {
+ LOG_ERR("[%i] Queue enqueue failed.\n", thr);
+ odp_event_free(ev);
+ return -1;
+ }
+ }
+
+ odp_schedule_resume();
+
+ odp_barrier_wait(&globals->barrier);
+
+ clear_sched_queues();
+
+ if (thr == MAIN_THREAD)
+ print_results(globals);
+
+ return 0;
+}
+
+/**
+ * Worker thread
+ *
+ * @param arg Arguments
+ *
+ * @retval 0 on success
+ * @retval -1 on failure
+ */
+static int run_thread(void *arg ODP_UNUSED)
+{
+ odp_shm_t shm;
+ test_globals_t *globals;
+ test_args_t *args;
+ int thr;
+ int sample_events = 0;
+
+ thr = odp_thread_id();
+
+ shm = odp_shm_lookup("test_globals");
+ globals = odp_shm_addr(shm);
+
+ if (globals == NULL) {
+ LOG_ERR("Shared mem lookup failed\n");
+ return -1;
+ }
+
+ if (thr == MAIN_THREAD) {
+ args = &globals->args;
+
+ if (enqueue_events(HI_PRIO, args->prio[HI_PRIO].queues,
+ args->prio[HI_PRIO].events, 1,
+ !args->prio[HI_PRIO].events_per_queue,
+ globals))
+ return -1;
+
+ if (!args->prio[HI_PRIO].queues || args->sample_per_prio)
+ sample_events = 1;
+
+ if (enqueue_events(LO_PRIO, args->prio[LO_PRIO].queues,
+ args->prio[LO_PRIO].events, sample_events,
+ !args->prio[LO_PRIO].events_per_queue,
+ globals))
+ return -1;
+ }
+
+ odp_barrier_wait(&globals->barrier);
+
+ if (test_schedule(thr, globals))
+ return -1;
+
+ return 0;
+}
+
+/**
+ * Print usage information
+ */
+static void usage(void)
+{
+ printf("\n"
+ "OpenDataPlane scheduler latency benchmark application.\n"
+ "\n"
+ "Usage: ./odp_sched_latency [options]\n"
+ "Optional OPTIONS:\n"
+ " -c, --count <number> CPU count\n"
+ " -l, --lo-prio-queues <number> Number of low priority scheduled
queues\n"
+ " -t, --hi-prio-queues <number> Number of high priority scheduled
queues\n"
+ " -m, --lo-prio-events-per-queue <number> Number of events per low
priority queue\n"
+ " -n, --hi-prio-events-per-queue <number> Number of events per high
priority queues\n"
+ " -o, --lo-prio-events <number> Total number of low priority events
(overrides the\n"
+ " number of events per queue)\n"
+ " -p, --hi-prio-events <number> Total number of high priority events
(overrides the\n"
+ " number of events per queue)\n"
+ " -r --sample-per-prio Allocate a separate sample event for each
priority. By default\n"
+ " a single sample event is used and its priority is
changed after\n"
+ " each processing round.\n"
+ " -s, --sync Scheduled queues' sync type\n"
+ " 0: ODP_SCHED_SYNC_PARALLEL (default)\n"
+ " 1: ODP_SCHED_SYNC_ATOMIC\n"
+ " 2: ODP_SCHED_SYNC_ORDERED\n"
+ " -h, --help Display help and exit.\n\n"
+ );
+}
+
+/**
+ * Parse arguments
+ *
+ * @param argc Argument count
+ * @param argv Argument vector
+ * @param args Test arguments
+ */
+static void parse_args(int argc, char *argv[], test_args_t *args)
+{
+ int opt;
+ int long_index;
+ int i;
+
+ static const struct option longopts[] = {
+ {"count", required_argument, NULL, 'c'},
+ {"lo-prio-queues", required_argument, NULL, 'l'},
+ {"hi-prio-queues", required_argument, NULL, 't'},
+ {"lo-prio-events-per-queue", required_argument, NULL, 'm'},
+ {"hi-prio-events-per-queue", required_argument, NULL, 'n'},
+ {"lo-prio-events", required_argument, NULL, 'o'},
+ {"hi-prio-events", required_argument, NULL, 'p'},
+ {"sample-per-prio", no_argument, NULL, 'r'},
+ {"sync", required_argument, NULL, 's'},
+ {"help", no_argument, NULL, 'h'},
+ {NULL, 0, NULL, 0}
+ };
+
+ static const char *shortopts = "+c:s:l:t:m:n:o:p:rh";
+
+ /* Let helper collect its own arguments (e.g. --odph_proc) */
+ odph_parse_options(argc, argv, shortopts, longopts);
+
+ args->sync_type = ODP_SCHED_SYNC_PARALLEL;
+ args->sample_per_prio = SAMPLE_EVENT_PER_PRIO;
+ args->prio[LO_PRIO].queues = LO_PRIO_QUEUES;
+ args->prio[HI_PRIO].queues = HI_PRIO_QUEUES;
+ args->prio[LO_PRIO].events = LO_PRIO_EVENTS;
+ args->prio[HI_PRIO].events = HI_PRIO_EVENTS;
+ args->prio[LO_PRIO].events_per_queue = EVENTS_PER_LO_PRIO_QUEUE;
+ args->prio[HI_PRIO].events_per_queue = EVENTS_PER_HI_PRIO_QUEUE;
+
+ opterr = 0; /* Do not issue errors on helper options */
+ while (1) {
+ opt = getopt_long(argc, argv, shortopts, longopts, &long_index);
+
+ if (opt == -1)
+ break; /* No more options */
+
+ switch (opt) {
+ case 'c':
+ args->cpu_count = atoi(optarg);
+ break;
+ case 'l':
+ args->prio[LO_PRIO].queues = atoi(optarg);
+ break;
+ case 't':
+ args->prio[HI_PRIO].queues = atoi(optarg);
+ break;
+ case 'm':
+ args->prio[LO_PRIO].events = atoi(optarg);
+ args->prio[LO_PRIO].events_per_queue = 1;
+ break;
+ case 'n':
+ args->prio[HI_PRIO].events = atoi(optarg);
+ args->prio[HI_PRIO].events_per_queue = 1;
+ break;
+ case 'o':
+ args->prio[LO_PRIO].events = atoi(optarg);
+ args->prio[LO_PRIO].events_per_queue = 0;
+ break;
+ case 'p':
+ args->prio[HI_PRIO].events = atoi(optarg);
+ args->prio[HI_PRIO].events_per_queue = 0;
+ break;
+ case 's':
+ i = atoi(optarg);
+ if (i == 1)
+ args->sync_type = ODP_SCHED_SYNC_ATOMIC;
+ else if (i == 2)
+ args->sync_type = ODP_SCHED_SYNC_ORDERED;
+ else
+ args->sync_type = ODP_SCHED_SYNC_PARALLEL;
+ break;
+ case 'r':
+ args->sample_per_prio = 1;
+ break;
+ case 'h':
+ usage();
+ exit(EXIT_SUCCESS);
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ /* Make sure arguments are valid */
+ if (args->cpu_count > MAX_WORKERS)
+ args->cpu_count = MAX_WORKERS;
+ if (args->prio[LO_PRIO].queues > MAX_QUEUES)
+ args->prio[LO_PRIO].queues = MAX_QUEUES;
+ if (args->prio[HI_PRIO].queues > MAX_QUEUES)
+ args->prio[HI_PRIO].queues = MAX_QUEUES;
+ if (!args->prio[HI_PRIO].queues && !args->prio[LO_PRIO].queues) {
+ printf("No queues configured\n");
+ usage();
+ exit(EXIT_FAILURE);
+ }
+}
+
+/**
+ * Test main function
+ */
+int main(int argc, char *argv[])
+{
+ odp_instance_t instance;
+ odph_odpthread_t *thread_tbl;
+ odph_odpthread_params_t thr_params;
+ odp_cpumask_t cpumask;
+ odp_pool_t pool;
+ odp_pool_param_t params;
+ odp_shm_t shm;
+ test_globals_t *globals;
+ test_args_t args;
+ char cpumaskstr[ODP_CPUMASK_STR_SIZE];
+ int i, j;
+ int ret = 0;
+ int num_workers = 0;
+
+ printf("\nODP scheduling latency benchmark starts\n\n");
+
+ memset(&args, 0, sizeof(args));
+ parse_args(argc, argv, &args);
+
+ /* ODP global init */
+ if (odp_init_global(&instance, NULL, NULL)) {
+ LOG_ERR("ODP global init failed.\n");
+ return -1;
+ }
+
+ /*
+ * Init this thread. It makes also ODP calls when
+ * setting up resources for worker threads.
+ */
+ if (odp_init_local(instance, ODP_THREAD_CONTROL)) {
+ LOG_ERR("ODP global init failed.\n");
+ return -1;
+ }
+
+ printf("\n");
+ printf("ODP system info\n");
+ printf("---------------\n");
+ printf("ODP API version: %s\n", odp_version_api_str());
+ printf("ODP impl name: %s\n", odp_version_impl_name());
+ printf("ODP impl details: %s\n", odp_version_impl_str());
+ printf("CPU model: %s\n", odp_cpu_model_str());
+ printf("CPU freq (hz): %" PRIu64 "\n", odp_cpu_hz_max());
+ printf("Cache line size: %i\n", odp_sys_cache_line_size());
+ printf("Max CPU count: %i\n", odp_cpu_count());
+
+ /* Get default worker cpumask */
+ if (args.cpu_count)
+ num_workers = args.cpu_count;
+
+ num_workers = odp_cpumask_default_worker(&cpumask, num_workers);
+ args.cpu_count = num_workers;
+
+ (void)odp_cpumask_to_str(&cpumask, cpumaskstr, sizeof(cpumaskstr));
+
+ printf("Worker threads: %i\n", num_workers);
+ printf("First CPU: %i\n", odp_cpumask_first(&cpumask));
+ printf("CPU mask: %s\n\n", cpumaskstr);
+
+ thread_tbl = calloc(sizeof(odph_odpthread_t), num_workers);
+ if (!thread_tbl) {
+ LOG_ERR("no memory for thread_tbl\n");
+ return -1;
+ }
+
+ shm = odp_shm_reserve("test_globals",
+ sizeof(test_globals_t), ODP_CACHE_LINE_SIZE, 0);
+ if (shm == ODP_SHM_INVALID) {
+ LOG_ERR("Shared memory reserve failed.\n");
+ return -1;
+ }
+
+ globals = odp_shm_addr(shm);
+ memset(globals, 0, sizeof(test_globals_t));
+ memcpy(&globals->args, &args, sizeof(test_args_t));
+
+ /*
+ * Create event pool
+ */
+ odp_pool_param_init(¶ms);
+ params.buf.size = sizeof(test_event_t);
+ params.buf.align = 0;
+ params.buf.num = EVENT_POOL_SIZE;
+ params.type = ODP_POOL_BUFFER;
+
+ pool = odp_pool_create("event_pool", ¶ms);
+
+ if (pool == ODP_POOL_INVALID) {
+ LOG_ERR("Pool create failed.\n");
+ return -1;
+ }
+ globals->pool = pool;
+
+ /*
+ * Create queues for schedule test
+ */
+ for (i = 0; i < NUM_PRIOS; i++) {
+ char name[] = "sched_XX_YY";
+ odp_queue_t queue;
+ odp_queue_param_t param;
+ int prio;
+
+ if (i == HI_PRIO)
+ prio = ODP_SCHED_PRIO_HIGHEST;
+ else
+ prio = ODP_SCHED_PRIO_LOWEST;
+
+ name[6] = '0' + (prio / 10);
+ name[7] = '0' + prio - (10 * (prio / 10));
+
+ odp_queue_param_init(¶m);
+ param.type = ODP_QUEUE_TYPE_SCHED;
+ param.sched.prio = prio;
+ param.sched.sync = args.sync_type;
+ param.sched.group = ODP_SCHED_GROUP_ALL;
+
+ for (j = 0; j < args.prio[i].queues; j++) {
+ name[9] = '0' + j / 10;
+ name[10] = '0' + j - 10 * (j / 10);
+
+ queue = odp_queue_create(name, ¶m);
+
+ if (queue == ODP_QUEUE_INVALID) {
+ LOG_ERR("Scheduled queue create failed.\n");
+ return -1;
+ }
+
+ globals->queue[i][j] = queue;
+ }
+ }
+
+ odp_barrier_init(&globals->barrier, num_workers);
+
+ /* Create and launch worker threads */
+ memset(&thr_params, 0, sizeof(thr_params));
+ thr_params.thr_type = ODP_THREAD_WORKER;
+ thr_params.instance = instance;
+ thr_params.start = run_thread;
+ thr_params.arg = NULL;
+ odph_odpthreads_create(thread_tbl, &cpumask, &thr_params);
+
+ /* Wait for worker threads to terminate */
+ odph_odpthreads_join(thread_tbl);
+ free(thread_tbl);
+
+ printf("ODP scheduling latency test complete\n\n");
+
+ for (i = 0; i < NUM_PRIOS; i++) {
+ odp_queue_t queue;
+ int num_queues;
+
+ num_queues = args.prio[i].queues;
+
+ for (j = 0; j < num_queues; j++) {
+ queue = globals->queue[i][j];
+ ret += odp_queue_destroy(queue);
+ }
+ }
+
+ ret += odp_shm_free(shm);
+ ret += odp_pool_destroy(pool);
+ ret += odp_term_local();
+ ret += odp_term_global(instance);
+
+ return ret;
+}
--
2.7.4
