[PATCH 3/3] app/eventdev: add vector adapter performance test

[<pbhagavatula@marvell.com>]

From: Pavan Nikhilesh <pbhagavatula@marvell.com>

Add performance test for event vector adapter.

Signed-off-by: Pavan Nikhilesh <pbhagavatula@marvell.com>
---
 app/test-eventdev/evt_common.h         |   9 +-
 app/test-eventdev/evt_options.c        |  14 ++
 app/test-eventdev/evt_options.h        |   1 +
 app/test-eventdev/test_perf_atq.c      |  61 +++++-
 app/test-eventdev/test_perf_common.c   | 281 ++++++++++++++++++-------
 app/test-eventdev/test_perf_common.h   |  13 +-
 app/test-eventdev/test_perf_queue.c    |  66 +++++-
 doc/guides/rel_notes/release_25_07.rst |   5 +
 doc/guides/tools/testeventdev.rst      |   6 +
 9 files changed, 362 insertions(+), 94 deletions(-)

diff --git a/app/test-eventdev/evt_common.h b/app/test-eventdev/evt_common.h
index 74f9d187f3..ec824f2454 100644
--- a/app/test-eventdev/evt_common.h
+++ b/app/test-eventdev/evt_common.h
@@ -39,11 +39,12 @@
 
 enum evt_prod_type {
 	EVT_PROD_TYPE_NONE,
-	EVT_PROD_TYPE_SYNT,          /* Producer type Synthetic i.e. CPU. */
-	EVT_PROD_TYPE_ETH_RX_ADPTR,  /* Producer type Eth Rx Adapter. */
+	EVT_PROD_TYPE_SYNT,		  /* Producer type Synthetic i.e. CPU. */
+	EVT_PROD_TYPE_ETH_RX_ADPTR,	  /* Producer type Eth Rx Adapter. */
 	EVT_PROD_TYPE_EVENT_TIMER_ADPTR,  /* Producer type Timer Adapter. */
-	EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR,  /* Producer type Crypto Adapter. */
-	EVT_PROD_TYPE_EVENT_DMA_ADPTR,  /* Producer type DMA Adapter. */
+	EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR, /* Producer type Crypto Adapter. */
+	EVT_PROD_TYPE_EVENT_DMA_ADPTR,	  /* Producer type DMA Adapter. */
+	EVT_PROD_TYPE_EVENT_VECTOR_ADPTR, /* Producer type Vector adapter. */
 	EVT_PROD_TYPE_MAX,
 };
 
diff --git a/app/test-eventdev/evt_options.c b/app/test-eventdev/evt_options.c
index 323d1e724d..0e70c971eb 100644
--- a/app/test-eventdev/evt_options.c
+++ b/app/test-eventdev/evt_options.c
@@ -186,6 +186,13 @@ evt_parse_dma_adptr_mode(struct evt_options *opt, const char *arg)
 	return ret;
 }
 
