Add a sched_yield() syscall if the thread spins for too long, waiting other
thread to finish its operations on the ring.
That gives pre-empted thread a chance to proceed and finish with ring
enqnue/dequeue operation.
The purpose is to reduce contention on the ring. By ring_perf_test, it doesn't
shows additional perf penalty.
Signed-off-by: Cunming Liang <cunming.liang at intel.com>
---
v6 changes:
rename RTE_RING_PAUSE_REP to RTE_RING_PAUSE_REP_COUNT
set default value as '0' in configure file
v5 changes:
add RTE_RING_PAUSE_REP to config file
v4 changes:
update and add more comments on sched_yield()
v3 changes:
new patch adding sched_yield() in rte_ring to avoid long spin
config/common_bsdapp | 1 +
config/common_linuxapp | 1 +
lib/librte_ring/rte_ring.h | 31 +++++++++++++++++++++++++++----
3 files changed, 29 insertions(+), 4 deletions(-)
diff --git a/config/common_bsdapp b/config/common_bsdapp
index 57bacb8..b9a9eeb 100644
--- a/config/common_bsdapp
+++ b/config/common_bsdapp
@@ -234,6 +234,7 @@ CONFIG_RTE_PMD_PACKET_PREFETCH=y
CONFIG_RTE_LIBRTE_RING=y
CONFIG_RTE_LIBRTE_RING_DEBUG=n
CONFIG_RTE_RING_SPLIT_PROD_CONS=n
+CONFIG_RTE_RING_PAUSE_REP_COUNT=0
#
# Compile librte_mempool
diff --git a/config/common_linuxapp b/config/common_linuxapp
index d428f84..abca5ff 100644
--- a/config/common_linuxapp
+++ b/config/common_linuxapp
@@ -242,6 +242,7 @@ CONFIG_RTE_PMD_PACKET_PREFETCH=y
CONFIG_RTE_LIBRTE_RING=y
CONFIG_RTE_LIBRTE_RING_DEBUG=n
CONFIG_RTE_RING_SPLIT_PROD_CONS=n
+CONFIG_RTE_RING_PAUSE_REP_COUNT=0
#
# Compile librte_mempool
diff --git a/lib/librte_ring/rte_ring.h b/lib/librte_ring/rte_ring.h
index 39bacdd..9bc1d5e 100644
--- a/lib/librte_ring/rte_ring.h
+++ b/lib/librte_ring/rte_ring.h
@@ -127,6 +127,11 @@ struct rte_ring_debug_stats {
#define RTE_RING_NAMESIZE 32 /**< The maximum length of a ring name. */
#define RTE_RING_MZ_PREFIX "RG_"
+#ifndef RTE_RING_PAUSE_REP_COUNT
+#define RTE_RING_PAUSE_REP_COUNT 0 /**< yield after pause num of times, no
yield
+ * if RTE_RING_PAUSE_REP not defined. */
+#endif
+
/**
* An RTE ring structure.
*
@@ -410,7 +415,7 @@ __rte_ring_mp_do_enqueue(struct rte_ring *r, void * const
*obj_table,
uint32_t cons_tail, free_entries;
const unsigned max = n;
int success;
- unsigned i;
+ unsigned i, rep = 0;
uint32_t mask = r->prod.mask;
int ret;
@@ -468,9 +473,18 @@ __rte_ring_mp_do_enqueue(struct rte_ring *r, void * const
*obj_table,
* If there are other enqueues in progress that preceded us,
* we need to wait for them to complete
*/
- while (unlikely(r->prod.tail != prod_head))
+ while (unlikely(r->prod.tail != prod_head)) {
rte_pause();
+ /* Set RTE_RING_PAUSE_REP_COUNT to avoid spin too long waiting
+ * for other thread finish. It gives pre-empted thread a chance
+ * to proceed and finish with ring denqnue operation. */
+ if (RTE_RING_PAUSE_REP_COUNT &&
+ ++rep == RTE_RING_PAUSE_REP_COUNT) {
+ rep = 0;
+ sched_yield();
+ }
+ }
r->prod.tail = prod_next;
return ret;
}
@@ -589,7 +603,7 @@ __rte_ring_mc_do_dequeue(struct rte_ring *r, void
**obj_table,
uint32_t cons_next, entries;
const unsigned max = n;
int success;
- unsigned i;
+ unsigned i, rep = 0;
uint32_t mask = r->prod.mask;
/* move cons.head atomically */
@@ -634,9 +648,18 @@ __rte_ring_mc_do_dequeue(struct rte_ring *r, void
**obj_table,
* If there are other dequeues in progress that preceded us,
* we need to wait for them to complete
*/
- while (unlikely(r->cons.tail != cons_head))
+ while (unlikely(r->cons.tail != cons_head)) {
rte_pause();
+ /* Set RTE_RING_PAUSE_REP_COUNT to avoid spin too long waiting
+ * for other thread finish. It gives pre-empted thread a chance
+ * to proceed and finish with ring denqnue operation. */
+ if (RTE_RING_PAUSE_REP_COUNT &&
+ ++rep == RTE_RING_PAUSE_REP_COUNT) {
+ rep = 0;
+ sched_yield();
+ }
+ }
__RING_STAT_ADD(r, deq_success, n);
r->cons.tail = cons_next;
--
1.8.1.4
