X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest-eventdev%2Ftest_perf_common.c;h=e7cf75a7d8912da711669637a72687b93c6928f8;hb=5d308972954cbad07d469e9b708aa517787e9948;hp=32749a695a4b701dfb1a45e421bcc800634e6191;hpb=3fc8de4f8df4a5f9ca23b0bc2d1ab592719c5daf;p=dpdk.git

diff --git a/app/test-eventdev/test_perf_common.c b/app/test-eventdev/test_perf_common.c
index 32749a695a..e7cf75a7d8 100644
--- a/app/test-eventdev/test_perf_common.c
+++ b/app/test-eventdev/test_perf_common.c
@@ -8,14 +8,27 @@ int
 perf_test_result(struct evt_test *test, struct evt_options *opt)
 {
 	RTE_SET_USED(opt);
+	int i;
+	uint64_t total = 0;
 	struct test_perf *t = evt_test_priv(test);
 
+	printf("Packet distribution across worker cores :\n");
+	for (i = 0; i < t->nb_workers; i++)
+		total += t->worker[i].processed_pkts;
+	for (i = 0; i < t->nb_workers; i++)
+		printf("Worker %d packets: "CLGRN"%"PRIx64" "CLNRM"percentage:"
+				CLGRN" %3.2f\n"CLNRM, i,
+				t->worker[i].processed_pkts,
+				(((double)t->worker[i].processed_pkts)/total)
+				* 100);
+
 	return t->result;
 }
 
 static inline int
 perf_producer(void *arg)
 {
+	int i;
 	struct prod_data *p  = arg;
 	struct test_perf *t = p->t;
 	struct evt_options *opt = t->opt;
@@ -26,7 +39,7 @@ perf_producer(void *arg)
 	const uint32_t nb_flows = t->nb_flows;
 	uint32_t flow_counter = 0;
 	uint64_t count = 0;
-	struct perf_elt *m;
+	struct perf_elt *m[BURST_SIZE + 1] = {NULL};
 	struct rte_event ev;
 
 	if (opt->verbose_level > 1)
@@ -42,21 +55,147 @@ perf_producer(void *arg)
 	ev.sub_event_type = 0; /* stage 0 */
 
 	while (count < nb_pkts && t->done == false) {
-		if (rte_mempool_get(pool, (void **)&m) < 0)
+		if (rte_mempool_get_bulk(pool, (void **)m, BURST_SIZE) < 0)
 			continue;
+		for (i = 0; i < BURST_SIZE; i++) {
+			ev.flow_id = flow_counter++ % nb_flows;
+			ev.event_ptr = m[i];
+			m[i]->timestamp = rte_get_timer_cycles();
+			while (rte_event_enqueue_burst(dev_id,
+						       port, &ev, 1) != 1) {
+				if (t->done)
+					break;
+				rte_pause();
+				m[i]->timestamp = rte_get_timer_cycles();
+			}
+		}
+		count += BURST_SIZE;
+	}
 
-		ev.flow_id = flow_counter++ % nb_flows;
-		ev.event_ptr = m;
-		m->timestamp = rte_get_timer_cycles();
-		while (rte_event_enqueue_burst(dev_id, port, &ev, 1) != 1) {
-			if (t->done)
-				break;
-			rte_pause();
-			m->timestamp = rte_get_timer_cycles();
+	return 0;
+}
+
+static inline int
+perf_event_timer_producer(void *arg)
+{
+	int i;
+	struct prod_data *p  = arg;
+	struct test_perf *t = p->t;
+	struct evt_options *opt = t->opt;
+	uint32_t flow_counter = 0;
+	uint64_t count = 0;
+	uint64_t arm_latency = 0;
+	const uint8_t nb_timer_adptrs = opt->nb_timer_adptrs;
+	const uint32_t nb_flows = t->nb_flows;
+	const uint64_t nb_timers = opt->nb_timers;
+	struct rte_mempool *pool = t->pool;
+	struct perf_elt *m[BURST_SIZE + 1] = {NULL};
+	struct rte_event_timer_adapter **adptr = t->timer_adptr;
+	struct rte_event_timer tim;
+	uint64_t timeout_ticks = opt->expiry_nsec / opt->timer_tick_nsec;
+
+	memset(&tim, 0, sizeof(struct rte_event_timer));
+	timeout_ticks = opt->optm_timer_tick_nsec ?
+			(timeout_ticks * opt->timer_tick_nsec)
+			/ opt->optm_timer_tick_nsec : timeout_ticks;
+	timeout_ticks += timeout_ticks ? 0 : 1;
+	tim.ev.event_type =  RTE_EVENT_TYPE_TIMER;
+	tim.ev.op = RTE_EVENT_OP_NEW;
+	tim.ev.sched_type = t->opt->sched_type_list[0];
+	tim.ev.queue_id = p->queue_id;
+	tim.ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL;
+	tim.state = RTE_EVENT_TIMER_NOT_ARMED;
+	tim.timeout_ticks = timeout_ticks;
+
+	if (opt->verbose_level > 1)
+		printf("%s(): lcore %d\n", __func__, rte_lcore_id());
+
+	while (count < nb_timers && t->done == false) {
+		if (rte_mempool_get_bulk(pool, (void **)m, BURST_SIZE) < 0)
+			continue;
+		for (i = 0; i < BURST_SIZE; i++) {
+			rte_prefetch0(m[i + 1]);
+			m[i]->tim = tim;
+			m[i]->tim.ev.flow_id = flow_counter++ % nb_flows;
+			m[i]->tim.ev.event_ptr = m[i];
+			m[i]->timestamp = rte_get_timer_cycles();
+			while (rte_event_timer_arm_burst(
+			       adptr[flow_counter % nb_timer_adptrs],
+			       (struct rte_event_timer **)&m[i], 1) != 1) {
+				if (t->done)
+					break;
+				m[i]->timestamp = rte_get_timer_cycles();
+			}
+			arm_latency += rte_get_timer_cycles() - m[i]->timestamp;
 		}
-		count++;
+		count += BURST_SIZE;
 	}
+	fflush(stdout);
+	rte_delay_ms(1000);
+	printf("%s(): lcore %d Average event timer arm latency = %.3f us\n",
+			__func__, rte_lcore_id(), (float)(arm_latency / count) /
+			(rte_get_timer_hz() / 1000000));
+	return 0;
+}
+
+static inline int
+perf_event_timer_producer_burst(void *arg)
+{
+	int i;
+	struct prod_data *p  = arg;
+	struct test_perf *t = p->t;
+	struct evt_options *opt = t->opt;
+	uint32_t flow_counter = 0;
+	uint64_t count = 0;
+	uint64_t arm_latency = 0;
+	const uint8_t nb_timer_adptrs = opt->nb_timer_adptrs;
+	const uint32_t nb_flows = t->nb_flows;
+	const uint64_t nb_timers = opt->nb_timers;
+	struct rte_mempool *pool = t->pool;
+	struct perf_elt *m[BURST_SIZE + 1] = {NULL};
+	struct rte_event_timer_adapter **adptr = t->timer_adptr;
+	struct rte_event_timer tim;
+	uint64_t timeout_ticks = opt->expiry_nsec / opt->timer_tick_nsec;
+
+	memset(&tim, 0, sizeof(struct rte_event_timer));
+	timeout_ticks = opt->optm_timer_tick_nsec ?
+			(timeout_ticks * opt->timer_tick_nsec)
+			/ opt->optm_timer_tick_nsec : timeout_ticks;
+	timeout_ticks += timeout_ticks ? 0 : 1;
+	tim.ev.event_type =  RTE_EVENT_TYPE_TIMER;
+	tim.ev.op = RTE_EVENT_OP_NEW;
+	tim.ev.sched_type = t->opt->sched_type_list[0];
+	tim.ev.queue_id = p->queue_id;
+	tim.ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL;
+	tim.state = RTE_EVENT_TIMER_NOT_ARMED;
+	tim.timeout_ticks = timeout_ticks;
 
+	if (opt->verbose_level > 1)
+		printf("%s(): lcore %d\n", __func__, rte_lcore_id());
+
+	while (count < nb_timers && t->done == false) {
+		if (rte_mempool_get_bulk(pool, (void **)m, BURST_SIZE) < 0)
+			continue;
+		for (i = 0; i < BURST_SIZE; i++) {
+			rte_prefetch0(m[i + 1]);
+			m[i]->tim = tim;
+			m[i]->tim.ev.flow_id = flow_counter++ % nb_flows;
+			m[i]->tim.ev.event_ptr = m[i];
+			m[i]->timestamp = rte_get_timer_cycles();
+		}
+		rte_event_timer_arm_tmo_tick_burst(
+				adptr[flow_counter % nb_timer_adptrs],
+				(struct rte_event_timer **)m,
+				tim.timeout_ticks,
+				BURST_SIZE);
+		arm_latency += rte_get_timer_cycles() - m[i - 1]->timestamp;
+		count += BURST_SIZE;
+	}
+	fflush(stdout);
+	rte_delay_ms(1000);
+	printf("%s(): lcore %d Average event timer arm latency = %.3f us\n",
+			__func__, rte_lcore_id(), (float)(arm_latency / count) /
+			(rte_get_timer_hz() / 1000000));
 	return 0;
 }
 
@@ -68,6 +207,12 @@ perf_producer_wrapper(void *arg)
 	/* Launch the producer function only in case of synthetic producer. */
 	if (t->opt->prod_type == EVT_PROD_TYPE_SYNT)
 		return perf_producer(arg);
+	else if (t->opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR &&
+			!t->opt->timdev_use_burst)
+		return perf_event_timer_producer(arg);
+	else if (t->opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR &&
+			t->opt->timdev_use_burst)
+		return perf_event_timer_producer_burst(arg);
 	return 0;
 }
 
