ring: add the second version of the RTS interface
PATCH v2 1/1 ring: add the second version of the RTS interface
The timing of the update of the RTS enqueues/dequeues tail is limited to the last enqueues/dequeues, which reduces concurrency, so the RTS interface of the V2 version is added, which makes the tail of the enqueues/dequeues not limited to the last enqueues/dequeues and thus enables timely updates to increase concurrency.
Add some corresponding test cases.
Signed-off-by Huichao Cai <[email protected]>
--- app/test/meson.build | 1 + app/test/test_ring.c | 26 +++ app/test/test_ring_rts_v2_stress.c | 32 ++++ app/test/test_ring_stress.c | 3 + app/test/test_ring_stress.h | 1 + devtools/libabigail.abignore | 6 + doc/guides/rel_notes/release_25_03.rst | 2 + lib/ring/rte_ring.c | 54 ++++++- lib/ring/rte_ring.h | 12 ++ lib/ring/rte_ring_core.h | 9 ++ lib/ring/rte_ring_elem.h | 18 +++ lib/ring/rte_ring_rts.h | 216 ++++++++++++++++++++++++- lib/ring/rte_ring_rts_elem_pvt.h | 168 +++++++++++++++++++ 13 files changed, 538 insertions(+), 10 deletions(-) create mode 100644 app/test/test_ring_rts_v2_stress.c
app/test/meson.build +1 -0
@@ -166,6 +166,7 @@ source_file_deps = { 'test_ring_mt_peek_stress_zc.c': ['ptr_compress'], 'test_ring_perf.c': ['ptr_compress'], 'test_ring_rts_stress.c': ['ptr_compress'], + 'test_ring_rts_v2_stress.c': ['ptr_compress'], 'test_ring_st_peek_stress.c': ['ptr_compress'], 'test_ring_st_peek_stress_zc.c': ['ptr_compress'], 'test_ring_stress.c': ['ptr_compress'],
app/test/test_ring.c +26 -0
@@ -284,6 +284,19 @@ static const struct { .felem = rte_ring_dequeue_bulk_elem, }, }, + { + .desc = "MP_RTS/MC_RTS V2 sync mode", + .api_type = TEST_RING_ELEM_BULK | TEST_RING_THREAD_DEF, + .create_flags = RING_F_MP_RTS_V2_ENQ | RING_F_MC_RTS_V2_DEQ, + .enq = { + .flegacy = rte_ring_enqueue_bulk, + .felem = rte_ring_enqueue_bulk_elem, + }, + .deq = { + .flegacy = rte_ring_dequeue_bulk, + .felem = rte_ring_dequeue_bulk_elem, + }, + }, { .desc = "MP_HTS/MC_HTS sync mode", .api_type = TEST_RING_ELEM_BULK | TEST_RING_THREAD_DEF,
@@ -349,6 +362,19 @@ static const struct { .felem = rte_ring_dequeue_burst_elem, }, }, + { + .desc = "MP_RTS/MC_RTS V2 sync mode", + .api_type = TEST_RING_ELEM_BURST | TEST_RING_THREAD_DEF, + .create_flags = RING_F_MP_RTS_V2_ENQ | RING_F_MC_RTS_V2_DEQ, + .enq = { + .flegacy = rte_ring_enqueue_burst, + .felem = rte_ring_enqueue_burst_elem, + }, + .deq = { + .flegacy = rte_ring_dequeue_burst, + .felem = rte_ring_dequeue_burst_elem, + }, + }, { .desc = "MP_HTS/MC_HTS sync mode", .api_type = TEST_RING_ELEM_BURST | TEST_RING_THREAD_DEF,
app/test/test_ring_rts_v2_stress.c new file +32 -0
@@ -0,0 +1,32 @@ +/* SPDX-License-Identifier: BSD-3-Clause +* Copyright(c) 2020 Intel Corporation +*/ + +#include "test_ring_stress_impl.h" + +static inline uint32_t +_st_ring_dequeue_bulk (struct rte_ring *r,void **obj,uint32_t n, +uint32_t *avail) +{ +return rte_ring_mc_rts_v2_dequeue_bulk (r, obj, n, avail); +} + +static inline uint32_t +_st_ring_enqueue_bulk (struct rte_ring *r,void *const *obj,uint32_t n, +uint32_t *free) +{ +return rte_ring_mp_rts_v2_enqueue_bulk (r, obj, n, free); +} + +static int +_st_ring_init (struct rte_ring *r,const char *name,uint32_t num) +{ +return rte_ring_init (r, name, num, +RING_F_MP_RTS_V2_ENQ |RING_F_MC_RTS_V2_DEQ ); +} + +const struct test test_ring_rts_v2_stress = { + .name ="MT_RTS_V2" , + .nb_case =RTE_DIM (tests), + .cases = tests, +};
app/test/test_ring_stress.c +3 -0
@@ -43,6 +43,9 @@ test_ring_stress(void) n += test_ring_rts_stress.nb_case; k +=run_test (&test_ring_rts_stress); + n += test_ring_rts_v2_stress.nb_case; + k +=run_test (&test_ring_rts_v2_stress); + n += test_ring_hts_stress.nb_case; k +=run_test (&test_ring_hts_stress);
app/test/test_ring_stress.h +1 -0
@@ -34,6 +34,7 @@ struct test {extern const struct test test_ring_mpmc_stress;extern const struct test test_ring_rts_stress; +extern const struct test test_ring_rts_v2_stress;extern const struct test test_ring_hts_stress;extern const struct test test_ring_mt_peek_stress;extern const struct test test_ring_mt_peek_stress_zc;
devtools/libabigail.abignore +6 -0
@@ -33,3 +33,9 @@ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Temporary exceptions till next major ABI version ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +[suppress_type] + type_kind = struct + name = rte_ring_rts_cache +[suppress_type] + name = rte_ring_rts_headtail + has_data_member_inserted_between = {offset_of(head), end}
doc/guides/rel_notes/release_25_03.rst +2 -0
@@ -102,6 +102,8 @@ ABI Changes * No ABI change that would break compatibility with 24.11. +* ring: Added ``rte_ring_rts_cache`` structure and ``rts_cache`` field to the + ``rte_ring_rts_headtail`` structure. Known Issues ------------
lib/ring/rte_ring.c +48 -6
103 lines not on this page · raw message
lib/ring/rte_ring.h +12 -0
@@ -89,6 +89,9 @@ ssize_t rte_ring_get_memsize(unsigned int count);* - RING_F_MP_RTS_ENQ: If this flag is set, the default behavior when * using ``rte_ring_enqueue()`` or ``rte_ring_enqueue_bulk()`` * is "multi-producer RTS mode". +* - RING_F_MP_RTS_V2_ENQ: If this flag is set, the default behavior when +* using ``rte_ring_enqueue()`` or ``rte_ring_enqueue_bulk()`` +* is "multi-producer RTS V2 mode". * - RING_F_MP_HTS_ENQ: If this flag is set, the default behavior when * using ``rte_ring_enqueue()`` or ``rte_ring_enqueue_bulk()`` * is "multi-producer HTS mode".
@@ -101,6 +104,9 @@ ssize_t rte_ring_get_memsize(unsigned int count);* - RING_F_MC_RTS_DEQ: If this flag is set, the default behavior when * using ``rte_ring_dequeue()`` or ``rte_ring_dequeue_bulk()`` * is "multi-consumer RTS mode". +* - RING_F_MC_RTS_V2_DEQ: If this flag is set, the default behavior when +* using ``rte_ring_dequeue()`` or ``rte_ring_dequeue_bulk()`` +* is "multi-consumer RTS V2 mode". * - RING_F_MC_HTS_DEQ: If this flag is set, the default behavior when * using ``rte_ring_dequeue()`` or ``rte_ring_dequeue_bulk()`` * is "multi-consumer HTS mode".
@@ -149,6 +155,9 @@ int rte_ring_init(struct rte_ring *r, const char *name, unsigned int count,* - RING_F_MP_RTS_ENQ: If this flag is set, the default behavior when * using ``rte_ring_enqueue()`` or ``rte_ring_enqueue_bulk()`` * is "multi-producer RTS mode". +* - RING_F_MP_RTS_V2_ENQ: If this flag is set, the default behavior when +* using ``rte_ring_enqueue()`` or ``rte_ring_enqueue_bulk()`` +* is "multi-producer RTS V2 mode". * - RING_F_MP_HTS_ENQ: If this flag is set, the default behavior when * using ``rte_ring_enqueue()`` or ``rte_ring_enqueue_bulk()`` * is "multi-producer HTS mode".
@@ -161,6 +170,9 @@ int rte_ring_init(struct rte_ring *r, const char *name, unsigned int count,* - RING_F_MC_RTS_DEQ: If this flag is set, the default behavior when * using ``rte_ring_dequeue()`` or ``rte_ring_dequeue_bulk()`` * is "multi-consumer RTS mode". +* - RING_F_MC_RTS_V2_DEQ: If this flag is set, the default behavior when +* using ``rte_ring_dequeue()`` or ``rte_ring_dequeue_bulk()`` +* is "multi-consumer RTS V2 mode". * - RING_F_MC_HTS_DEQ: If this flag is set, the default behavior when * using ``rte_ring_dequeue()`` or ``rte_ring_dequeue_bulk()`` * is "multi-consumer HTS mode".
lib/ring/rte_ring_core.h +9 -0
@@ -55,6 +55,7 @@ enum rte_ring_sync_type {RTE_RING_SYNC_ST ,/**< single thread only */ RTE_RING_SYNC_MT_RTS ,/**< multi-thread relaxed tail sync */ RTE_RING_SYNC_MT_HTS ,/**< multi-thread head/tail sync */ + RTE_RING_SYNC_MT_RTS_V2, /**< multi-thread relaxed tail sync v2 */ };/**
@@ -82,11 +83,16 @@ union __rte_ring_rts_poscnt { } val; }; +struct rte_ring_rts_cache { +volatile RTE_ATOMIC (uint32_t ) num;/**< Number of objs. */ +}; +struct rte_ring_rts_headtail {volatile union __rte_ring_rts_poscnt tail;enum rte_ring_sync_type sync_type;/**< sync type of prod/cons */ uint32_t htd_max;/**< max allowed distance between head/tail */ volatile union __rte_ring_rts_poscnt head; +struct rte_ring_rts_cache *rts_cache;/**< Cache of prod/cons */ };union __rte_ring_hts_pos {
@@ -163,4 +169,7 @@ struct rte_ring {#define RING_F_MP_HTS_ENQ 0x0020/**< The default enqueue is "MP HTS". */ #define RING_F_MC_HTS_DEQ 0x0040/**< The default dequeue is "MC HTS". */ +#define RING_F_MP_RTS_V2_ENQ 0x0080/**< The default enqueue is "MP RTS V2". */ +#define RING_F_MC_RTS_V2_DEQ 0x0100/**< The default dequeue is "MC RTS V2". */ +#endif /* _RTE_RING_CORE_H_ */
lib/ring/rte_ring_elem.h +18 -0
@@ -71,6 +71,9 @@ ssize_t rte_ring_get_memsize_elem(unsigned int esize, unsigned int count);* - RING_F_MP_RTS_ENQ: If this flag is set, the default behavior when * using ``rte_ring_enqueue()`` or ``rte_ring_enqueue_bulk()`` * is "multi-producer RTS mode". +* - RING_F_MP_RTS_V2_ENQ: If this flag is set, the default behavior when +* using ``rte_ring_enqueue()`` or ``rte_ring_enqueue_bulk()`` +* is "multi-producer RTS V2 mode". * - RING_F_MP_HTS_ENQ: If this flag is set, the default behavior when * using ``rte_ring_enqueue()`` or ``rte_ring_enqueue_bulk()`` * is "multi-producer HTS mode".
@@ -83,6 +86,9 @@ ssize_t rte_ring_get_memsize_elem(unsigned int esize, unsigned int count);* - RING_F_MC_RTS_DEQ: If this flag is set, the default behavior when * using ``rte_ring_dequeue()`` or ``rte_ring_dequeue_bulk()`` * is "multi-consumer RTS mode". +* - RING_F_MC_RTS_V2_DEQ: If this flag is set, the default behavior when +* using ``rte_ring_dequeue()`` or ``rte_ring_dequeue_bulk()`` +* is "multi-consumer RTS V2 mode". * - RING_F_MC_HTS_DEQ: If this flag is set, the default behavior when * using ``rte_ring_dequeue()`` or ``rte_ring_dequeue_bulk()`` * is "multi-consumer HTS mode".
@@ -203,6 +209,9 @@ rte_ring_enqueue_bulk_elem(struct rte_ring *r, const void *obj_table,case RTE_RING_SYNC_MT_HTS :return rte_ring_mp_hts_enqueue_bulk_elem (r, obj_table, esize, n, free_space); +case RTE_RING_SYNC_MT_RTS_V2 : +return rte_ring_mp_rts_v2_enqueue_bulk_elem (r, obj_table, esize, n, + free_space); }/* valid ring should never reach this point */
@@ -385,6 +394,9 @@ rte_ring_dequeue_bulk_elem(struct rte_ring *r, void *obj_table,case RTE_RING_SYNC_MT_HTS :return rte_ring_mc_hts_dequeue_bulk_elem (r, obj_table, esize, n, available); +case RTE_RING_SYNC_MT_RTS_V2 : +return rte_ring_mc_rts_v2_dequeue_bulk_elem (r, obj_table, esize, + n, available); }/* valid ring should never reach this point */
@@ -571,6 +583,9 @@ rte_ring_enqueue_burst_elem(struct rte_ring *r, const void *obj_table,case RTE_RING_SYNC_MT_HTS :return rte_ring_mp_hts_enqueue_burst_elem (r, obj_table, esize, n, free_space); +case RTE_RING_SYNC_MT_RTS_V2 : +return rte_ring_mp_rts_v2_enqueue_burst_elem (r, obj_table, esize, + n, free_space); }/* valid ring should never reach this point */
@@ -681,6 +696,9 @@ rte_ring_dequeue_burst_elem(struct rte_ring *r, void *obj_table,case RTE_RING_SYNC_MT_HTS :return rte_ring_mc_hts_dequeue_burst_elem (r, obj_table, esize, n, available); +case RTE_RING_SYNC_MT_RTS_V2 : +return rte_ring_mc_rts_v2_dequeue_burst_elem (r, obj_table, esize, + n, available); }/* valid ring should never reach this point */
lib/ring/rte_ring_rts.h +212 -4
276 lines not on this page · raw message
lib/ring/rte_ring_rts_elem_pvt.h +168 -0
184 lines not on this page · raw message
Signature · 1 line
2.27.0