+static int
+evt_parse_vector_prod_type(struct evt_options *opt,
+			   const char *arg __rte_unused)
+{
+	opt->prod_type = EVT_PROD_TYPE_EVENT_VECTOR_ADPTR;
+	return 0;
+}
 
 static int
 evt_parse_crypto_prod_type(struct evt_options *opt,
@@ -494,6 +501,7 @@ usage(char *program)
 		"\t                     in ns.\n"
 		"\t--prod_type_timerdev_burst : use timer device as producer\n"
 		"\t                             burst mode.\n"
+		"\t--prod_type_vector : use vector adapter as producer.\n"
 		"\t--nb_timers        : number of timers to arm.\n"
 		"\t--nb_timer_adptrs  : number of timer adapters to use.\n"
 		"\t--timer_tick_nsec  : timer tick interval in ns.\n"
@@ -591,6 +599,7 @@ static struct option lgopts[] = {
 	{ EVT_PROD_CRYPTODEV,      0, 0, 0 },
 	{ EVT_PROD_TIMERDEV,       0, 0, 0 },
 	{ EVT_PROD_TIMERDEV_BURST, 0, 0, 0 },
+	{ EVT_PROD_VECTOR,         0, 0, 0 },
 	{ EVT_DMA_ADPTR_MODE,      1, 0, 0 },
 	{ EVT_CRYPTO_ADPTR_MODE,   1, 0, 0 },
 	{ EVT_CRYPTO_OP_TYPE,	   1, 0, 0 },
@@ -642,6 +651,7 @@ evt_opts_parse_long(int opt_idx, struct evt_options *opt)
 		{ EVT_PROD_DMADEV, evt_parse_dma_prod_type},
 		{ EVT_PROD_TIMERDEV, evt_parse_timer_prod_type},
 		{ EVT_PROD_TIMERDEV_BURST, evt_parse_timer_prod_type_burst},
+		{ EVT_PROD_VECTOR, evt_parse_vector_prod_type },
 		{ EVT_DMA_ADPTR_MODE, evt_parse_dma_adptr_mode},
 		{ EVT_CRYPTO_ADPTR_MODE, evt_parse_crypto_adptr_mode},
 		{ EVT_CRYPTO_OP_TYPE, evt_parse_crypto_op_type},
@@ -721,4 +731,8 @@ evt_options_dump(struct evt_options *opt)
 	evt_dump_end;
 	evt_dump_nb_flows(opt);
 	evt_dump_worker_dequeue_depth(opt);
+	if (opt->ena_vector || opt->prod_type == EVT_PROD_TYPE_EVENT_VECTOR_ADPTR) {
+		evt_dump("vector_sz", "%d", opt->vector_size);
+		evt_dump("vector_tmo_ns", "%"PRIu64, opt->vector_tmo_nsec);
+	}
 }
diff --git a/app/test-eventdev/evt_options.h b/app/test-eventdev/evt_options.h
index 18a893b704..4bf712bd19 100644
--- a/app/test-eventdev/evt_options.h
+++ b/app/test-eventdev/evt_options.h
@@ -38,6 +38,7 @@
 #define EVT_PROD_DMADEV          ("prod_type_dmadev")
 #define EVT_PROD_TIMERDEV        ("prod_type_timerdev")
 #define EVT_PROD_TIMERDEV_BURST  ("prod_type_timerdev_burst")
+#define EVT_PROD_VECTOR          ("prod_type_vector")
 #define EVT_DMA_ADPTR_MODE       ("dma_adptr_mode")
 #define EVT_CRYPTO_ADPTR_MODE	 ("crypto_adptr_mode")
 #define EVT_CRYPTO_OP_TYPE	 ("crypto_op_type")
diff --git a/app/test-eventdev/test_perf_atq.c b/app/test-eventdev/test_perf_atq.c
index 30c34edabd..b07b010af1 100644
--- a/app/test-eventdev/test_perf_atq.c
+++ b/app/test-eventdev/test_perf_atq.c
@@ -145,7 +145,7 @@ perf_atq_worker_burst(void *arg, const int enable_fwd_latency)
 }
 
 static int
