/**
* printing verbose statistics
*
*/
static void print_global_stats(int num_workers)
{
odp_time_t start, wait, diff;
uint64_t pkts, pkts_prev = 0, pps, maximum_pps = 0;
int verbose_interval = 20;
odp_thrmask_t thrd_mask;
while (odp_thrmask_worker(&thrd_mask) < num_workers)
continue;
wait = odp_time_local_from_ns(verbose_interval * ODP_TIME_SEC_IN_NS);
start = odp_time_local();
while (odp_thrmask_worker(&thrd_mask) == num_workers) {
if (args->appl.number != -1 &&
odp_atomic_load_u64(&counters.cnt) >=
(unsigned int)args->appl.number) {
break;
}
diff = odp_time_diff(odp_time_local(), start);
if (odp_time_cmp(wait, diff) > 0)
continue;
start = odp_time_local();
if (args->appl.mode == APPL_MODE_RCV) {
pkts = odp_atomic_load_u64(&counters.udp);
printf(" total receive(UDP: %" PRIu64 ")\n", pkts);
continue;
}
if (args->appl.mode == APPL_MODE_PING) {
pkts = odp_atomic_load_u64(&counters.icmp);
printf(" total receive(ICMP: %" PRIu64 ")\n", pkts);
}
pkts = odp_atomic_load_u64(&counters.seq);
printf(" total sent: %" PRIu64 "\n", pkts);
if (args->appl.mode == APPL_MODE_UDP) {
pps = (pkts - pkts_prev) / verbose_interval;
if (pps > maximum_pps)
maximum_pps = pps;
printf(" %" PRIu64 " pps, %" PRIu64 " max pps\n",
pps, maximum_pps);
pkts_prev = pkts;
}
}
}
int test_atomic_validate(void)
{
if (odp_atomic_load_u32(&a32u) != U32_INIT_VAL) {
LOG_ERR("Atomic u32 usual functions failed\n");
return -1;
}
if (odp_atomic_load_u64(&a64u) != U64_INIT_VAL) {
LOG_ERR("Atomic u64 usual functions failed\n");
return -1;
}
return 0;
}
/**
* Get Ethernet address port index from MAC table
*
* @param mac Pointer to Ethernet address
* @param port[out] Pointer to port index for output
*
* @retval 0 on success
* @retval -1 on failure
*/
static inline int mac_table_get(odph_ethaddr_t *mac, uint8_t *port)
{
mac_tbl_entry_t entry;
uint16_t idx;
idx = calc_mac_tbl_idx(mac);
entry.u64 = odp_atomic_load_u64(&gbl_args->mac_tbl[idx]);
if (memcmp(mac->addr, entry.s.mac.addr, ODPH_ETHADDR_LEN))
return -1;
*port = entry.s.port;
return 0;
}
/**
* Main receive function
*
* @param arg thread arguments of type 'thread_args_t *'
*/
static void *gen_recv_thread(void *arg)
{
int thr;
odp_pktio_t pktio;
thread_args_t *thr_args;
odp_packet_t pkt;
odp_event_t ev;
thr = odp_thread_id();
thr_args = arg;
pktio = odp_pktio_lookup(thr_args->pktio_dev);
if (pktio == ODP_PKTIO_INVALID) {
EXAMPLE_ERR(" [%02i] Error: lookup of pktio %s failed\n",
thr, thr_args->pktio_dev);
return NULL;
}
printf(" [%02i] created mode: RECEIVE\n", thr);
for (;;) {
if (args->appl.number != -1 &&
odp_atomic_load_u64(&counters.icmp) >=
(unsigned int)args->appl.number) {
break;
}
/* Use schedule to get buf from any input queue */
ev = odp_schedule(NULL, ODP_SCHED_WAIT);
pkt = odp_packet_from_event(ev);
/* Drop packets with errors */
if (odp_unlikely(odp_packet_has_error(pkt))) {
odp_packet_free(pkt);
continue;
}
print_pkts(thr, &pkt, 1);
odp_packet_free(pkt);
}
return arg;
}
void odp_pool_print(odp_pool_t pool_hdl)
{
pool_entry_t *pool;
uint32_t pool_id;
pool_id = pool_handle_to_index(pool_hdl);
pool = get_pool_entry(pool_id);
uint32_t bufcount = odp_atomic_load_u32(&pool->s.bufcount);
uint32_t blkcount = odp_atomic_load_u32(&pool->s.blkcount);
uint64_t bufallocs = odp_atomic_load_u64(&pool->s.poolstats.bufallocs);
uint64_t buffrees = odp_atomic_load_u64(&pool->s.poolstats.buffrees);
uint64_t blkallocs = odp_atomic_load_u64(&pool->s.poolstats.blkallocs);
uint64_t blkfrees = odp_atomic_load_u64(&pool->s.poolstats.blkfrees);
uint64_t bufempty = odp_atomic_load_u64(&pool->s.poolstats.bufempty);
uint64_t blkempty = odp_atomic_load_u64(&pool->s.poolstats.blkempty);
uint64_t hiwmct =
odp_atomic_load_u64(&pool->s.poolstats.high_wm_count);
uint64_t lowmct =
odp_atomic_load_u64(&pool->s.poolstats.low_wm_count);
ODP_DBG("Pool info\n");
ODP_DBG("---------\n");
ODP_DBG(" pool %" PRIu64 "\n",
odp_pool_to_u64(pool->s.pool_hdl));
ODP_DBG(" name %s\n",
pool->s.flags.has_name ? pool->s.name : "Unnamed Pool");
ODP_DBG(" pool type %s\n",
pool->s.params.type == ODP_POOL_BUFFER ? "buffer" :
(pool->s.params.type == ODP_POOL_PACKET ? "packet" :
(pool->s.params.type == ODP_POOL_TIMEOUT ? "timeout" :
"unknown")));
ODP_DBG(" pool storage ODP managed shm handle %" PRIu64 "\n",
odp_shm_to_u64(pool->s.pool_shm));
ODP_DBG(" pool status %s\n",
pool->s.quiesced ? "quiesced" : "active");
ODP_DBG(" pool opts %s, %s, %s\n",
pool->s.flags.unsegmented ? "unsegmented" : "segmented",
pool->s.flags.zeroized ? "zeroized" : "non-zeroized",
pool->s.flags.predefined ? "predefined" : "created");
ODP_DBG(" pool base %p\n", pool->s.pool_base_addr);
ODP_DBG(" pool size %lu(k)\n",
pool->s.pool_size / 1024);
ODP_DBG(" pool mdata base %p\n", pool->s.pool_mdata_addr);
ODP_DBG(" udata size %u\n", pool->s.udata_size);
ODP_DBG(" headroom %u\n", pool->s.headroom);
ODP_DBG(" tailroom %u\n", pool->s.tailroom);
if (pool->s.params.type == ODP_POOL_BUFFER) {
ODP_DBG(" buf size %1u\n", pool->s.params.buf.size);
ODP_DBG(" buf align %u requested, %u used\n",
pool->s.params.buf.align, pool->s.buf_align);
} else if (pool->s.params.type == ODP_POOL_PACKET) {
ODP_DBG(" seg length %u requested, %u used\n",
pool->s.params.pkt.seg_len, pool->s.seg_size);
ODP_DBG(" pkt length %u requested, %u used\n",
pool->s.params.pkt.len, pool->s.blk_size);
}
ODP_DBG(" num bufs %u\n", pool->s.buf_num);
ODP_DBG(" bufs available %u %s\n", bufcount,
pool->s.low_wm_assert ? " **low wm asserted**" : "");
ODP_DBG(" bufs in use %u\n", pool->s.buf_num - bufcount);
ODP_DBG(" buf allocs %lu\n", bufallocs);
ODP_DBG(" buf frees %lu\n", buffrees);
ODP_DBG(" buf empty %lu\n", bufempty);
ODP_DBG(" blk size %1u\n",
pool->s.seg_size > ODP_MAX_INLINE_BUF ? pool->s.seg_size : 0);
ODP_DBG(" blks available %u\n", blkcount);
ODP_DBG(" blk allocs %lu\n", blkallocs);
ODP_DBG(" blk frees %lu\n", blkfrees);
ODP_DBG(" blk empty %lu\n", blkempty);
ODP_DBG(" high wm value %u\n", pool->s.high_wm);
ODP_DBG(" high wm count %lu\n", hiwmct);
ODP_DBG(" low wm value %u\n", pool->s.low_wm);
ODP_DBG(" low wm count %lu\n", lowmct);
}
static void *gen_send_thread(void *arg)
{
int thr;
odp_pktio_t pktio;
thread_args_t *thr_args;
odp_queue_t outq_def;
odp_packet_t pkt[PKT_BURST_SZ];
thr = odp_thread_id();
thr_args = arg;
pktio = odp_pktio_lookup(thr_args->pktio_dev);
if (pktio == ODP_PKTIO_INVALID) {
EXAMPLE_ERR(" [%02i] Error: lookup of pktio %s failed\n",
thr, thr_args->pktio_dev);
return NULL;
}
outq_def = odp_pktio_outq_getdef(pktio);
if (outq_def == ODP_QUEUE_INVALID) {
EXAMPLE_ERR(" [%02i] Error: def output-Q query\n", thr);
return NULL;
}
printf(" [%02i] created mode: SEND\n", thr);
for (int i = 0; i < PKT_BURST_SZ; ++i) {
if (args->appl.mode == APPL_MODE_UDP)
pkt[i] = pack_udp_pkt(thr_args->pool);
else if (args->appl.mode == APPL_MODE_PING)
pkt[i] = pack_icmp_pkt(thr_args->pool);
else
pkt[i] = ODP_PACKET_INVALID;
if (!odp_packet_is_valid(pkt[i])) {
EXAMPLE_ERR(" [%2i] alloc_single failed\n", thr);
return NULL;
}
}
for (;;) {
int err;
err = odp_queue_enq_multi(outq_def, (odp_event_t*)pkt, PKT_BURST_SZ);
if (err != PKT_BURST_SZ) {
/* EXAMPLE_ERR(" [%02i] send pkt err!\n", thr); */
/* return NULL; */
}
static uint64_t toto = 0;
if (args->appl.interval != 0) {
printf(" [%02i] send pkt no:%"PRIu64" seq %"PRIu64"\n",
thr,
odp_atomic_load_u64(&counters.seq),
toto++);
usleep(args->appl.interval);
/* millisleep(args->appl.interval, */
/* thr_args->tp, */
/* thr_args->tim, */
/* thr_args->tq, */
/* thr_args->tmo_ev); */
}
}
printf("Done\n");
_exit(0);
/* receive number of reply pks until timeout */
if (args->appl.mode == APPL_MODE_PING && args->appl.number > 0) {
while (args->appl.timeout >= 0) {
if (odp_atomic_load_u64(&counters.icmp) >=
(unsigned int)args->appl.number)
break;
millisleep(DEFAULT_PKT_INTERVAL,
thr_args->tp,
thr_args->tim,
thr_args->tq,
thr_args->tmo_ev);
args->appl.timeout--;
}
}
return arg;
}
