event/octeontx: add single producer timer arm variant

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 <pbhagavatula@caviumnetworks.com>

diff --git a/drivers/event/octeontx/timvf_evdev.c b/drivers/event/octeontx/timvf_evdev.c
index 5ffb460..3b698b7 100644 (file)
--- a/drivers/event/octeontx/timvf_evdev.c
+++ b/drivers/event/octeontx/timvf_evdev.c
@@ -180,6 +180,7 @@ timvf_ring_create(struct rte_event_timer_adapter *adptr)
        struct timvf_ring *timr;
        struct timvf_info tinfo;
        const char *mempool_ops;
+       unsigned int mp_flags = 0;
 
        if (timvf_info(&tinfo) < 0)
                return -ENODEV;
@@ -213,6 +214,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->bkt = rte_zmalloc("octeontx_timvf_bucket",
                        (timr->nb_bkts) * sizeof(struct tim_mem_bucket),
                        0);
@@ -222,7 +228,7 @@ timvf_ring_create(struct rte_event_timer_adapter *adptr)
        snprintf(pool_name, 30, "timvf_chunk_pool%d", timr->tim_ring_id);
        timr->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->chunk_pool) {
                rte_free(timr->bkt);
@@ -306,17 +312,20 @@ timvf_timer_adapter_caps_get(const struct rte_eventdev *dev, uint64_t flags,
                uint8_t enable_stats)
 {
        RTE_SET_USED(dev);
-       RTE_SET_USED(flags);
 
        if (enable_stats) {
                timvf_ops.stats_get   = timvf_stats_get;
                timvf_ops.stats_reset = timvf_stats_reset;
        }
 
-       if (enable_stats)
-               timvf_ops.arm_burst = timvf_timer_arm_burst_mp_stats;
+       if (flags & RTE_EVENT_TIMER_ADAPTER_F_SP_PUT)
+               timvf_ops.arm_burst = enable_stats ?
+                       timvf_timer_arm_burst_sp_stats :
+                       timvf_timer_arm_burst_sp;
        else
-               timvf_ops.arm_burst = timvf_timer_arm_burst_mp;
+               timvf_ops.arm_burst = enable_stats ?
+                       timvf_timer_arm_burst_mp_stats :
+                       timvf_timer_arm_burst_mp;
 
        timvf_ops.cancel_burst = timvf_timer_cancel_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 cae949c..01ffac0 100644 (file)
--- a/drivers/event/octeontx/timvf_evdev.h
+++ b/drivers/event/octeontx/timvf_evdev.h
@@ -197,6 +197,11 @@ int timvf_timer_adapter_caps_get(const struct rte_eventdev *dev, uint64_t flags,
                uint8_t enable_stats);
 uint16_t timvf_timer_cancel_burst(const struct rte_event_timer_adapter *adptr,
                struct rte_event_timer **tim, const uint16_t nb_timers);
+uint16_t timvf_timer_arm_burst_sp(const struct rte_event_timer_adapter *adptr,
+               struct rte_event_timer **tim, const uint16_t nb_timers);
+uint16_t timvf_timer_arm_burst_sp_stats(
+               const struct rte_event_timer_adapter *adptr,
+               struct rte_event_timer **tim, const uint16_t nb_timers);
 uint16_t timvf_timer_arm_burst_mp(const struct rte_event_timer_adapter *adptr,
                struct rte_event_timer **tim, const uint16_t nb_timers);
 uint16_t timvf_timer_arm_burst_mp_stats(

diff --git a/drivers/event/octeontx/timvf_worker.c b/drivers/event/octeontx/timvf_worker.c
index 38b16d1..52b212c 100644 (file)
--- a/drivers/event/octeontx/timvf_worker.c
+++ b/drivers/event/octeontx/timvf_worker.c
@@ -64,6 +64,43 @@ timvf_timer_cancel_burst(const struct rte_event_timer_adapter *adptr,
        return index;
 }
 
+uint16_t
+timvf_timer_arm_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 (timvf_timer_reg_checks(timr, tim[index]))
+                       break;
+
+               timvf_format_event(tim[index], &entry);
+               ret = timvf_add_entry_sp(timr, tim[index]->timeout_ticks,
+                               tim[index], &entry);
+               if (unlikely(ret)) {
+                       rte_errno = -ret;
+                       break;
+               }
+       }
+
+       return index;
+}
+
+uint16_t
+timvf_timer_arm_burst_sp_stats(const struct rte_event_timer_adapter *adptr,
+               struct rte_event_timer **tim, const uint16_t nb_timers)
+{
+       uint16_t ret;
+       struct timvf_ring *timr = adptr->data->adapter_priv;
+
+       ret = timvf_timer_arm_burst_sp(adptr, tim, nb_timers);
+       timr->tim_arm_cnt += ret;
+
+       return ret;
+}
+
 uint16_t
 timvf_timer_arm_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 c20d4d0..c3a669d 100644 (file)
--- a/drivers/event/octeontx/timvf_worker.h
+++ b/drivers/event/octeontx/timvf_worker.h
@@ -224,6 +224,53 @@ timvf_get_target_bucket(struct timvf_ring * const timr, const uint32_t rel_bkt)
        return &timr->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->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 = (uintptr_t) chunk;
+               timr_bkt_set_rem(bkt, nb_chunk_slots - 1);
+       } else {
+               chunk = (struct tim_mem_entry *)(uintptr_t)bkt->current_chunk;
+               chunk += nb_chunk_slots - rem;
+       }
+       /* Copy work entry. */
+       *chunk = *pent;
+       timr_bkt_inc_nent(bkt);
+
+       tim->impl_opaque[0] = (uintptr_t)chunk;
+       tim->impl_opaque[1] = (uintptr_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,