-perf_atq_worker_vector(void *arg, const int enable_fwd_latency)
+perf_atq_worker_crypto_vector(void *arg, const int enable_fwd_latency)
 {
 	uint16_t enq = 0, deq = 0;
 	struct rte_event ev;
@@ -161,10 +161,8 @@ perf_atq_worker_vector(void *arg, const int enable_fwd_latency)
 		if (!deq)
 			continue;
 
-		if (ev.event_type == RTE_EVENT_TYPE_CRYPTODEV_VECTOR) {
-			if (perf_handle_crypto_vector_ev(&ev, &pe, enable_fwd_latency))
-				continue;
-		}
+		if (perf_handle_crypto_vector_ev(&ev, &pe, enable_fwd_latency))
+			continue;
 
 		stage = ev.sub_event_type % nb_stages;
 		/* First q in pipeline, mark timestamp to compute fwd latency */
@@ -173,8 +171,8 @@ perf_atq_worker_vector(void *arg, const int enable_fwd_latency)
 
 		/* Last stage in pipeline */
 		if (unlikely(stage == laststage)) {
-			perf_process_vector_last_stage(pool, t->ca_op_pool, &ev, w,
-							enable_fwd_latency);
+			perf_process_crypto_vector_last_stage(pool, t->ca_op_pool, &ev, w,
+							      enable_fwd_latency);
 		} else {
 			atq_fwd_event_vector(&ev, sched_type_list, nb_stages);
 			do {
@@ -188,6 +186,53 @@ perf_atq_worker_vector(void *arg, const int enable_fwd_latency)
 	return 0;
 }
 
+static int
+perf_atq_worker_vector(void *arg, const int enable_fwd_latency)
+{
+	uint16_t enq = 0, deq = 0;
+	struct rte_event ev;
+	PERF_WORKER_INIT;
+
+	RTE_SET_USED(sz);
+	RTE_SET_USED(pe);
+	RTE_SET_USED(cnt);
+	RTE_SET_USED(prod_type);
+	RTE_SET_USED(prod_timer_type);
+
+	while (t->done == false) {
+		deq = rte_event_dequeue_burst(dev, port, &ev, 1, 0);
+		if (!deq)
+			continue;
+
+		if (ev.event_type != RTE_EVENT_TYPE_CPU_VECTOR) {
+			w->processed_pkts++;
+			continue;
+		}
+
+		stage = ev.sub_event_type % nb_stages;
+		if (enable_fwd_latency && stage == 0)
+			/* first stage in pipeline, mark ts to compute fwd latency */
+			ev.vec->u64s[0] = rte_get_timer_cycles();
+
+		/* Last stage in pipeline */
+		if (unlikely(stage == laststage)) {
+			w->processed_vecs++;
+			if (enable_fwd_latency)
+				w->latency += rte_get_timer_cycles() - ev.vec->u64s[0];
+
+			rte_mempool_put(pool, ev.event_ptr);
+		} else {
+			atq_fwd_event_vector(&ev, sched_type_list, nb_stages);
+			do {
+				enq = rte_event_enqueue_burst(dev, port, &ev, 1);
+			} while (!enq && !t->done);
+		}
+	}
+	perf_worker_cleanup(pool, dev, port, &ev, enq, deq);
+
+	return 0;
+}
+
 static int
 worker_wrapper(void *arg)
 {
@@ -199,6 +244,8 @@ worker_wrapper(void *arg)
 
 	/* allow compiler to optimize */
 	if (opt->ena_vector && opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
+		return perf_atq_worker_crypto_vector(arg, fwd_latency);
+	else if (opt->prod_type == EVT_PROD_TYPE_EVENT_VECTOR_ADPTR)
 		return perf_atq_worker_vector(arg, fwd_latency);
 	else if (!burst && !fwd_latency)
 		return perf_atq_worker(arg, 0);
diff --git a/app/test-eventdev/test_perf_common.c b/app/test-eventdev/test_perf_common.c
index 627f07caa1..4709de8b07 100644
--- a/app/test-eventdev/test_perf_common.c
+++ b/app/test-eventdev/test_perf_common.c
@@ -102,16 +102,20 @@ perf_test_result(struct evt_test *test, struct evt_options *opt)
 	int i;
 	uint64_t total = 0;
 	struct test_perf *t = evt_test_priv(test);
+	uint8_t is_vec;
 
 	printf("Packet distribution across worker cores :\n");
+	is_vec = (opt->prod_type == EVT_PROD_TYPE_EVENT_VECTOR_ADPTR);
 	for (i = 0; i < t->nb_workers; i++)
-		total += t->worker[i].processed_pkts;
+		total += is_vec ? t->worker[i].processed_vecs : t->worker[i].processed_pkts;
 	for (i = 0; i < t->nb_workers; i++)
-		printf("Worker %d packets: "CLGRN"%"PRIx64" "CLNRM"percentage:"
-				CLGRN" %3.2f"CLNRM"\n", i,
-				t->worker[i].processed_pkts,
-				(((double)t->worker[i].processed_pkts)/total)
-				* 100);
+		printf("Worker %d packets: " CLGRN "%" PRIx64 " " CLNRM "percentage:" CLGRN
+		       " %3.2f" CLNRM "\n",
+		       i, is_vec ? t->worker[i].processed_vecs : t->worker[i].processed_pkts,
+		       (((double)(is_vec ? t->worker[i].processed_vecs :
+					   t->worker[i].processed_pkts)) /
+			total) *
+			       100);
 
 	return t->result;
 }
@@ -887,6 +891,31 @@ perf_event_crypto_producer_burst(void *arg)
 	return 0;
 }
 
+static int
+perf_event_vector_producer(struct prod_data *p)
+{
+	struct rte_event_vector_adapter *adptr = p->va.vector_adptr;
+	struct evt_options *opt = p->t->opt;
+	const struct test_perf *t = p->t;
+	uint64_t objs[BURST_SIZE];
+	uint16_t enq;
+
+	if (opt->verbose_level > 1)
+		printf("%s(): lcore %d vector adapter %p\n", __func__, rte_lcore_id(), adptr);
+
+	while (t->done == false) {
+		enq = rte_event_vector_adapter_enqueue(adptr, objs, BURST_SIZE, 0);
+		while (enq < BURST_SIZE) {
+			enq += rte_event_vector_adapter_enqueue(adptr, objs + enq, BURST_SIZE - enq,
+								0);
+			if (t->done)
+				break;
+			rte_pause();
+		}
+	}
+	return 0;
+}
+
 static int
 perf_producer_wrapper(void *arg)
 {
@@ -930,6 +959,8 @@ perf_producer_wrapper(void *arg)
 			return perf_event_crypto_producer(arg);
 	} else if (t->opt->prod_type == EVT_PROD_TYPE_EVENT_DMA_ADPTR)
 		return perf_event_dma_producer(arg);
+	else if (t->opt->prod_type == EVT_PROD_TYPE_EVENT_VECTOR_ADPTR)
+		return perf_event_vector_producer(p);
 
 	return 0;
 }
@@ -947,115 +978,103 @@ processed_pkts(struct test_perf *t)
 }
 
 static inline uint64_t