@@ -134,8 +279,7 @@ perf_launch_lcores(struct evt_test *test, struct evt_options *opt,
 		port_idx++;
 	}
 
-	const uint64_t total_pkts = opt->nb_pkts *
-			evt_nr_active_lcores(opt->plcores);
+	const uint64_t total_pkts = t->outstand_pkts;
 
 	uint64_t dead_lock_cycles = rte_get_timer_cycles();
 	int64_t dead_lock_remaining  =  total_pkts;
@@ -177,7 +321,9 @@ perf_launch_lcores(struct evt_test *test, struct evt_options *opt,
 
 			if (remaining <= 0) {
 				t->result = EVT_TEST_SUCCESS;
-				if (opt->prod_type == EVT_PROD_TYPE_SYNT) {
+				if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
+					opt->prod_type ==
+					EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
 					t->done = true;
 					rte_smp_wmb();
 					break;
@@ -186,7 +332,8 @@ perf_launch_lcores(struct evt_test *test, struct evt_options *opt,
 		}
 
 		if (new_cycles - dead_lock_cycles > dead_lock_sample &&
-				opt->prod_type == EVT_PROD_TYPE_SYNT) {
+		    (opt->prod_type == EVT_PROD_TYPE_SYNT ||
+		     opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR)) {
 			remaining = t->outstand_pkts - processed_pkts(t);
 			if (dead_lock_remaining == remaining) {
 				rte_event_dev_dump(opt->dev_id, stdout);
@@ -203,21 +350,121 @@ perf_launch_lcores(struct evt_test *test, struct evt_options *opt,
 	return 0;
 }
 
+static int
+perf_event_rx_adapter_setup(struct evt_options *opt, uint8_t stride,
+		struct rte_event_port_conf prod_conf)
+{
+	int ret = 0;
+	uint16_t prod;
+	struct rte_event_eth_rx_adapter_queue_conf queue_conf;
+
+	memset(&queue_conf, 0,
+			sizeof(struct rte_event_eth_rx_adapter_queue_conf));
+	queue_conf.ev.sched_type = opt->sched_type_list[0];
+	RTE_ETH_FOREACH_DEV(prod) {
+		uint32_t cap;
+
+		ret = rte_event_eth_rx_adapter_caps_get(opt->dev_id,
+				prod, &cap);
+		if (ret) {
+			evt_err("failed to get event rx adapter[%d]"
+					" capabilities",
+					opt->dev_id);
+			return ret;
+		}
+		queue_conf.ev.queue_id = prod * stride;
+		ret = rte_event_eth_rx_adapter_create(prod, opt->dev_id,
+				&prod_conf);
+		if (ret) {
+			evt_err("failed to create rx adapter[%d]", prod);
+			return ret;
+		}
+		ret = rte_event_eth_rx_adapter_queue_add(prod, prod, -1,
+				&queue_conf);
+		if (ret) {
+			evt_err("failed to add rx queues to adapter[%d]", prod);
+			return ret;
+		}
+
+		if (!(cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT)) {
+			uint32_t service_id;
+
+			rte_event_eth_rx_adapter_service_id_get(prod,
+					&service_id);
+			ret = evt_service_setup(service_id);
+			if (ret) {
+				evt_err("Failed to setup service core"
+						" for Rx adapter\n");
+				return ret;
+			}
+		}
+	}
+
+	return ret;
+}
+
+static int
+perf_event_timer_adapter_setup(struct test_perf *t)
+{
+	int i;
+	int ret;
+	struct rte_event_timer_adapter_info adapter_info;
+	struct rte_event_timer_adapter *wl;
+	uint8_t nb_producers = evt_nr_active_lcores(t->opt->plcores);
+	uint8_t flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES;
+
+	if (nb_producers == 1)
+		flags |= RTE_EVENT_TIMER_ADAPTER_F_SP_PUT;
+
+	for (i = 0; i < t->opt->nb_timer_adptrs; i++) {
+		struct rte_event_timer_adapter_conf config = {
+			.event_dev_id = t->opt->dev_id,
+			.timer_adapter_id = i,
+			.timer_tick_ns = t->opt->timer_tick_nsec,
+			.max_tmo_ns = t->opt->max_tmo_nsec,
+			.nb_timers = t->opt->pool_sz,
+			.flags = flags,
+		};
+
+		wl = rte_event_timer_adapter_create(&config);
+		if (wl == NULL) {
+			evt_err("failed to create event timer ring %d", i);
+			return rte_errno;
+		}
+
+		memset(&adapter_info, 0,
+				sizeof(struct rte_event_timer_adapter_info));
+		rte_event_timer_adapter_get_info(wl, &adapter_info);
+		t->opt->optm_timer_tick_nsec = adapter_info.min_resolution_ns;
+
+		if (!(adapter_info.caps &
+				RTE_EVENT_TIMER_ADAPTER_CAP_INTERNAL_PORT)) {
+			uint32_t service_id = -1U;
+
+			rte_event_timer_adapter_service_id_get(wl,
+					&service_id);
+			ret = evt_service_setup(service_id);
+			if (ret) {
+				evt_err("Failed to setup service core"
+						" for timer adapter\n");
+				return ret;
+			}
+			rte_service_runstate_set(service_id, 1);
+		}
+		t->timer_adptr[i] = wl;
+	}
+	return 0;
+}
+
 int
 perf_event_dev_port_setup(struct evt_test *test, struct evt_options *opt,
-				uint8_t stride, uint8_t nb_queues)
+				uint8_t stride, uint8_t nb_queues,
+				const struct rte_event_port_conf *port_conf)
 {
 	struct test_perf *t = evt_test_priv(test);
-	uint8_t port, prod;
+	uint16_t port, prod;
 	int ret = -1;
 
-	/* port configuration */
-	const struct rte_event_port_conf wkr_p_conf = {
-			.dequeue_depth = opt->wkr_deq_dep,
-			.enqueue_depth = 64,
-			.new_event_threshold = 4096,
-	};
-
 	/* setup one port per worker, linking to all queues */
 	for (port = 0; port < evt_nr_active_lcores(opt->wlcores);
 				port++) {
@@ -229,7 +476,7 @@ perf_event_dev_port_setup(struct evt_test *test, struct evt_options *opt,
 		w->processed_pkts = 0;
 		w->latency = 0;
 
-		ret = rte_event_port_setup(opt->dev_id, port, &wkr_p_conf);
+		ret = rte_event_port_setup(opt->dev_id, port, port_conf);
 		if (ret) {
 			evt_err("failed to setup port %d", port);
 			return ret;
@@ -243,26 +490,45 @@ perf_event_dev_port_setup(struct evt_test *test, struct evt_options *opt,
 	}
 
 	/* port for producers, no links */
-	const struct rte_event_port_conf prod_conf = {
-			.dequeue_depth = 8,
-			.enqueue_depth = 32,
-			.new_event_threshold = 1200,
-	};
-	prod = 0;
-	for ( ; port < perf_nb_event_ports(opt); port++) {
-		struct prod_data *p = &t->prod[port];
+	if (opt->prod_type == EVT_PROD_TYPE_ETH_RX_ADPTR) {
+		for ( ; port < perf_nb_event_ports(opt); port++) {
+			struct prod_data *p = &t->prod[port];
+			p->t = t;
+		}
 
-		p->dev_id = opt->dev_id;
-		p->port_id = port;
-		p->queue_id = prod * stride;
-		p->t = t;
+		ret = perf_event_rx_adapter_setup(opt, stride, *port_conf);
+		if (ret)
+			return ret;
+	} else if (opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
+		prod = 0;
+		for ( ; port < perf_nb_event_ports(opt); port++) {
+			struct prod_data *p = &t->prod[port];
+			p->queue_id = prod * stride;
+			p->t = t;
+			prod++;
+		}
 
-		ret = rte_event_port_setup(opt->dev_id, port, &prod_conf);
-		if (ret) {
-			evt_err("failed to setup port %d", port);
+		ret = perf_event_timer_adapter_setup(t);
+		if (ret)
 			return ret;
+	} else {
+		prod = 0;
+		for ( ; port < perf_nb_event_ports(opt); port++) {
+			struct prod_data *p = &t->prod[port];
+
+			p->dev_id = opt->dev_id;
+			p->port_id = port;
+			p->queue_id = prod * stride;
+			p->t = t;
+
+			ret = rte_event_port_setup(opt->dev_id, port,
+					port_conf);
+			if (ret) {
+				evt_err("failed to setup port %d", port);
+				return ret;
+			}
+			prod++;
 		}
-		prod++;
 	}
 
 	return ret;
@@ -301,7 +567,8 @@ perf_opt_check(struct evt_options *opt, uint64_t nb_queues)
 		return -1;
 	}
 
-	if (opt->prod_type == EVT_PROD_TYPE_SYNT) {
+	if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
+			opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
 		/* Validate producer lcores */
 		if (evt_lcores_has_overlap(opt->plcores,
 					rte_get_master_lcore())) {
@@ -334,10 +601,13 @@ perf_opt_check(struct evt_options *opt, uint64_t nb_queues)
 	}
 
 	/* Fixups */
-	if (opt->nb_stages == 1 && opt->fwd_latency) {
+	if ((opt->nb_stages == 1 &&
+			opt->prod_type != EVT_PROD_TYPE_EVENT_TIMER_ADPTR) &&
+			opt->fwd_latency) {
 		evt_info("fwd_latency is valid when nb_stages > 1, disabling");
 		opt->fwd_latency = 0;
 	}
+
 	if (opt->fwd_latency && !opt->q_priority) {
 		evt_info("enabled queue priority for latency measurement");
 		opt->q_priority = 1;
@@ -366,8 +636,13 @@ perf_opt_dump(struct evt_options *opt, uint8_t nb_queues)
 void
 perf_eventdev_destroy(struct evt_test *test, struct evt_options *opt)
 {
-	RTE_SET_USED(test);
+	int i;
+	struct test_perf *t = evt_test_priv(test);
 
+	if (opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
+		for (i = 0; i < opt->nb_timer_adptrs; i++)
+			rte_event_timer_adapter_stop(t->timer_adptr[i]);
+	}
 	rte_event_dev_stop(opt->dev_id);
 	rte_event_dev_close(opt->dev_id);
 }
@@ -384,20 +659,14 @@ perf_elt_init(struct rte_mempool *mp, void *arg __rte_unused,
 int
 perf_ethdev_setup(struct evt_test *test, struct evt_options *opt)
 {
-	int i;
+	uint16_t i;
+	int ret;
 	struct test_perf *t = evt_test_priv(test);
 	struct rte_eth_conf port_conf = {
 		.rxmode = {
 			.mq_mode = ETH_MQ_RX_RSS,
-			.max_rx_pkt_len = ETHER_MAX_LEN,
+			.max_rx_pkt_len = RTE_ETHER_MAX_LEN,
 			.split_hdr_size = 0,
-			.header_split   = 0,
-			.hw_ip_checksum = 0,
-			.hw_vlan_filter = 0,
-			.hw_vlan_strip  = 0,
-			.hw_vlan_extend = 0,
-			.jumbo_frame    = 0,
-			.hw_strip_crc   = 1,
 		},
 		.rx_adv_conf = {
 			.rss_conf = {
@@ -407,19 +676,38 @@ perf_ethdev_setup(struct evt_test *test, struct evt_options *opt)
 		},
 	};
 
-	if (opt->prod_type == EVT_PROD_TYPE_SYNT)
+	if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
+			opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR)
 		return 0;
 
-	if (!rte_eth_dev_count()) {
+	if (!rte_eth_dev_count_avail()) {
 		evt_err("No ethernet ports found.");
 		return -ENODEV;
 	}
 
-	for (i = 0; i < rte_eth_dev_count(); i++) {
+	RTE_ETH_FOREACH_DEV(i) {
+		struct rte_eth_dev_info dev_info;
+		struct rte_eth_conf local_port_conf = port_conf;
+
+		ret = rte_eth_dev_info_get(i, &dev_info);
+		if (ret != 0) {
+			evt_err("Error during getting device (port %u) info: %s\n",
+					i, strerror(-ret));
+			return ret;
+		}
+
+		local_port_conf.rx_adv_conf.rss_conf.rss_hf &=
+			dev_info.flow_type_rss_offloads;
+		if (local_port_conf.rx_adv_conf.rss_conf.rss_hf !=
+				port_conf.rx_adv_conf.rss_conf.rss_hf) {
+			evt_info("Port %u modified RSS hash function based on hardware support,"
+				"requested:%#"PRIx64" configured:%#"PRIx64"\n",
+				i,
+				port_conf.rx_adv_conf.rss_conf.rss_hf,
+				local_port_conf.rx_adv_conf.rss_conf.rss_hf);
+		}
 
-		if (rte_eth_dev_configure(i, 1, 1,
-					&port_conf)
-				< 0) {
+		if (rte_eth_dev_configure(i, 1, 1, &local_port_conf) < 0) {
 			evt_err("Failed to configure eth port [%d]", i);
 			return -EINVAL;
 		}
@@ -438,18 +726,37 @@ perf_ethdev_setup(struct evt_test *test, struct evt_options *opt)
 			return -EINVAL;
 		}
 
-		rte_eth_promiscuous_enable(i);
+		ret = rte_eth_promiscuous_enable(i);
+		if (ret != 0) {
+			evt_err("Failed to enable promiscuous mode for eth port [%d]: %s",
+				i, rte_strerror(-ret));
+			return ret;
+		}
 	}
 
 	return 0;
 }
 
+void perf_ethdev_destroy(struct evt_test *test, struct evt_options *opt)
+{
+	uint16_t i;
+	RTE_SET_USED(test);
+
+	if (opt->prod_type == EVT_PROD_TYPE_ETH_RX_ADPTR) {
+		RTE_ETH_FOREACH_DEV(i) {
+			rte_event_eth_rx_adapter_stop(i);
+			rte_eth_dev_stop(i);
+		}
+	}
+}
+
 int
 perf_mempool_setup(struct evt_test *test, struct evt_options *opt)
 {
 	struct test_perf *t = evt_test_priv(test);
 
-	if (opt->prod_type == EVT_PROD_TYPE_SYNT) {
+	if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
+			opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
 		t->pool = rte_mempool_create(test->name, /* mempool name */
 				opt->pool_sz, /* number of elements*/
 				sizeof(struct perf_elt), /* element size*/
@@ -499,10 +806,18 @@ perf_test_setup(struct evt_test *test, struct evt_options *opt)
 
 	struct test_perf *t = evt_test_priv(test);
 
-	t->outstand_pkts = opt->nb_pkts * evt_nr_active_lcores(opt->plcores);
+	if (opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
+		t->outstand_pkts = opt->nb_timers *
+			evt_nr_active_lcores(opt->plcores);
+		t->nb_pkts = opt->nb_timers;
+	} else {
+		t->outstand_pkts = opt->nb_pkts *
+			evt_nr_active_lcores(opt->plcores);
+		t->nb_pkts = opt->nb_pkts;
+	}
+
 	t->nb_workers = evt_nr_active_lcores(opt->wlcores);
 	t->done = false;
-	t->nb_pkts = opt->nb_pkts;
 	t->nb_flows = opt->nb_flows;
 	t->result = EVT_TEST_FAILED;
 	t->opt = opt;