When application creates the timer adapter by passing
`RTE_EVENT_TIMER_ADAPTER_F_SP_PUT` flag, we can optimize the arm sequence
by removing the locking overhead.
Signed-off-by: Pavan Nikhilesh <pbhagavat...@caviumnetworks.com>
---
drivers/event/octeontx/timvf_evdev.c | 15 ++++++++---
drivers/event/octeontx/timvf_evdev.h | 2 ++
drivers/event/octeontx/timvf_worker.c | 29 +++++++++++++++++++++
drivers/event/octeontx/timvf_worker.h | 47 +++++++++++++++++++++++++++++++++++
4 files changed, 90 insertions(+), 3 deletions(-)
diff --git a/drivers/event/octeontx/timvf_evdev.c
b/drivers/event/octeontx/timvf_evdev.c
index 852e8811c..3d0e43229 100644
--- a/drivers/event/octeontx/timvf_evdev.c
+++ b/drivers/event/octeontx/timvf_evdev.c
@@ -176,6 +176,7 @@ timvf_ring_create(struct rte_event_timer_adapter *adptr)
struct timvf_ring *timr;
struct octeontx_timvf_info tinfo;
const char *mempool_ops;
+ unsigned int mp_flags = 0;
if (octeontx_timvf_info(&tinfo) < 0)
return -ENODEV;
@@ -226,6 +227,11 @@ timvf_ring_create(struct rte_event_timer_adapter *adptr)
timr->nb_chunks = nb_timers / nb_chunk_slots;
+ if (rcfg->flags & RTE_EVENT_TIMER_ADAPTER_F_SP_PUT) {
+ mp_flags = MEMPOOL_F_SP_PUT | MEMPOOL_F_SC_GET;
+ timvf_log_info("Using single producer mode");
+ }
+
timr->meta.bkt = rte_zmalloc("octeontx_timvf_bucket",
(timr->meta.nb_bkts) * sizeof(struct tim_mem_bucket),
0);
@@ -235,7 +241,7 @@ timvf_ring_create(struct rte_event_timer_adapter *adptr)
snprintf(pool_name, 30, "timvf_meta.chunk_pool%d", timr->tim_ring_id);
timr->meta.chunk_pool = (void *)rte_mempool_create_empty(pool_name,
timr->nb_chunks, TIM_CHUNK_SIZE, 0, 0, rte_socket_id(),
- 0);
+ mp_flags);
if (!timr->meta.chunk_pool) {
rte_free(timr->meta.bkt);
@@ -295,9 +301,12 @@ timvf_timer_adapter_caps_get(const struct rte_eventdev
*dev, uint64_t flags,
uint32_t *caps, const struct rte_event_timer_adapter_ops **ops)
{
RTE_SET_USED(dev);
- RTE_SET_USED(flags);
- timvf_ops.arm_burst = timvf_timer_reg_burst_mp;
+ if (flags & RTE_EVENT_TIMER_ADAPTER_F_SP_PUT)
+ timvf_ops.arm_burst = timvf_timer_reg_burst_sp;
+ else
+ timvf_ops.arm_burst = timvf_timer_reg_burst_mp;
+
timvf_ops.cancel_burst = timvf_timer_unreg_burst;
*caps = RTE_EVENT_TIMER_ADAPTER_CAP_INTERNAL_PORT;
diff --git a/drivers/event/octeontx/timvf_evdev.h
b/drivers/event/octeontx/timvf_evdev.h
index c717c19bc..232657776 100644
--- a/drivers/event/octeontx/timvf_evdev.h
+++ b/drivers/event/octeontx/timvf_evdev.h
@@ -195,6 +195,8 @@ int timvf_timer_adapter_caps_get(const struct rte_eventdev
*dev, uint64_t flags,
uint32_t *caps, const struct rte_event_timer_adapter_ops **ops);
int timvf_timer_unreg_burst(const struct rte_event_timer_adapter *adptr,
struct rte_event_timer **tim, const uint16_t nb_timers);
+int timvf_timer_reg_burst_sp(const struct rte_event_timer_adapter *adptr,
+ struct rte_event_timer **tim, const uint16_t nb_timers);
int timvf_timer_reg_burst_mp(const struct rte_event_timer_adapter *adptr,
struct rte_event_timer **tim, const uint16_t nb_timers);
void timvf_set_chunk_refill(struct timvf_ring * const timr);
diff --git a/drivers/event/octeontx/timvf_worker.c
b/drivers/event/octeontx/timvf_worker.c
index 113603616..93fd050c0 100644
--- a/drivers/event/octeontx/timvf_worker.c
+++ b/drivers/event/octeontx/timvf_worker.c
@@ -23,6 +23,35 @@ timvf_timer_unreg_burst(const struct rte_event_timer_adapter
*adptr,
return index;
}
+int
+timvf_timer_reg_burst_sp(const struct rte_event_timer_adapter *adptr,
+ struct rte_event_timer **tim, const uint16_t nb_timers)
+{
+ int ret;
+ uint16_t index;
+ struct tim_mem_entry entry;
+ struct timvf_ring *timr = adptr->data->adapter_priv;
+ for (index = 0; index < nb_timers; index++) {
+ if (unlikely(tim[index]->timeout_ticks > timr->meta.nb_bkts)) {
+ tim[index]->state = RTE_EVENT_TIMER_ERROR_TOOLATE;
+ rte_errno = EINVAL;
+ break;
+ }
+
+ entry.w0 = (tim[index]->ev.event & 0xFFC000000000) >> 6 |
+ (tim[index]->ev.event & 0xFFFFFFFF);
+ entry.wqe = tim[index]->ev.u64;
+ ret = timvf_add_entry_sp(timr, tim[index]->timeout_ticks,
+ tim[index], &entry);
+ if (unlikely(ret)) {
+ rte_errno = -ret;
+ break;
+ }
+ }
+
+ return index;
+}
+
int
timvf_timer_reg_burst_mp(const struct rte_event_timer_adapter *adptr,
struct rte_event_timer **tim, const uint16_t nb_timers)
diff --git a/drivers/event/octeontx/timvf_worker.h
b/drivers/event/octeontx/timvf_worker.h
index bba4985ab..7e197f5cd 100644
--- a/drivers/event/octeontx/timvf_worker.h
+++ b/drivers/event/octeontx/timvf_worker.h
@@ -223,6 +223,53 @@ timvf_get_target_bucket(struct timvf_ring * const timr,
const uint32_t rel_bkt)
return &timr->meta.bkt[tbkt_id];
}
+/* Single producer functions. */
+static inline int
+timvf_add_entry_sp(struct timvf_ring * const timr, const uint32_t rel_bkt,
+ struct rte_event_timer * const tim,
+ const struct tim_mem_entry * const pent)
+{
+ int16_t rem;
+ uint64_t lock_sema;
+ struct tim_mem_bucket *bkt;
+ struct tim_mem_entry *chunk;
+
+
+ bkt = timvf_get_target_bucket(timr, rel_bkt);
+__retry:
+ /*Get Bucket sema*/
+ lock_sema = timr_bkt_fetch_sema(bkt);
+ /* Bucket related checks. */
+ if (unlikely(timr_bkt_get_hbt(lock_sema)))
+ goto __retry;
+
+ /* Insert the work. */
+ rem = timr_bkt_fetch_rem(lock_sema);
+
+ if (!rem) {
+ chunk = timr->meta.refill_chunk(bkt, timr);
+ if (unlikely(chunk == NULL)) {
+ timr_bkt_set_rem(bkt, 0);
+ tim->impl_opaque[0] = tim->impl_opaque[1] = 0;
+ tim->state = RTE_EVENT_TIMER_ERROR;
+ return -ENOMEM;
+ }
+ bkt->current_chunk = (uint64_t) chunk;
+ timr_bkt_set_rem(bkt, nb_chunk_slots - 1);
+ } else {
+ chunk = (struct tim_mem_entry *)bkt->current_chunk;
+ chunk += nb_chunk_slots - rem;
+ }
+ /* Copy work entry. */
+ *chunk = *pent;
+ timr_bkt_inc_nent(bkt);
+
+ tim->impl_opaque[0] = (uint64_t)chunk;
+ tim->impl_opaque[1] = (uint64_t)bkt;
+ tim->state = RTE_EVENT_TIMER_ARMED;
+ return 0;
+}
+
/* Multi producer functions. */
static inline int
timvf_add_entry_mp(struct timvf_ring * const timr, const uint32_t rel_bkt,
--
2.16.2