-total_latency(struct test_perf *t)
+processed_vecs(struct test_perf *t)
 {
 	uint8_t i;
 	uint64_t total = 0;
 
 	for (i = 0; i < t->nb_workers; i++)
-		total += t->worker[i].latency;
+		total += t->worker[i].processed_vecs;
 
 	return total;
 }
 
-
-int
-perf_launch_lcores(struct evt_test *test, struct evt_options *opt,
-		int (*worker)(void *))
+static inline uint64_t
+total_latency(struct test_perf *t)
 {
-	int ret, lcore_id;
-	struct test_perf *t = evt_test_priv(test);
-
-	int port_idx = 0;
-	/* launch workers */
-	RTE_LCORE_FOREACH_WORKER(lcore_id) {
-		if (!(opt->wlcores[lcore_id]))
-			continue;
-
-		ret = rte_eal_remote_launch(worker,
-				 &t->worker[port_idx], lcore_id);
-		if (ret) {
-			evt_err("failed to launch worker %d", lcore_id);
-			return ret;
-		}
-		port_idx++;
-	}
-
-	/* launch producers */
-	RTE_LCORE_FOREACH_WORKER(lcore_id) {
-		if (!(opt->plcores[lcore_id]))
-			continue;
+	uint8_t i;
+	uint64_t total = 0;
 
-		ret = rte_eal_remote_launch(perf_producer_wrapper,
-				&t->prod[port_idx], lcore_id);
-		if (ret) {
-			evt_err("failed to launch perf_producer %d", lcore_id);
-			return ret;
-		}
-		port_idx++;
-	}
+	for (i = 0; i < t->nb_workers; i++)
+		total += t->worker[i].latency;
 
-	const uint64_t total_pkts = t->outstand_pkts;
+	return total;
+}
 
-	uint64_t dead_lock_cycles = rte_get_timer_cycles();
-	int64_t dead_lock_remaining  =  total_pkts;
+static void
+check_work_status(struct test_perf *t, struct evt_options *opt)
+{
 	const uint64_t dead_lock_sample = rte_get_timer_hz() * 5;
-
+	const uint64_t freq_mhz = rte_get_timer_hz() / 1000000;
+	uint64_t dead_lock_cycles = rte_get_timer_cycles();
+	const uint64_t perf_sample = rte_get_timer_hz();
 	uint64_t perf_cycles = rte_get_timer_cycles();
+	const uint64_t total_pkts = t->outstand_pkts;
+	int64_t dead_lock_remaining = total_pkts;
 	int64_t perf_remaining  = total_pkts;
-	const uint64_t perf_sample = rte_get_timer_hz();
-
-	static float total_mpps;
 	static uint64_t samples;
+	static float total_mpps;
+	int64_t remaining;
+	uint8_t is_vec;
 
-	const uint64_t freq_mhz = rte_get_timer_hz() / 1000000;
-	int64_t remaining = t->outstand_pkts - processed_pkts(t);
+	is_vec = (t->opt->prod_type == EVT_PROD_TYPE_EVENT_VECTOR_ADPTR);
+	remaining = t->outstand_pkts - (is_vec ? processed_vecs(t) : processed_pkts(t));
 
 	while (t->done == false) {
 		const uint64_t new_cycles = rte_get_timer_cycles();
 
 		if ((new_cycles - perf_cycles) > perf_sample) {
 			const uint64_t latency = total_latency(t);
-			const uint64_t pkts = processed_pkts(t);
+			const uint64_t pkts = is_vec ? processed_vecs(t) : processed_pkts(t);
+			uint64_t fallback_pkts = processed_pkts(t);
 
 			remaining = t->outstand_pkts - pkts;
-			float mpps = (float)(perf_remaining-remaining)/1000000;
+			float mpps = (float)(perf_remaining - remaining) / 1E6;
 
 			perf_remaining = remaining;
 			perf_cycles = new_cycles;
 			total_mpps += mpps;
 			++samples;
+
 			if (opt->fwd_latency && pkts > 0) {
-				printf(CLGRN"\r%.3f mpps avg %.3f mpps [avg fwd latency %.3f us] "CLNRM,
-					mpps, total_mpps/samples,
-					(float)(latency/pkts)/freq_mhz);
+				if (is_vec) {
+					printf(CLGRN
+					       "\r%.3f mvps avg %.3f mvps [avg fwd latency %.3f us] "
+					       "fallback mpps %.3f" CLNRM,
+					       mpps, total_mpps / samples,
+					       (float)(latency / pkts) / freq_mhz,
+					       fallback_pkts / 1E6);
+				} else {
+					printf(CLGRN
+					       "\r%.3f mpps avg %.3f mpps [avg fwd latency %.3f us] "
+					       CLNRM,
+					       mpps, total_mpps / samples,
+					       (float)(latency / pkts) / freq_mhz);
+				}
 			} else {
-				printf(CLGRN"\r%.3f mpps avg %.3f mpps"CLNRM,
-					mpps, total_mpps/samples);
+				if (is_vec) {
+					printf(CLGRN
+					       "\r%.3f mvps avg %.3f mvps fallback mpps %.3f" CLNRM,
+					       mpps, total_mpps / samples, fallback_pkts / 1E6);
+				} else {
+					printf(CLGRN "\r%.3f mpps avg %.3f mpps" CLNRM, mpps,
+					       total_mpps / samples);
+				}
 			}
 			fflush(stdout);
 
 			if (remaining <= 0) {
 				t->result = EVT_TEST_SUCCESS;
-				if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
-				    opt->prod_type ==
-					    EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
-				    opt->prod_type ==
-					    EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR ||
-				    opt->prod_type ==
-					    EVT_PROD_TYPE_EVENT_DMA_ADPTR) {
+				if (opt->prod_type != EVT_PROD_TYPE_ETH_RX_ADPTR) {
 					t->done = true;
 					break;
 				}
 			}
 		}
-
 		if (new_cycles - dead_lock_cycles > dead_lock_sample &&
-		    (opt->prod_type == EVT_PROD_TYPE_SYNT ||
-		     opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
-		     opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR ||
-		     opt->prod_type == EVT_PROD_TYPE_EVENT_DMA_ADPTR)) {
-			remaining = t->outstand_pkts - processed_pkts(t);
+		    (opt->prod_type != EVT_PROD_TYPE_ETH_RX_ADPTR)) {
+			remaining =
+				t->outstand_pkts - (is_vec ? processed_vecs(t) : processed_pkts(t));
 			if (dead_lock_remaining == remaining) {
 				rte_event_dev_dump(opt->dev_id, stdout);
 				evt_err("No schedules for seconds, deadlock");
@@ -1067,6 +1086,45 @@ perf_launch_lcores(struct evt_test *test, struct evt_options *opt,
 		}
 	}
 	printf("\n");
+}
+
+int
+perf_launch_lcores(struct evt_test *test, struct evt_options *opt, int (*worker)(void *))
+{
+	int ret, lcore_id;
+	struct test_perf *t = evt_test_priv(test);
+
+	int port_idx = 0;
+	/* launch workers */
+	RTE_LCORE_FOREACH_WORKER(lcore_id)
+	{
+		if (!(opt->wlcores[lcore_id]))
+			continue;
+
+		ret = rte_eal_remote_launch(worker, &t->worker[port_idx], lcore_id);
+		if (ret) {
+			evt_err("failed to launch worker %d", lcore_id);
+			return ret;
+		}
+		port_idx++;
+	}
+
+	/* launch producers */
+	RTE_LCORE_FOREACH_WORKER(lcore_id)
+	{
+		if (!(opt->plcores[lcore_id]))
+			continue;
+
+		ret = rte_eal_remote_launch(perf_producer_wrapper, &t->prod[port_idx], lcore_id);
+		if (ret) {
+			evt_err("failed to launch perf_producer %d", lcore_id);
+			return ret;
+		}
+		port_idx++;
+	}
+
+	check_work_status(t, opt);
+
 	return 0;
 }
 
@@ -1564,6 +1622,70 @@ perf_event_dev_port_setup(struct evt_test *test, struct evt_options *opt,
 
 			prod++;
 		}
+	} else if (opt->prod_type == EVT_PROD_TYPE_EVENT_VECTOR_ADPTR) {
+		struct rte_event_vector_adapter_conf conf;
+		struct rte_event_vector_adapter_info info;
+
+		ret = rte_event_vector_adapter_info_get(opt->dev_id, &info);
+
+		if (opt->vector_size < info.min_vector_sz ||
+		    opt->vector_size > info.max_vector_sz) {
+			evt_err("Vector size [%d] not within limits max[%d] min[%d]",
+				opt->vector_size, info.max_vector_sz, info.min_vector_sz);
+			return -EINVAL;
+		}
+
+		if (opt->vector_tmo_nsec > info.max_vector_timeout_ns ||
+		    opt->vector_tmo_nsec < info.min_vector_timeout_ns) {
+			evt_err("Vector timeout [%" PRIu64 "] not within limits "
+				"max[%" PRIu64 "] min[%" PRIu64 "]",
+				opt->vector_tmo_nsec, info.max_vector_timeout_ns,
+				info.min_vector_timeout_ns);
+			return -EINVAL;
+		}
+
+		memset(&conf, 0, sizeof(struct rte_event_vector_adapter_conf));
+		conf.event_dev_id = opt->dev_id;
+		conf.vector_sz = opt->vector_size;
+		conf.vector_timeout_ns = opt->vector_tmo_nsec;
+		conf.socket_id = opt->socket_id;
+		conf.vector_mp = t->pool;
+
+		conf.ev.sched_type = opt->sched_type_list[0];
+		conf.ev.event_type = RTE_EVENT_TYPE_VECTOR | RTE_EVENT_TYPE_CPU;
+
+		conf.ev_fallback.event_type = RTE_EVENT_TYPE_CPU;
+
+		prod = 0;
+		for (; port < perf_nb_event_ports(opt); port++) {
+			struct rte_event_vector_adapter *vector_adptr;
+			struct prod_data *p = &t->prod[port];
+			uint32_t service_id;
+
+			p->queue_id = prod * stride;
+			p->t = t;
+
+			conf.ev.queue_id = p->queue_id;
+
+			vector_adptr = rte_event_vector_adapter_create(&conf);
+			if (vector_adptr == NULL) {
+				evt_err("Failed to create vector adapter for port %d", port);
+				return -ENOMEM;
+			}
+			p->va.vector_adptr = vector_adptr;
+			prod++;
+
+			if (rte_event_vector_adapter_service_id_get(vector_adptr, &service_id) ==
+			    0) {
+				ret = evt_service_setup(service_id);
+				if (ret) {
+					evt_err("Failed to setup service core"
+						" for vector adapter\n");
+					return ret;
+				}
+				rte_service_runstate_set(service_id, 1);
+			}
+		}
 	} else {
 		prod = 0;
 		for ( ; port < perf_nb_event_ports(opt); port++) {
@@ -1728,6 +1850,20 @@ perf_eventdev_destroy(struct evt_test *test, struct evt_options *opt)
 		for (i = 0; i < opt->nb_timer_adptrs; i++)
 			rte_event_timer_adapter_stop(t->timer_adptr[i]);
 	}
+
+	if (opt->prod_type == EVT_PROD_TYPE_EVENT_VECTOR_ADPTR) {
+		for (i = 0; i < evt_nr_active_lcores(opt->plcores); i++) {
+			struct prod_data *p = &t->prod[i];
+			uint32_t service_id;
+
+			if (p->va.vector_adptr) {
+				if (rte_event_vector_adapter_service_id_get(p->va.vector_adptr,
+									    &service_id) == 0)
+					rte_service_runstate_set(service_id, 0);
+				rte_event_vector_adapter_destroy(p->va.vector_adptr);
+			}
+		}
+	}
 	rte_event_dev_stop(opt->dev_id);
 	rte_event_dev_close(opt->dev_id);
 }
@@ -2119,6 +2255,9 @@ perf_mempool_setup(struct evt_test *test, struct evt_options *opt)
 					     cache_sz,		       /* cache size*/
 					     0, NULL, NULL, NULL,      /* obj constructor */
 					     NULL, opt->socket_id, 0); /* flags */
+	} else if (opt->prod_type == EVT_PROD_TYPE_EVENT_VECTOR_ADPTR) {
+		t->pool = rte_event_vector_pool_create(test->name, opt->pool_sz, cache_sz,
+						       opt->vector_size, opt->socket_id);
 	} else {
 		t->pool = rte_pktmbuf_pool_create(test->name, /* mempool name */
 				opt->pool_sz, /* number of elements*/
diff --git a/app/test-eventdev/test_perf_common.h b/app/test-eventdev/test_perf_common.h
index d7333ad390..99df008cc7 100644
--- a/app/test-eventdev/test_perf_common.h
+++ b/app/test-eventdev/test_perf_common.h
@@ -16,6 +16,7 @@
 #include <rte_event_eth_rx_adapter.h>
 #include <rte_event_eth_tx_adapter.h>
 #include <rte_event_timer_adapter.h>
+#include <rte_event_vector_adapter.h>
 #include <rte_eventdev.h>
 #include <rte_lcore.h>
 #include <rte_malloc.h>
@@ -33,6 +34,7 @@ struct test_perf;
 
 struct __rte_cache_aligned worker_data {
 	uint64_t processed_pkts;
+	uint64_t processed_vecs;
 	uint64_t latency;
 	uint8_t dev_id;
 	uint8_t port_id;
@@ -50,12 +52,17 @@ struct dma_adptr_data {
 	uint16_t vchan_id;
 };
 
+struct vector_adptr_data {
+	struct rte_event_vector_adapter *vector_adptr;
+};
+
 struct __rte_cache_aligned prod_data {
 	uint8_t dev_id;
 	uint8_t port_id;
 	uint8_t queue_id;
 	struct crypto_adptr_data ca;
 	struct dma_adptr_data da;
+	struct vector_adptr_data va;
 	struct test_perf *t;
 };
 
@@ -320,9 +327,9 @@ perf_process_last_stage_latency(struct rte_mempool *const pool, enum evt_prod_ty
 }
 
 static __rte_always_inline void
-perf_process_vector_last_stage(struct rte_mempool *const pool,
-		struct rte_mempool *const ca_pool, struct rte_event *const ev,
-		struct worker_data *const w, const bool enable_fwd_latency)
+perf_process_crypto_vector_last_stage(struct rte_mempool *const pool,
+				      struct rte_mempool *const ca_pool, struct rte_event *const ev,
+				      struct worker_data *const w, const bool enable_fwd_latency)
 {
 	struct rte_event_vector *vec = ev->vec;
 	struct rte_crypto_op *cop;
diff --git a/app/test-eventdev/test_perf_queue.c b/app/test-eventdev/test_perf_queue.c
index 58715a2537..36fe94e190 100644
--- a/app/test-eventdev/test_perf_queue.c
+++ b/app/test-eventdev/test_perf_queue.c
@@ -147,7 +147,7 @@ perf_queue_worker_burst(void *arg, const int enable_fwd_latency)
 }
 
 static int
-perf_queue_worker_vector(void *arg, const int enable_fwd_latency)
+perf_queue_worker_crypto_vector(void *arg, const int enable_fwd_latency)
 {
 	uint16_t enq = 0, deq = 0;
 	struct rte_event ev;
@@ -163,10 +163,8 @@ perf_queue_worker_vector(void *arg, const int enable_fwd_latency)
 		if (!deq)
 			continue;
 
-		if (ev.event_type == RTE_EVENT_TYPE_CRYPTODEV_VECTOR) {
-			if (perf_handle_crypto_vector_ev(&ev, &pe, enable_fwd_latency))
-				continue;
-		}
+		if (perf_handle_crypto_vector_ev(&ev, &pe, enable_fwd_latency))
+			continue;
 
 		stage = ev.queue_id % nb_stages;
 		/* First q in pipeline, mark timestamp to compute fwd latency */
@@ -175,8 +173,8 @@ perf_queue_worker_vector(void *arg, const int enable_fwd_latency)
 
 		/* Last stage in pipeline */
 		if (unlikely(stage == laststage)) {
-			perf_process_vector_last_stage(pool, t->ca_op_pool, &ev, w,
-						       enable_fwd_latency);
+			perf_process_crypto_vector_last_stage(pool, t->ca_op_pool, &ev, w,
+							      enable_fwd_latency);
 		} else {
 			fwd_event_vector(&ev, sched_type_list, nb_stages);
 			do {
@@ -190,6 +188,52 @@ perf_queue_worker_vector(void *arg, const int enable_fwd_latency)
 	return 0;
 }
 
+static int
+perf_queue_worker_vector(void *arg, const int enable_fwd_latency)
+{
+	uint16_t enq = 0, deq = 0;
+	struct rte_event ev;
+	PERF_WORKER_INIT;
+
+	RTE_SET_USED(pe);
+	RTE_SET_USED(sz);
+	RTE_SET_USED(cnt);
+	RTE_SET_USED(prod_type);
+	RTE_SET_USED(prod_timer_type);
+
+	while (t->done == false) {
+		deq = rte_event_dequeue_burst(dev, port, &ev, 1, 0);
+		if (!deq)
+			continue;
+
+		if (ev.event_type != RTE_EVENT_TYPE_CPU_VECTOR) {
+			w->processed_pkts++;
+			continue;
+		}
+
+		stage = ev.sub_event_type % nb_stages;
+		if (enable_fwd_latency && stage == 0)
+			/* first stage in pipeline, mark ts to compute fwd latency */
+			ev.vec->u64s[0] = rte_get_timer_cycles();
+
+		/* Last stage in pipeline */
+		if (unlikely(stage == laststage)) {
+			w->processed_vecs++;
+			if (enable_fwd_latency)
+				w->latency += rte_get_timer_cycles() - ev.vec->u64s[0];
+			rte_mempool_put(pool, ev.event_ptr);
+		} else {
+			fwd_event_vector(&ev, sched_type_list, nb_stages);
+			do {
+				enq = rte_event_enqueue_burst(dev, port, &ev, 1);
+			} while (!enq && !t->done);
+		}
+	}
+	perf_worker_cleanup(pool, dev, port, &ev, enq, deq);
+
+	return 0;
+}
+
 static int
 worker_wrapper(void *arg)
 {
@@ -201,6 +245,8 @@ worker_wrapper(void *arg)
 
 	/* allow compiler to optimize */
 	if (opt->ena_vector && opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
+		return perf_queue_worker_crypto_vector(arg, fwd_latency);
+	else if (opt->prod_type == EVT_PROD_TYPE_EVENT_VECTOR_ADPTR)
 		return perf_queue_worker_vector(arg, fwd_latency);
 	else if (!burst && !fwd_latency)
 		return perf_queue_worker(arg, 0);
@@ -234,8 +280,10 @@ perf_queue_eventdev_setup(struct evt_test *test, struct evt_options *opt)
 
 	nb_ports = evt_nr_active_lcores(opt->wlcores);
 	nb_ports += opt->prod_type == EVT_PROD_TYPE_ETH_RX_ADPTR ||
-		opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR ? 0 :
-		evt_nr_active_lcores(opt->plcores);
+				    opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
+				    opt->prod_type == EVT_PROD_TYPE_EVENT_VECTOR_ADPTR ?
+			    0 :
+			    evt_nr_active_lcores(opt->plcores);
 
 	nb_queues = perf_queue_nb_event_queues(opt);
 
diff --git a/doc/guides/rel_notes/release_25_07.rst b/doc/guides/rel_notes/release_25_07.rst
index e6e84eeec6..a17ab13a00 100644
--- a/doc/guides/rel_notes/release_25_07.rst
+++ b/doc/guides/rel_notes/release_25_07.rst
@@ -61,6 +61,11 @@ New Features
     model by introducing APIs that allow applications to offload creation of
     event vectors.
 
+* **Added vector adapter producer mode in eventdev test.**
+
+  Added vector adapter producer mode to measure performance of event vector
+  adapter.
+
 
 Removed Items
 -------------
diff --git a/doc/guides/tools/testeventdev.rst b/doc/guides/tools/testeventdev.rst
index 58f373b867..c4e1047fbb 100644
--- a/doc/guides/tools/testeventdev.rst
+++ b/doc/guides/tools/testeventdev.rst
@@ -130,6 +130,10 @@ The following are the application command-line options:
 
         Use DMA device as producer.
 
+* ``--prod_type_vector``
+
+        Use event vector adapter as producer.
+
 * ``--timer_tick_nsec``
 
        Used to dictate number of nano seconds between bucket traversal of the
@@ -635,6 +639,7 @@ Supported application command line options are following::
         --prod_type_timerdev
         --prod_type_cryptodev
         --prod_type_dmadev
+        --prod_type_vector
         --prod_enq_burst_sz
         --timer_tick_nsec
         --max_tmo_nsec
@@ -756,6 +761,7 @@ Supported application command line options are following::
         --prod_type_timerdev
         --prod_type_cryptodev
         --prod_type_dmadev
+        --prod_type_vector
         --timer_tick_nsec
         --max_tmo_nsec
         --expiry_nsec
-- 
2.43.0