RCU integration with LPM library
Subsystems (2)
PATCH v5 2/3 test/lpm: add LPM RCU integration functional tests
In reply to Ruifeng WangAdd positive and negative tests for API rte_lpm_rcu_qsbr_add. Also test LPM library behavior when RCU QSBR is enabled.
--- app/test/test_lpm.c | 291 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 290 insertions(+), 1 deletion(-)
app/test/test_lpm.c +290 -1
@@ -8,6 +8,7 @@#include <rte_ip.h> #include <rte_lpm.h> +#include <rte_malloc.h> #include "test.h" #include "test_xmmt_ops.h"
@@ -40,6 +41,9 @@ static int32_t test15(void);static int32_t test16 (void );static int32_t test17 (void );static int32_t test18 (void ); +static int32_t test19 (void ); +static int32_t test20 (void ); +static int32_t test21 (void );rte_lpm_test tests[] = {/* Test Cases */
@@ -61,7 +65,10 @@ rte_lpm_test tests[] = { test15, test16, test17, - test18 + test18, + test19, + test20, + test21 };#define MAX_DEPTH 32
@@ -1265,6 +1272,288 @@ test18(void)return PASS ; } +/* +* rte_lpm_rcu_qsbr_add positive and negative tests. +* - Add RCU QSBR variable to LPM +* - Add another RCU QSBR variable to LPM +* - Check returns +*/ +int32_t +test19 (void ) +{ +struct rte_lpm *lpm =NULL ; +struct rte_lpm_config config; +size_t sz; +struct rte_rcu_qsbr *qsv; +struct rte_rcu_qsbr *qsv2; +int32_t status; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + + config.max_rules =MAX_RULES ; + config.number_tbl8s =NUMBER_TBL8S ; + config.flags =0 ; + + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Create RCU QSBR variable */ + sz =rte_rcu_qsbr_get_memsize (RTE_MAX_LCORE ); + qsv = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (qsv !=NULL ); + + status =rte_rcu_qsbr_init (qsv,RTE_MAX_LCORE ); +TEST_LPM_ASSERT (status ==0 ); + + rcu_cfg.v = qsv; +/* Invalid QSBR mode */ + rcu_cfg.mode =2 ; + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status !=0 ); + + rcu_cfg.mode =RTE_LPM_QSBR_MODE_DQ ; +/* Attach RCU QSBR to LPM table */ + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status ==0 ); + +/* Create and attach another RCU QSBR to LPM table */ + qsv2 = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (qsv2 !=NULL ); + + rcu_cfg.v = qsv2; + rcu_cfg.mode =RTE_LPM_QSBR_MODE_SYNC ; + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status !=0 ); + +rte_lpm_free (lpm); +rte_free (qsv); +rte_free (qsv2); + +return PASS ; +} + +/* +* rte_lpm_rcu_qsbr_add DQ mode functional test. +* Reader and writer are in the same thread in this test. +* - Create LPM which supports 1 tbl8 group at max +* - Add RCU QSBR variable to LPM +* - Add a rule with depth=28 (> 24) +* - Register a reader thread (not a real thread) +* - Reader lookup existing rule +* - Writer delete the rule +* - Reader lookup the rule +* - Writer re-add the rule (no available tbl8 group) +* - Reader report quiescent state and unregister +* - Writer re-add the rule +* - Reader lookup the rule +*/ +int32_t +test20 (void ) +{ +struct rte_lpm *lpm =NULL ; +struct rte_lpm_config config; +size_t sz; +struct rte_rcu_qsbr *qsv; +int32_t status; +uint32_t ip, next_hop, next_hop_return; +uint8_t depth; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + + config.max_rules =MAX_RULES ; + config.number_tbl8s =1 ; + config.flags =0 ; + + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Create RCU QSBR variable */ + sz =rte_rcu_qsbr_get_memsize (1 ); + qsv = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (qsv !=NULL ); + + status =rte_rcu_qsbr_init (qsv,1 ); +TEST_LPM_ASSERT (status ==0 ); + + rcu_cfg.v = qsv; + rcu_cfg.mode =RTE_LPM_QSBR_MODE_DQ ; +/* Attach RCU QSBR to LPM table */ + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status ==0 ); + + ip =RTE_IPV4 (192 ,18 ,100 ,100 ); + depth =28 ; + next_hop =1 ; + status =rte_lpm_add (lpm, ip, depth, next_hop); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (lpm->tbl24[ip>>8 ].valid_group); + +/* Register pseudo reader */ + status =rte_rcu_qsbr_thread_register (qsv,0 ); +TEST_LPM_ASSERT (status ==0 ); +rte_rcu_qsbr_thread_online (qsv,0 ); + + status =rte_lpm_lookup (lpm, ip, &next_hop_return); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (next_hop_return == next_hop); + +/* Writer update */ + status =rte_lpm_delete (lpm, ip, depth); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (!lpm->tbl24[ip>>8 ].valid); + + status =rte_lpm_lookup (lpm, ip, &next_hop_return); +TEST_LPM_ASSERT (status !=0 ); + + status =rte_lpm_add (lpm, ip, depth, next_hop); +TEST_LPM_ASSERT (status !=0 ); + +/* Reader quiescent */ +rte_rcu_qsbr_quiescent (qsv,0 ); + + status =rte_lpm_add (lpm, ip, depth, next_hop); +TEST_LPM_ASSERT (status ==0 ); + +rte_rcu_qsbr_thread_offline (qsv,0 ); + status =rte_rcu_qsbr_thread_unregister (qsv,0 ); +TEST_LPM_ASSERT (status ==0 ); + + status =rte_lpm_lookup (lpm, ip, &next_hop_return); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (next_hop_return == next_hop); + +rte_lpm_free (lpm); +rte_free (qsv); + +return PASS ; +} + +static struct rte_lpm *g_lpm; +static struct rte_rcu_qsbr *g_v; +static uint32_t g_ip =RTE_IPV4 (192 ,18 ,100 ,100 ); +static volatile uint8_t writer_done; +/* Report quiescent state interval every 1024 lookups. Larger critical +* sections in reader will result in writer polling multiple times. +*/ +#define QSBR_REPORTING_INTERVAL 1024 +#define WRITER_ITERATIONS 512 + +/* +* Reader thread using rte_lpm data structure with RCU. +*/ +static int +test_lpm_rcu_qsbr_reader (void *arg) +{ +int i; +uint32_t next_hop_return =0 ; + +RTE_SET_USED (arg); +/* Register this thread to report quiescent state */ +rte_rcu_qsbr_thread_register (g_v,0 ); +rte_rcu_qsbr_thread_online (g_v,0 ); + +do { +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) +rte_lpm_lookup (g_lpm, g_ip, &next_hop_return); + +/* Update quiescent state */ +rte_rcu_qsbr_quiescent (g_v,0 ); + }while (!writer_done); + +rte_rcu_qsbr_thread_offline (g_v,0 ); +rte_rcu_qsbr_thread_unregister (g_v,0 ); + +return 0 ; +} + +/* +* rte_lpm_rcu_qsbr_add sync mode functional test. +* 1 Reader and 1 writer. They cannot be in the same thread in this test. +* - Create LPM which supports 1 tbl8 group at max +* - Add RCU QSBR variable with sync mode to LPM +* - Register a reader thread. Reader keeps looking up a specific rule. +* - Writer keeps adding and deleting a specific rule with depth=28 (> 24) +*/ +int32_t +test21 (void ) +{ +struct rte_lpm_config config; +size_t sz; +int32_t status; +uint32_t i, next_hop; +uint8_t depth; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + +if (rte_lcore_count () <2 ) { +printf ("Not enough cores for %s, expecting at least 2\n" , + __func__); +return TEST_SKIPPED ; + } + + config.max_rules =MAX_RULES ; + config.number_tbl8s =1 ; + config.flags =0 ; + + g_lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (g_lpm !=NULL ); + +/* Create RCU QSBR variable */ + sz =rte_rcu_qsbr_get_memsize (1 ); + g_v = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (g_v !=NULL ); + + status =rte_rcu_qsbr_init (g_v,1 ); +TEST_LPM_ASSERT (status ==0 ); + + rcu_cfg.v = g_v; + rcu_cfg.mode =RTE_LPM_QSBR_MODE_SYNC ; +/* Attach RCU QSBR to LPM table */ + status =rte_lpm_rcu_qsbr_add (g_lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status ==0 ); + + writer_done =0 ; +/* Launch reader thread */ +rte_eal_remote_launch (test_lpm_rcu_qsbr_reader,NULL , +rte_get_next_lcore (-1 ,1 ,0 )); + + depth =28 ; + next_hop =1 ; + status =rte_lpm_add (g_lpm, g_ip, depth, next_hop); +if (status !=0 ) { +printf ("%s: Failed to add rule\n" , __func__); + goto error; + } + +/* Writer update */ +for (i =0 ; i <WRITER_ITERATIONS ; i++) { + status =rte_lpm_delete (g_lpm, g_ip, depth); +if (status !=0 ) { +printf ("%s: Failed to delete rule at iteration %d\n" , + __func__, i); + goto error; + } + + status =rte_lpm_add (g_lpm, g_ip, depth, next_hop); +if (status !=0 ) { +printf ("%s: Failed to add rule at iteration %d\n" , + __func__, i); + goto error; + } + } + +error: + writer_done =1 ; +/* Wait until reader exited. */ +rte_eal_mp_wait_lcore (); + +rte_lpm_free (g_lpm); +rte_free (g_v); + +return (status ==0 ) ?PASS :-1 ; +} +/* * Do all unit tests. */
Signature · 1 line
2.17.1
PATCH v5 3/3 test/lpm: add RCU integration performance tests
In reply to Ruifeng WangFrom: Honnappa Nagarahalli <[email protected]>
Add performance tests for RCU integration. The performance difference with and without RCU integration is very small (~1% to ~2%) on both Arm and x86 platforms.
--- app/test/test_lpm_perf.c | 492 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 489 insertions(+), 3 deletions(-)
app/test/test_lpm_perf.c +489 -3
@@ -1,5 +1,6 @@/* SPDX-License-Identifier: BSD-3-Clause * Copyright(c) 2010-2014 Intel Corporation +* Copyright(c) 2020 Arm Limited */ #include <stdio.h>
@@ -10,12 +11,27 @@#include <rte_cycles.h> #include <rte_random.h> #include <rte_branch_prediction.h> +#include <rte_malloc.h> #include <rte_ip.h> #include <rte_lpm.h> #include "test.h" #include "test_xmmt_ops.h" +struct rte_lpm *lpm; +static struct rte_rcu_qsbr *rv; +static volatile uint8_t writer_done; +static volatile uint32_t thr_id; +static uint64_t gwrite_cycles; +static uint64_t gwrites; +/* LPM APIs are not thread safe, use mutex to provide thread safety */ +static pthread_mutex_t lpm_mutex =PTHREAD_MUTEX_INITIALIZER ; + +/* Report quiescent state interval every 1024 lookups. Larger critical +* sections in reader will result in writer polling multiple times. +*/ +#define QSBR_REPORTING_INTERVAL 1024 +#define TEST_LPM_ASSERT (cond) do { \ if (!(cond)) { \ printf("Error at line %d: \n", __LINE__); \
@@ -24,6 +40,7 @@ } while(0)#define ITERATIONS (1 << 10) +#define RCU_ITERATIONS 10#define BATCH_SIZE (1 << 12)#define BULK_SIZE 32
@@ -35,9 +52,13 @@ struct route_rule { };static struct route_rule large_route_table[MAX_RULE_NUM ]; +/* Route table for routes with depth > 24 */ +struct route_rule large_ldepth_route_table[MAX_RULE_NUM ];static uint32_t num_route_entries; +static uint32_t num_ldepth_route_entries;#define NUM_ROUTE_ENTRIES num_route_entries +#define NUM_LDEPTH_ROUTE_ENTRIES num_ldepth_route_entriesenum {IP_CLASS_A ,
@@ -191,7 +212,7 @@ static void generate_random_rule_prefix(uint32_t ip_class, uint8_t depth)uint32_t ip_head_mask;uint32_t rule_num;uint32_t k; -struct route_rule *ptr_rule; +struct route_rule *ptr_rule, *ptr_ldepth_rule;if (ip_class ==IP_CLASS_A ) {/* IP Address class A */ fixed_bit_num =IP_HEAD_BIT_NUM_A ;
@@ -236,10 +257,20 @@ static void generate_random_rule_prefix(uint32_t ip_class, uint8_t depth)*/ start =lrand48 () & mask; ptr_rule = &large_route_table[num_route_entries]; + ptr_ldepth_rule = &large_ldepth_route_table[num_ldepth_route_entries];for (k =0 ; k < rule_num; k++) { ptr_rule->ip = (start << (RTE_LPM_MAX_DEPTH - depth)) | ip_head_mask; ptr_rule->depth = depth; +/* If the depth of the route is more than 24, store it +* in another table as well. +*/ +if (depth >24 ) { + ptr_ldepth_rule->ip = ptr_rule->ip; + ptr_ldepth_rule->depth = ptr_rule->depth; + ptr_ldepth_rule++; + num_ldepth_route_entries++; + } ptr_rule++; start = (start + step) & mask; }
@@ -273,6 +304,7 @@ static void generate_large_route_rule_table(void)uint8_t depth; num_route_entries =0 ; + num_ldepth_route_entries =0 ;memset (large_route_table,0 ,sizeof (large_route_table));for (ip_class =IP_CLASS_A ; ip_class <=IP_CLASS_C ; ip_class++) {
@@ -316,10 +348,460 @@ print_route_distribution(const struct route_rule *table, uint32_t n)printf ("\n" ); } +/* Check condition and return an error if true. */ +static uint16_t enabled_core_ids[RTE_MAX_LCORE ]; +static unsigned int num_cores; + +/* Simple way to allocate thread ids in 0 to RTE_MAX_LCORE space */ +static inline uint32_t +alloc_thread_id (void ) +{ +uint32_t tmp_thr_id; + + tmp_thr_id =__atomic_fetch_add (&thr_id,1 , __ATOMIC_RELAXED); +if (tmp_thr_id >=RTE_MAX_LCORE ) +printf ("Invalid thread id %u\n" , tmp_thr_id); + +return tmp_thr_id; +} + +/* +* Reader thread using rte_lpm data structure without RCU. +*/ +static int +test_lpm_reader (void *arg) +{ +int i; +uint32_t ip_batch[QSBR_REPORTING_INTERVAL ]; +uint32_t next_hop_return =0 ; + +RTE_SET_USED (arg); +do { +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) + ip_batch[i] =rte_rand (); + +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) +rte_lpm_lookup (lpm, ip_batch[i], &next_hop_return); + + }while (!writer_done); + +return 0 ; +} + +/* +* Reader thread using rte_lpm data structure with RCU. +*/ +static int +test_lpm_rcu_qsbr_reader (void *arg) +{ +int i; +uint32_t thread_id =alloc_thread_id (); +uint32_t ip_batch[QSBR_REPORTING_INTERVAL ]; +uint32_t next_hop_return =0 ; + +RTE_SET_USED (arg); +/* Register this thread to report quiescent state */ +rte_rcu_qsbr_thread_register (rv, thread_id); +rte_rcu_qsbr_thread_online (rv, thread_id); + +do { +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) + ip_batch[i] =rte_rand (); + +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) +rte_lpm_lookup (lpm, ip_batch[i], &next_hop_return); + +/* Update quiescent state */ +rte_rcu_qsbr_quiescent (rv, thread_id); + }while (!writer_done); + +rte_rcu_qsbr_thread_offline (rv, thread_id); +rte_rcu_qsbr_thread_unregister (rv, thread_id); + +return 0 ; +} + +/* +* Writer thread using rte_lpm data structure with RCU. +*/ +static int +test_lpm_rcu_qsbr_writer (void *arg) +{ +unsigned int i, j, si, ei; +uint64_t begin, total_cycles; +uint8_t core_id = (uint8_t )((uintptr_t )arg); +uint32_t next_hop_add =0xAA ; + +RTE_SET_USED (arg); +/* 2 writer threads are used */ +if (core_id %2 ==0 ) { + si =0 ; + ei =NUM_LDEPTH_ROUTE_ENTRIES /2 ; + }else { + si =NUM_LDEPTH_ROUTE_ENTRIES /2 ; + ei =NUM_LDEPTH_ROUTE_ENTRIES ; + } + +/* Measure add/delete. */ + begin =rte_rdtsc_precise (); +for (i =0 ; i <RCU_ITERATIONS ; i++) { +/* Add all the entries */ +for (j = si; j < ei; j++) { +pthread_mutex_lock (&lpm_mutex); +if (rte_lpm_add (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth, + next_hop_add) !=0 ) { +printf ("Failed to add iteration %d, route# %d\n" , + i, j); + } +pthread_mutex_unlock (&lpm_mutex); + } + +/* Delete all the entries */ +for (j = si; j < ei; j++) { +pthread_mutex_lock (&lpm_mutex); +if (rte_lpm_delete (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth) !=0 ) { +printf ("Failed to delete iteration %d, route# %d\n" , + i, j); + } +pthread_mutex_unlock (&lpm_mutex); + } + } + + total_cycles =rte_rdtsc_precise () - begin; + +__atomic_fetch_add (&gwrite_cycles, total_cycles, __ATOMIC_RELAXED); +__atomic_fetch_add (&gwrites, +2 *NUM_LDEPTH_ROUTE_ENTRIES *RCU_ITERATIONS , + __ATOMIC_RELAXED); + +return 0 ; +} + +/* +* Functional test: +* 2 writers, rest are readers +*/ +static int +test_lpm_rcu_perf_multi_writer (void ) +{ +struct rte_lpm_config config; +size_t sz; +unsigned int i; +uint16_t core_id; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + +if (rte_lcore_count () <3 ) { +printf ("Not enough cores for lpm_rcu_perf_autotest, expecting at least 3\n" ); +return TEST_SKIPPED ; + } + + num_cores =0 ; +RTE_LCORE_FOREACH_SLAVE (core_id) { + enabled_core_ids[num_cores] = core_id; + num_cores++; + } + +printf ("\nPerf test: 2 writers, %d readers, RCU integration enabled\n" , + num_cores -2 ); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Init RCU variable */ + sz =rte_rcu_qsbr_get_memsize (num_cores); + rv = (struct rte_rcu_qsbr *)rte_zmalloc ("rcu0" , sz, +RTE_CACHE_LINE_SIZE ); +rte_rcu_qsbr_init (rv, num_cores); + + rcu_cfg.v = rv; +/* Assign the RCU variable to LPM */ +if (rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ) !=0 ) { +printf ("RCU variable assignment failed\n" ); + goto error; + } + + writer_done =0 ; +__atomic_store_n (&gwrite_cycles,0 , __ATOMIC_RELAXED); +__atomic_store_n (&gwrites,0 , __ATOMIC_RELAXED); + +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =2 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_reader,NULL , + enabled_core_ids[i]); + +/* Launch writer threads */ +for (i =0 ; i <2 ; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_writer, + (void *)(uintptr_t )i, + enabled_core_ids[i]); + +/* Wait for writer threads */ +for (i =0 ; i <2 ; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +printf ("Total LPM Adds: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %" PRIu64" cycles\n" , +__atomic_load_n (&gwrite_cycles, __ATOMIC_RELAXED) / +__atomic_load_n (&gwrites, __ATOMIC_RELAXED) + ); + +/* Wait and check return value from reader threads */ + writer_done =1 ; +for (i =2 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +rte_lpm_free (lpm); +rte_free (rv); + lpm =NULL ; + rv =NULL ; + +/* Test without RCU integration */ +printf ("\nPerf test: 2 writers, %d readers, RCU integration disabled\n" , + num_cores -2 ); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + + writer_done =0 ; +__atomic_store_n (&gwrite_cycles,0 , __ATOMIC_RELAXED); +__atomic_store_n (&gwrites,0 , __ATOMIC_RELAXED); +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =2 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_reader,NULL , + enabled_core_ids[i]); + +/* Launch writer threads */ +for (i =0 ; i <2 ; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_writer, + (void *)(uintptr_t )i, + enabled_core_ids[i]); + +/* Wait for writer threads */ +for (i =0 ; i <2 ; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +printf ("Total LPM Adds: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %" PRIu64" cycles\n" , +__atomic_load_n (&gwrite_cycles, __ATOMIC_RELAXED) / +__atomic_load_n (&gwrites, __ATOMIC_RELAXED) + ); + + writer_done =1 ; +/* Wait and check return value from reader threads */ +for (i =2 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +rte_lpm_free (lpm); + +return 0 ; + +error: + writer_done =1 ; +/* Wait until all readers have exited */ +rte_eal_mp_wait_lcore (); + +rte_lpm_free (lpm); +rte_free (rv); + +return -1 ; +} + +/* +* Functional test: +* Single writer, rest are readers +*/ +static int +test_lpm_rcu_perf (void ) +{ +struct rte_lpm_config config; +uint64_t begin, total_cycles; +size_t sz; +unsigned int i, j; +uint16_t core_id; +uint32_t next_hop_add =0xAA ; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + +if (rte_lcore_count () <2 ) { +printf ("Not enough cores for lpm_rcu_perf_autotest, expecting at least 2\n" ); +return TEST_SKIPPED ; + } + + num_cores =0 ; +RTE_LCORE_FOREACH_SLAVE (core_id) { + enabled_core_ids[num_cores] = core_id; + num_cores++; + } + +printf ("\nPerf test: 1 writer, %d readers, RCU integration enabled\n" , + num_cores); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Init RCU variable */ + sz =rte_rcu_qsbr_get_memsize (num_cores); + rv = (struct rte_rcu_qsbr *)rte_zmalloc ("rcu0" , sz, +RTE_CACHE_LINE_SIZE ); +rte_rcu_qsbr_init (rv, num_cores); + + rcu_cfg.v = rv; +/* Assign the RCU variable to LPM */ +if (rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ) !=0 ) { +printf ("RCU variable assignment failed\n" ); + goto error; + } + + writer_done =0 ; +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =0 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_reader,NULL , + enabled_core_ids[i]); + +/* Measure add/delete. */ + begin =rte_rdtsc_precise (); +for (i =0 ; i <RCU_ITERATIONS ; i++) { +/* Add all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_add (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth, + next_hop_add) !=0 ) { +printf ("Failed to add iteration %d, route# %d\n" , + i, j); + goto error; + } + +/* Delete all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_delete (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth) !=0 ) { +printf ("Failed to delete iteration %d, route# %d\n" , + i, j); + goto error; + } + } + total_cycles =rte_rdtsc_precise () - begin; + +printf ("Total LPM Adds: %d\n" ,ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %g cycles\n" , + (double )total_cycles / (NUM_LDEPTH_ROUTE_ENTRIES *ITERATIONS )); + + writer_done =1 ; +/* Wait and check return value from reader threads */ +for (i =0 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +rte_lpm_free (lpm); +rte_free (rv); + lpm =NULL ; + rv =NULL ; + +/* Test without RCU integration */ +printf ("\nPerf test: 1 writer, %d readers, RCU integration disabled\n" , + num_cores); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + + writer_done =0 ; +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =0 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_reader,NULL , + enabled_core_ids[i]); + +/* Measure add/delete. */ + begin =rte_rdtsc_precise (); +for (i =0 ; i <RCU_ITERATIONS ; i++) { +/* Add all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_add (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth, + next_hop_add) !=0 ) { +printf ("Failed to add iteration %d, route# %d\n" , + i, j); + goto error; + } + +/* Delete all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_delete (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth) !=0 ) { +printf ("Failed to delete iteration %d, route# %d\n" , + i, j); + goto error; + } + } + total_cycles =rte_rdtsc_precise () - begin; + +printf ("Total LPM Adds: %d\n" ,ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %g cycles\n" , + (double )total_cycles / (NUM_LDEPTH_ROUTE_ENTRIES *ITERATIONS )); + + writer_done =1 ; +/* Wait and check return value from reader threads */ +for (i =0 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) +printf ("Warning: lcore %u not finished.\n" , + enabled_core_ids[i]); + +rte_lpm_free (lpm); + +return 0 ; + +error: + writer_done =1 ; +/* Wait until all readers have exited */ +rte_eal_mp_wait_lcore (); + +rte_lpm_free (lpm); +rte_free (rv); + +return -1 ; +} +static int test_lpm_perf (void ) { -struct rte_lpm *lpm =NULL ;struct rte_lpm_config config; config.max_rules =2000000 ;
@@ -343,7 +825,7 @@ test_lpm_perf(void) lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config);TEST_LPM_ASSERT (lpm !=NULL ); -/* Measue add. */ +/* Measure add. */ begin =rte_rdtsc ();for (i =0 ; i <NUM_ROUTE_ENTRIES ; i++) {
@@ -478,6 +960,10 @@ test_lpm_perf(void)rte_lpm_delete_all (lpm);rte_lpm_free (lpm); +test_lpm_rcu_perf (); + +test_lpm_rcu_perf_multi_writer (); +return 0 ; }
Signature · 1 line
2.17.1
v6 cover RCU integration with LPM library
In reply to Ruifeng WangThis patchset integrates RCU QSBR support with LPM library.
Resource reclaimation implementation was splitted from the original series, and has already been part of RCU library. Rework the series to base LPM integration on RCU reclaimation APIs.
New API rte_lpm_rcu_qsbr_add is introduced for application to register a RCU variable that LPM library will use. This provides user the handle to enable RCU that integrated in LPM library.
Functional tests and performance tests are added to cover the integration with RCU.
---
v6:
Remove ALLOW_EXPERIMENTAL_API from rte_lpm.c.
v5:
No default value for reclaim_thd. This allows reclamation triggering with every call. Pass LPM pointer instead of tbl8 as argument of reclaim callback free function. Updated group_idx check at tbl8 allocation.
Use enums instead of defines for different reclamation modes.
RCU QSBR integrated path is inside ALLOW_EXPERIMENTAL_API to avoid ABI change.
v4:
Allow user to configure defer queue: size, reclaim threshold, max entries. Return defer queue handler so user can manually trigger reclaimation. Add blocking mode support. Defer queue will not be created.
Honnappa Nagarahalli (1):
test/lpm: add RCU integration performance tests
Ruifeng Wang (2):
lib/lpm: integrate RCU QSBR
test/lpm: add LPM RCU integration functional tests
app/test/test_lpm.c | 291 ++++++++++++++++- app/test/test_lpm_perf.c | 492 ++++++++++++++++++++++++++++- doc/guides/prog_guide/lpm_lib.rst | 32 ++ lib/librte_lpm/Makefile | 2 +- lib/librte_lpm/meson.build | 1 + lib/librte_lpm/rte_lpm.c | 120 ++++++- lib/librte_lpm/rte_lpm.h | 59 ++++ lib/librte_lpm/rte_lpm_version.map | 6 + 8 files changed, 987 insertions(+), 16 deletions(-)
Signature · 1 line
2.17.1
PATCH v6 1/3 lib/lpm: integrate RCU QSBR
Currently, the tbl8 group is freed even though the readers might be using the tbl8 group entries. The freed tbl8 group can be reallocated quickly. This results in incorrect lookup results.
RCU QSBR process is integrated for safe tbl8 group reclaim. Refer to RCU documentation to understand various aspects of integrating RCU library into other libraries.
--- doc/guides/prog_guide/lpm_lib.rst | 32 ++++++++ lib/librte_lpm/Makefile | 2 +- lib/librte_lpm/meson.build | 1 + lib/librte_lpm/rte_lpm.c | 120 ++++++++++++++++++++++++++--- lib/librte_lpm/rte_lpm.h | 59 ++++++++++++++ lib/librte_lpm/rte_lpm_version.map | 6 ++ 6 files changed, 208 insertions(+), 12 deletions(-)
doc/guides/prog_guide/lpm_lib.rst +32 -0
@@ -145,6 +145,38 @@ depending on whether we need to move to the next table or not. Prefix expansion is one of the keys of this algorithm, since it improves the speed dramatically by adding redundancy. +Deletion +~~~~~~~~ + +When deleting a rule, a replacement rule is searched for. Replacement rule is an existing rule that has +the longest prefix match with the rule to be deleted, but has shorter prefix. + +If a replacement rule is found, target tbl24 and tbl8 entries are updated to have the same depth and next hop +value with the replacement rule. + +If no replacement rule can be found, target tbl24 and tbl8 entries will be cleared. + +Prefix expansion is performed if the rule's depth is not exactly 24 bits or 32 bits. + +After deleting a rule, a group of tbl8s that belongs to the same tbl24 entry are freed in following cases: + +* All tbl8s in the group are empty . + +* All tbl8s in the group have the same values and with depth no greater than 24. + +Free of tbl8s have different behaviors: + +* If RCU is not used, tbl8s are cleared and reclaimed immediately. + +* If RCU is used, tbl8s are reclaimed when readers are in quiescent state. + +When the LPM is not using RCU, tbl8 group can be freed immediately even though the readers might be using +the tbl8 group entries. This might result in incorrect lookup results. + +RCU QSBR process is integrated for safe tbl8 group reclaimation. Application has certain responsibilities +while using this feature. Please refer to resource reclaimation framework of :ref:`RCU library <RCU_Library>` +for more details. + Lookup ~~~~~~
lib/librte_lpm/Makefile +1 -1
@@ -8,7 +8,7 @@ LIB = librte_lpm.a CFLAGS += -O3 CFLAGS += $(WERROR_FLAGS) -I$(SRCDIR) -LDLIBS += -lrte_eal -lrte_hash +LDLIBS += -lrte_eal -lrte_hash -lrte_rcu EXPORT_MAP := rte_lpm_version.map
lib/librte_lpm/meson.build +1 -0
@@ -7,3 +7,4 @@ headers = files('rte_lpm.h', 'rte_lpm6.h') # without worrying about which architecture we actually need headers += files('rte_lpm_altivec.h', 'rte_lpm_neon.h', 'rte_lpm_sse.h') deps += ['hash'] +deps += ['rcu']
lib/librte_lpm/rte_lpm.c +109 -11
182 lines not on this page · raw message
lib/librte_lpm/rte_lpm.h +59 -0
88 lines not on this page · raw message
lib/librte_lpm/rte_lpm_version.map +6 -0
@@ -21,3 +21,9 @@ DPDK_20.0 { local: *; }; + +EXPERIMENTAL { + global: + + rte_lpm_rcu_qsbr_add; +};
Signature · 1 line
2.17.1
PATCH v6 2/3 test/lpm: add LPM RCU integration functional tests
In reply to Ruifeng WangAdd positive and negative tests for API rte_lpm_rcu_qsbr_add. Also test LPM library behavior when RCU QSBR is enabled.
--- app/test/test_lpm.c | 291 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 290 insertions(+), 1 deletion(-)
app/test/test_lpm.c +290 -1
@@ -8,6 +8,7 @@#include <rte_ip.h> #include <rte_lpm.h> +#include <rte_malloc.h> #include "test.h" #include "test_xmmt_ops.h"
@@ -40,6 +41,9 @@ static int32_t test15(void);static int32_t test16 (void );static int32_t test17 (void );static int32_t test18 (void ); +static int32_t test19 (void ); +static int32_t test20 (void ); +static int32_t test21 (void );rte_lpm_test tests[] = {/* Test Cases */
@@ -61,7 +65,10 @@ rte_lpm_test tests[] = { test15, test16, test17, - test18 + test18, + test19, + test20, + test21 };#define MAX_DEPTH 32
@@ -1265,6 +1272,288 @@ test18(void)return PASS ; } +/* +* rte_lpm_rcu_qsbr_add positive and negative tests. +* - Add RCU QSBR variable to LPM +* - Add another RCU QSBR variable to LPM +* - Check returns +*/ +int32_t +test19 (void ) +{ +struct rte_lpm *lpm =NULL ; +struct rte_lpm_config config; +size_t sz; +struct rte_rcu_qsbr *qsv; +struct rte_rcu_qsbr *qsv2; +int32_t status; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + + config.max_rules =MAX_RULES ; + config.number_tbl8s =NUMBER_TBL8S ; + config.flags =0 ; + + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Create RCU QSBR variable */ + sz =rte_rcu_qsbr_get_memsize (RTE_MAX_LCORE ); + qsv = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (qsv !=NULL ); + + status =rte_rcu_qsbr_init (qsv,RTE_MAX_LCORE ); +TEST_LPM_ASSERT (status ==0 ); + + rcu_cfg.v = qsv; +/* Invalid QSBR mode */ + rcu_cfg.mode =2 ; + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status !=0 ); + + rcu_cfg.mode =RTE_LPM_QSBR_MODE_DQ ; +/* Attach RCU QSBR to LPM table */ + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status ==0 ); + +/* Create and attach another RCU QSBR to LPM table */ + qsv2 = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (qsv2 !=NULL ); + + rcu_cfg.v = qsv2; + rcu_cfg.mode =RTE_LPM_QSBR_MODE_SYNC ; + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status !=0 ); + +rte_lpm_free (lpm); +rte_free (qsv); +rte_free (qsv2); + +return PASS ; +} + +/* +* rte_lpm_rcu_qsbr_add DQ mode functional test. +* Reader and writer are in the same thread in this test. +* - Create LPM which supports 1 tbl8 group at max +* - Add RCU QSBR variable to LPM +* - Add a rule with depth=28 (> 24) +* - Register a reader thread (not a real thread) +* - Reader lookup existing rule +* - Writer delete the rule +* - Reader lookup the rule +* - Writer re-add the rule (no available tbl8 group) +* - Reader report quiescent state and unregister +* - Writer re-add the rule +* - Reader lookup the rule +*/ +int32_t +test20 (void ) +{ +struct rte_lpm *lpm =NULL ; +struct rte_lpm_config config; +size_t sz; +struct rte_rcu_qsbr *qsv; +int32_t status; +uint32_t ip, next_hop, next_hop_return; +uint8_t depth; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + + config.max_rules =MAX_RULES ; + config.number_tbl8s =1 ; + config.flags =0 ; + + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Create RCU QSBR variable */ + sz =rte_rcu_qsbr_get_memsize (1 ); + qsv = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (qsv !=NULL ); + + status =rte_rcu_qsbr_init (qsv,1 ); +TEST_LPM_ASSERT (status ==0 ); + + rcu_cfg.v = qsv; + rcu_cfg.mode =RTE_LPM_QSBR_MODE_DQ ; +/* Attach RCU QSBR to LPM table */ + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status ==0 ); + + ip =RTE_IPV4 (192 ,18 ,100 ,100 ); + depth =28 ; + next_hop =1 ; + status =rte_lpm_add (lpm, ip, depth, next_hop); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (lpm->tbl24[ip>>8 ].valid_group); + +/* Register pseudo reader */ + status =rte_rcu_qsbr_thread_register (qsv,0 ); +TEST_LPM_ASSERT (status ==0 ); +rte_rcu_qsbr_thread_online (qsv,0 ); + + status =rte_lpm_lookup (lpm, ip, &next_hop_return); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (next_hop_return == next_hop); + +/* Writer update */ + status =rte_lpm_delete (lpm, ip, depth); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (!lpm->tbl24[ip>>8 ].valid); + + status =rte_lpm_lookup (lpm, ip, &next_hop_return); +TEST_LPM_ASSERT (status !=0 ); + + status =rte_lpm_add (lpm, ip, depth, next_hop); +TEST_LPM_ASSERT (status !=0 ); + +/* Reader quiescent */ +rte_rcu_qsbr_quiescent (qsv,0 ); + + status =rte_lpm_add (lpm, ip, depth, next_hop); +TEST_LPM_ASSERT (status ==0 ); + +rte_rcu_qsbr_thread_offline (qsv,0 ); + status =rte_rcu_qsbr_thread_unregister (qsv,0 ); +TEST_LPM_ASSERT (status ==0 ); + + status =rte_lpm_lookup (lpm, ip, &next_hop_return); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (next_hop_return == next_hop); + +rte_lpm_free (lpm); +rte_free (qsv); + +return PASS ; +} + +static struct rte_lpm *g_lpm; +static struct rte_rcu_qsbr *g_v; +static uint32_t g_ip =RTE_IPV4 (192 ,18 ,100 ,100 ); +static volatile uint8_t writer_done; +/* Report quiescent state interval every 1024 lookups. Larger critical +* sections in reader will result in writer polling multiple times. +*/ +#define QSBR_REPORTING_INTERVAL 1024 +#define WRITER_ITERATIONS 512 + +/* +* Reader thread using rte_lpm data structure with RCU. +*/ +static int +test_lpm_rcu_qsbr_reader (void *arg) +{ +int i; +uint32_t next_hop_return =0 ; + +RTE_SET_USED (arg); +/* Register this thread to report quiescent state */ +rte_rcu_qsbr_thread_register (g_v,0 ); +rte_rcu_qsbr_thread_online (g_v,0 ); + +do { +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) +rte_lpm_lookup (g_lpm, g_ip, &next_hop_return); + +/* Update quiescent state */ +rte_rcu_qsbr_quiescent (g_v,0 ); + }while (!writer_done); + +rte_rcu_qsbr_thread_offline (g_v,0 ); +rte_rcu_qsbr_thread_unregister (g_v,0 ); + +return 0 ; +} + +/* +* rte_lpm_rcu_qsbr_add sync mode functional test. +* 1 Reader and 1 writer. They cannot be in the same thread in this test. +* - Create LPM which supports 1 tbl8 group at max +* - Add RCU QSBR variable with sync mode to LPM +* - Register a reader thread. Reader keeps looking up a specific rule. +* - Writer keeps adding and deleting a specific rule with depth=28 (> 24) +*/ +int32_t +test21 (void ) +{ +struct rte_lpm_config config; +size_t sz; +int32_t status; +uint32_t i, next_hop; +uint8_t depth; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + +if (rte_lcore_count () <2 ) { +printf ("Not enough cores for %s, expecting at least 2\n" , + __func__); +return TEST_SKIPPED ; + } + + config.max_rules =MAX_RULES ; + config.number_tbl8s =1 ; + config.flags =0 ; + + g_lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (g_lpm !=NULL ); + +/* Create RCU QSBR variable */ + sz =rte_rcu_qsbr_get_memsize (1 ); + g_v = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (g_v !=NULL ); + + status =rte_rcu_qsbr_init (g_v,1 ); +TEST_LPM_ASSERT (status ==0 ); + + rcu_cfg.v = g_v; + rcu_cfg.mode =RTE_LPM_QSBR_MODE_SYNC ; +/* Attach RCU QSBR to LPM table */ + status =rte_lpm_rcu_qsbr_add (g_lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status ==0 ); + + writer_done =0 ; +/* Launch reader thread */ +rte_eal_remote_launch (test_lpm_rcu_qsbr_reader,NULL , +rte_get_next_lcore (-1 ,1 ,0 )); + + depth =28 ; + next_hop =1 ; + status =rte_lpm_add (g_lpm, g_ip, depth, next_hop); +if (status !=0 ) { +printf ("%s: Failed to add rule\n" , __func__); + goto error; + } + +/* Writer update */ +for (i =0 ; i <WRITER_ITERATIONS ; i++) { + status =rte_lpm_delete (g_lpm, g_ip, depth); +if (status !=0 ) { +printf ("%s: Failed to delete rule at iteration %d\n" , + __func__, i); + goto error; + } + + status =rte_lpm_add (g_lpm, g_ip, depth, next_hop); +if (status !=0 ) { +printf ("%s: Failed to add rule at iteration %d\n" , + __func__, i); + goto error; + } + } + +error: + writer_done =1 ; +/* Wait until reader exited. */ +rte_eal_mp_wait_lcore (); + +rte_lpm_free (g_lpm); +rte_free (g_v); + +return (status ==0 ) ?PASS :-1 ; +} +/* * Do all unit tests. */
Signature · 1 line
2.17.1
PATCH v6 3/3 test/lpm: add RCU integration performance tests
In reply to Ruifeng WangFrom: Honnappa Nagarahalli <[email protected]>
Add performance tests for RCU integration. The performance difference with and without RCU integration is very small (~1% to ~2%) on both Arm and x86 platforms.
--- app/test/test_lpm_perf.c | 492 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 489 insertions(+), 3 deletions(-)
app/test/test_lpm_perf.c +489 -3
@@ -1,5 +1,6 @@/* SPDX-License-Identifier: BSD-3-Clause * Copyright(c) 2010-2014 Intel Corporation +* Copyright(c) 2020 Arm Limited */ #include <stdio.h>
@@ -10,12 +11,27 @@#include <rte_cycles.h> #include <rte_random.h> #include <rte_branch_prediction.h> +#include <rte_malloc.h> #include <rte_ip.h> #include <rte_lpm.h> #include "test.h" #include "test_xmmt_ops.h" +struct rte_lpm *lpm; +static struct rte_rcu_qsbr *rv; +static volatile uint8_t writer_done; +static volatile uint32_t thr_id; +static uint64_t gwrite_cycles; +static uint64_t gwrites; +/* LPM APIs are not thread safe, use mutex to provide thread safety */ +static pthread_mutex_t lpm_mutex =PTHREAD_MUTEX_INITIALIZER ; + +/* Report quiescent state interval every 1024 lookups. Larger critical +* sections in reader will result in writer polling multiple times. +*/ +#define QSBR_REPORTING_INTERVAL 1024 +#define TEST_LPM_ASSERT (cond) do { \ if (!(cond)) { \ printf("Error at line %d: \n", __LINE__); \
@@ -24,6 +40,7 @@ } while(0)#define ITERATIONS (1 << 10) +#define RCU_ITERATIONS 10#define BATCH_SIZE (1 << 12)#define BULK_SIZE 32
@@ -35,9 +52,13 @@ struct route_rule { };static struct route_rule large_route_table[MAX_RULE_NUM ]; +/* Route table for routes with depth > 24 */ +struct route_rule large_ldepth_route_table[MAX_RULE_NUM ];static uint32_t num_route_entries; +static uint32_t num_ldepth_route_entries;#define NUM_ROUTE_ENTRIES num_route_entries +#define NUM_LDEPTH_ROUTE_ENTRIES num_ldepth_route_entriesenum {IP_CLASS_A ,
@@ -191,7 +212,7 @@ static void generate_random_rule_prefix(uint32_t ip_class, uint8_t depth)uint32_t ip_head_mask;uint32_t rule_num;uint32_t k; -struct route_rule *ptr_rule; +struct route_rule *ptr_rule, *ptr_ldepth_rule;if (ip_class ==IP_CLASS_A ) {/* IP Address class A */ fixed_bit_num =IP_HEAD_BIT_NUM_A ;
@@ -236,10 +257,20 @@ static void generate_random_rule_prefix(uint32_t ip_class, uint8_t depth)*/ start =lrand48 () & mask; ptr_rule = &large_route_table[num_route_entries]; + ptr_ldepth_rule = &large_ldepth_route_table[num_ldepth_route_entries];for (k =0 ; k < rule_num; k++) { ptr_rule->ip = (start << (RTE_LPM_MAX_DEPTH - depth)) | ip_head_mask; ptr_rule->depth = depth; +/* If the depth of the route is more than 24, store it +* in another table as well. +*/ +if (depth >24 ) { + ptr_ldepth_rule->ip = ptr_rule->ip; + ptr_ldepth_rule->depth = ptr_rule->depth; + ptr_ldepth_rule++; + num_ldepth_route_entries++; + } ptr_rule++; start = (start + step) & mask; }
@@ -273,6 +304,7 @@ static void generate_large_route_rule_table(void)uint8_t depth; num_route_entries =0 ; + num_ldepth_route_entries =0 ;memset (large_route_table,0 ,sizeof (large_route_table));for (ip_class =IP_CLASS_A ; ip_class <=IP_CLASS_C ; ip_class++) {
@@ -316,10 +348,460 @@ print_route_distribution(const struct route_rule *table, uint32_t n)printf ("\n" ); } +/* Check condition and return an error if true. */ +static uint16_t enabled_core_ids[RTE_MAX_LCORE ]; +static unsigned int num_cores; + +/* Simple way to allocate thread ids in 0 to RTE_MAX_LCORE space */ +static inline uint32_t +alloc_thread_id (void ) +{ +uint32_t tmp_thr_id; + + tmp_thr_id =__atomic_fetch_add (&thr_id,1 , __ATOMIC_RELAXED); +if (tmp_thr_id >=RTE_MAX_LCORE ) +printf ("Invalid thread id %u\n" , tmp_thr_id); + +return tmp_thr_id; +} + +/* +* Reader thread using rte_lpm data structure without RCU. +*/ +static int +test_lpm_reader (void *arg) +{ +int i; +uint32_t ip_batch[QSBR_REPORTING_INTERVAL ]; +uint32_t next_hop_return =0 ; + +RTE_SET_USED (arg); +do { +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) + ip_batch[i] =rte_rand (); + +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) +rte_lpm_lookup (lpm, ip_batch[i], &next_hop_return); + + }while (!writer_done); + +return 0 ; +} + +/* +* Reader thread using rte_lpm data structure with RCU. +*/ +static int +test_lpm_rcu_qsbr_reader (void *arg) +{ +int i; +uint32_t thread_id =alloc_thread_id (); +uint32_t ip_batch[QSBR_REPORTING_INTERVAL ]; +uint32_t next_hop_return =0 ; + +RTE_SET_USED (arg); +/* Register this thread to report quiescent state */ +rte_rcu_qsbr_thread_register (rv, thread_id); +rte_rcu_qsbr_thread_online (rv, thread_id); + +do { +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) + ip_batch[i] =rte_rand (); + +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) +rte_lpm_lookup (lpm, ip_batch[i], &next_hop_return); + +/* Update quiescent state */ +rte_rcu_qsbr_quiescent (rv, thread_id); + }while (!writer_done); + +rte_rcu_qsbr_thread_offline (rv, thread_id); +rte_rcu_qsbr_thread_unregister (rv, thread_id); + +return 0 ; +} + +/* +* Writer thread using rte_lpm data structure with RCU. +*/ +static int +test_lpm_rcu_qsbr_writer (void *arg) +{ +unsigned int i, j, si, ei; +uint64_t begin, total_cycles; +uint8_t core_id = (uint8_t )((uintptr_t )arg); +uint32_t next_hop_add =0xAA ; + +RTE_SET_USED (arg); +/* 2 writer threads are used */ +if (core_id %2 ==0 ) { + si =0 ; + ei =NUM_LDEPTH_ROUTE_ENTRIES /2 ; + }else { + si =NUM_LDEPTH_ROUTE_ENTRIES /2 ; + ei =NUM_LDEPTH_ROUTE_ENTRIES ; + } + +/* Measure add/delete. */ + begin =rte_rdtsc_precise (); +for (i =0 ; i <RCU_ITERATIONS ; i++) { +/* Add all the entries */ +for (j = si; j < ei; j++) { +pthread_mutex_lock (&lpm_mutex); +if (rte_lpm_add (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth, + next_hop_add) !=0 ) { +printf ("Failed to add iteration %d, route# %d\n" , + i, j); + } +pthread_mutex_unlock (&lpm_mutex); + } + +/* Delete all the entries */ +for (j = si; j < ei; j++) { +pthread_mutex_lock (&lpm_mutex); +if (rte_lpm_delete (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth) !=0 ) { +printf ("Failed to delete iteration %d, route# %d\n" , + i, j); + } +pthread_mutex_unlock (&lpm_mutex); + } + } + + total_cycles =rte_rdtsc_precise () - begin; + +__atomic_fetch_add (&gwrite_cycles, total_cycles, __ATOMIC_RELAXED); +__atomic_fetch_add (&gwrites, +2 *NUM_LDEPTH_ROUTE_ENTRIES *RCU_ITERATIONS , + __ATOMIC_RELAXED); + +return 0 ; +} + +/* +* Functional test: +* 2 writers, rest are readers +*/ +static int +test_lpm_rcu_perf_multi_writer (void ) +{ +struct rte_lpm_config config; +size_t sz; +unsigned int i; +uint16_t core_id; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + +if (rte_lcore_count () <3 ) { +printf ("Not enough cores for lpm_rcu_perf_autotest, expecting at least 3\n" ); +return TEST_SKIPPED ; + } + + num_cores =0 ; +RTE_LCORE_FOREACH_SLAVE (core_id) { + enabled_core_ids[num_cores] = core_id; + num_cores++; + } + +printf ("\nPerf test: 2 writers, %d readers, RCU integration enabled\n" , + num_cores -2 ); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Init RCU variable */ + sz =rte_rcu_qsbr_get_memsize (num_cores); + rv = (struct rte_rcu_qsbr *)rte_zmalloc ("rcu0" , sz, +RTE_CACHE_LINE_SIZE ); +rte_rcu_qsbr_init (rv, num_cores); + + rcu_cfg.v = rv; +/* Assign the RCU variable to LPM */ +if (rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ) !=0 ) { +printf ("RCU variable assignment failed\n" ); + goto error; + } + + writer_done =0 ; +__atomic_store_n (&gwrite_cycles,0 , __ATOMIC_RELAXED); +__atomic_store_n (&gwrites,0 , __ATOMIC_RELAXED); + +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =2 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_reader,NULL , + enabled_core_ids[i]); + +/* Launch writer threads */ +for (i =0 ; i <2 ; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_writer, + (void *)(uintptr_t )i, + enabled_core_ids[i]); + +/* Wait for writer threads */ +for (i =0 ; i <2 ; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +printf ("Total LPM Adds: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %" PRIu64" cycles\n" , +__atomic_load_n (&gwrite_cycles, __ATOMIC_RELAXED) / +__atomic_load_n (&gwrites, __ATOMIC_RELAXED) + ); + +/* Wait and check return value from reader threads */ + writer_done =1 ; +for (i =2 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +rte_lpm_free (lpm); +rte_free (rv); + lpm =NULL ; + rv =NULL ; + +/* Test without RCU integration */ +printf ("\nPerf test: 2 writers, %d readers, RCU integration disabled\n" , + num_cores -2 ); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + + writer_done =0 ; +__atomic_store_n (&gwrite_cycles,0 , __ATOMIC_RELAXED); +__atomic_store_n (&gwrites,0 , __ATOMIC_RELAXED); +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =2 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_reader,NULL , + enabled_core_ids[i]); + +/* Launch writer threads */ +for (i =0 ; i <2 ; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_writer, + (void *)(uintptr_t )i, + enabled_core_ids[i]); + +/* Wait for writer threads */ +for (i =0 ; i <2 ; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +printf ("Total LPM Adds: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %" PRIu64" cycles\n" , +__atomic_load_n (&gwrite_cycles, __ATOMIC_RELAXED) / +__atomic_load_n (&gwrites, __ATOMIC_RELAXED) + ); + + writer_done =1 ; +/* Wait and check return value from reader threads */ +for (i =2 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +rte_lpm_free (lpm); + +return 0 ; + +error: + writer_done =1 ; +/* Wait until all readers have exited */ +rte_eal_mp_wait_lcore (); + +rte_lpm_free (lpm); +rte_free (rv); + +return -1 ; +} + +/* +* Functional test: +* Single writer, rest are readers +*/ +static int +test_lpm_rcu_perf (void ) +{ +struct rte_lpm_config config; +uint64_t begin, total_cycles; +size_t sz; +unsigned int i, j; +uint16_t core_id; +uint32_t next_hop_add =0xAA ; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + +if (rte_lcore_count () <2 ) { +printf ("Not enough cores for lpm_rcu_perf_autotest, expecting at least 2\n" ); +return TEST_SKIPPED ; + } + + num_cores =0 ; +RTE_LCORE_FOREACH_SLAVE (core_id) { + enabled_core_ids[num_cores] = core_id; + num_cores++; + } + +printf ("\nPerf test: 1 writer, %d readers, RCU integration enabled\n" , + num_cores); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Init RCU variable */ + sz =rte_rcu_qsbr_get_memsize (num_cores); + rv = (struct rte_rcu_qsbr *)rte_zmalloc ("rcu0" , sz, +RTE_CACHE_LINE_SIZE ); +rte_rcu_qsbr_init (rv, num_cores); + + rcu_cfg.v = rv; +/* Assign the RCU variable to LPM */ +if (rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ) !=0 ) { +printf ("RCU variable assignment failed\n" ); + goto error; + } + + writer_done =0 ; +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =0 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_reader,NULL , + enabled_core_ids[i]); + +/* Measure add/delete. */ + begin =rte_rdtsc_precise (); +for (i =0 ; i <RCU_ITERATIONS ; i++) { +/* Add all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_add (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth, + next_hop_add) !=0 ) { +printf ("Failed to add iteration %d, route# %d\n" , + i, j); + goto error; + } + +/* Delete all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_delete (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth) !=0 ) { +printf ("Failed to delete iteration %d, route# %d\n" , + i, j); + goto error; + } + } + total_cycles =rte_rdtsc_precise () - begin; + +printf ("Total LPM Adds: %d\n" ,ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %g cycles\n" , + (double )total_cycles / (NUM_LDEPTH_ROUTE_ENTRIES *ITERATIONS )); + + writer_done =1 ; +/* Wait and check return value from reader threads */ +for (i =0 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +rte_lpm_free (lpm); +rte_free (rv); + lpm =NULL ; + rv =NULL ; + +/* Test without RCU integration */ +printf ("\nPerf test: 1 writer, %d readers, RCU integration disabled\n" , + num_cores); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + + writer_done =0 ; +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =0 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_reader,NULL , + enabled_core_ids[i]); + +/* Measure add/delete. */ + begin =rte_rdtsc_precise (); +for (i =0 ; i <RCU_ITERATIONS ; i++) { +/* Add all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_add (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth, + next_hop_add) !=0 ) { +printf ("Failed to add iteration %d, route# %d\n" , + i, j); + goto error; + } + +/* Delete all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_delete (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth) !=0 ) { +printf ("Failed to delete iteration %d, route# %d\n" , + i, j); + goto error; + } + } + total_cycles =rte_rdtsc_precise () - begin; + +printf ("Total LPM Adds: %d\n" ,ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %g cycles\n" , + (double )total_cycles / (NUM_LDEPTH_ROUTE_ENTRIES *ITERATIONS )); + + writer_done =1 ; +/* Wait and check return value from reader threads */ +for (i =0 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) +printf ("Warning: lcore %u not finished.\n" , + enabled_core_ids[i]); + +rte_lpm_free (lpm); + +return 0 ; + +error: + writer_done =1 ; +/* Wait until all readers have exited */ +rte_eal_mp_wait_lcore (); + +rte_lpm_free (lpm); +rte_free (rv); + +return -1 ; +} +static int test_lpm_perf (void ) { -struct rte_lpm *lpm =NULL ;struct rte_lpm_config config; config.max_rules =2000000 ;
@@ -343,7 +825,7 @@ test_lpm_perf(void) lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config);TEST_LPM_ASSERT (lpm !=NULL ); -/* Measue add. */ +/* Measure add. */ begin =rte_rdtsc ();for (i =0 ; i <NUM_ROUTE_ENTRIES ; i++) {
@@ -478,6 +960,10 @@ test_lpm_perf(void)rte_lpm_delete_all (lpm);rte_lpm_free (lpm); +test_lpm_rcu_perf (); + +test_lpm_rcu_perf_multi_writer (); +return 0 ; }
Signature · 1 line
2.17.1
v7 cover RCU integration with LPM library
In reply to Ruifeng WangThis patchset integrates RCU QSBR support with LPM library.
Resource reclaimation implementation was splitted from the original series, and has already been part of RCU library. Rework the series to base LPM integration on RCU reclaimation APIs.
New API rte_lpm_rcu_qsbr_add is introduced for application to register a RCU variable that LPM library will use. This provides user the handle to enable RCU that integrated in LPM library.
Functional tests and performance tests are added to cover the integration with RCU.
---
v7:
Fixed typos in document.
v6:
Remove ALLOW_EXPERIMENTAL_API from rte_lpm.c.
v5:
No default value for reclaim_thd. This allows reclamation triggering with every call. Pass LPM pointer instead of tbl8 as argument of reclaim callback free function. Updated group_idx check at tbl8 allocation.
Use enums instead of defines for different reclamation modes.
RCU QSBR integrated path is inside ALLOW_EXPERIMENTAL_API to avoid ABI change.
v4:
Allow user to configure defer queue: size, reclaim threshold, max entries. Return defer queue handler so user can manually trigger reclaimation. Add blocking mode support. Defer queue will not be created.
Honnappa Nagarahalli (1):
test/lpm: add RCU integration performance tests
Ruifeng Wang (2):
lib/lpm: integrate RCU QSBR
test/lpm: add LPM RCU integration functional tests
app/test/test_lpm.c | 291 ++++++++++++++++- app/test/test_lpm_perf.c | 492 ++++++++++++++++++++++++++++- doc/guides/prog_guide/lpm_lib.rst | 32 ++ lib/librte_lpm/Makefile | 2 +- lib/librte_lpm/meson.build | 1 + lib/librte_lpm/rte_lpm.c | 120 ++++++- lib/librte_lpm/rte_lpm.h | 59 ++++ lib/librte_lpm/rte_lpm_version.map | 6 + 8 files changed, 987 insertions(+), 16 deletions(-)
Signature · 1 line
2.17.1
PATCH v7 1/3 lib/lpm: integrate RCU QSBR
Currently, the tbl8 group is freed even though the readers might be using the tbl8 group entries. The freed tbl8 group can be reallocated quickly. This results in incorrect lookup results.
RCU QSBR process is integrated for safe tbl8 group reclaim. Refer to RCU documentation to understand various aspects of integrating RCU library into other libraries.
--- doc/guides/prog_guide/lpm_lib.rst | 32 ++++++++ lib/librte_lpm/Makefile | 2 +- lib/librte_lpm/meson.build | 1 + lib/librte_lpm/rte_lpm.c | 120 ++++++++++++++++++++++++++--- lib/librte_lpm/rte_lpm.h | 59 ++++++++++++++ lib/librte_lpm/rte_lpm_version.map | 6 ++ 6 files changed, 208 insertions(+), 12 deletions(-)
doc/guides/prog_guide/lpm_lib.rst +32 -0
@@ -145,6 +145,38 @@ depending on whether we need to move to the next table or not. Prefix expansion is one of the keys of this algorithm, since it improves the speed dramatically by adding redundancy. +Deletion +~~~~~~~~ + +When deleting a rule, a replacement rule is searched for. Replacement rule is an existing rule that has +the longest prefix match with the rule to be deleted, but has shorter prefix. + +If a replacement rule is found, target tbl24 and tbl8 entries are updated to have the same depth and next hop +value with the replacement rule. + +If no replacement rule can be found, target tbl24 and tbl8 entries will be cleared. + +Prefix expansion is performed if the rule's depth is not exactly 24 bits or 32 bits. + +After deleting a rule, a group of tbl8s that belongs to the same tbl24 entry are freed in following cases: + +* All tbl8s in the group are empty . + +* All tbl8s in the group have the same values and with depth no greater than 24. + +Free of tbl8s have different behaviors: + +* If RCU is not used, tbl8s are cleared and reclaimed immediately. + +* If RCU is used, tbl8s are reclaimed when readers are in quiescent state. + +When the LPM is not using RCU, tbl8 group can be freed immediately even though the readers might be using +the tbl8 group entries. This might result in incorrect lookup results. + +RCU QSBR process is integrated for safe tbl8 group reclamation. Application has certain responsibilities +while using this feature. Please refer to resource reclamation framework of :ref:`RCU library <RCU_Library>` +for more details. + Lookup ~~~~~~
lib/librte_lpm/Makefile +1 -1
@@ -8,7 +8,7 @@ LIB = librte_lpm.a CFLAGS += -O3 CFLAGS += $(WERROR_FLAGS) -I$(SRCDIR) -LDLIBS += -lrte_eal -lrte_hash +LDLIBS += -lrte_eal -lrte_hash -lrte_rcu EXPORT_MAP := rte_lpm_version.map
lib/librte_lpm/meson.build +1 -0
@@ -7,3 +7,4 @@ headers = files('rte_lpm.h', 'rte_lpm6.h') # without worrying about which architecture we actually need headers += files('rte_lpm_altivec.h', 'rte_lpm_neon.h', 'rte_lpm_sse.h') deps += ['hash'] +deps += ['rcu']
lib/librte_lpm/rte_lpm.c +109 -11
182 lines not on this page · raw message
lib/librte_lpm/rte_lpm.h +59 -0
88 lines not on this page · raw message
lib/librte_lpm/rte_lpm_version.map +6 -0
@@ -21,3 +21,9 @@ DPDK_20.0 { local: *; }; + +EXPERIMENTAL { + global: + + rte_lpm_rcu_qsbr_add; +};
Signature · 1 line
2.17.1
Re: [dpdk-dev] [PATCH v7 1/3] lib/lpm: integrate RCU QSBR
Quoted 381 lines · Ruifeng Wang
Currently, the tbl8 group is freed even though the readers might be using the tbl8 group entries. The freed tbl8 group can be reallocated quickly. This results in incorrect lookup results.
RCU QSBR process is integrated for safe tbl8 group reclaim. Refer to RCU documentation to understand various aspects of integrating RCU library into other libraries.
Signed-off-by Ruifeng Wang <[email protected]>Reviewed-by Honnappa Nagarahalli <[email protected]>Acked-by Ray Kinsella <[email protected]>--- doc/guides/prog_guide/lpm_lib.rst | 32 ++++++++ lib/librte_lpm/Makefile | 2 +- lib/librte_lpm/meson.build | 1 + lib/librte_lpm/rte_lpm.c | 120 ++++++++++++++++++++++++++--- lib/librte_lpm/rte_lpm.h | 59 ++++++++++++++ lib/librte_lpm/rte_lpm_version.map | 6 ++ 6 files changed, 208 insertions(+), 12 deletions(-)doc/guides/prog_guide/lpm_lib.rst +32
-0@@ -145,6 +145,38 @@ depending on whether we need to move to the next table or not. Prefix expansion is one of the keys of this algorithm, since it improves the speed dramatically by adding redundancy. +Deletion +~~~~~~~~ + +When deleting a rule, a replacement rule is searched for. Replacement rule is an existing rule that has +the longest prefix match with the rule to be deleted, but has shorter prefix. + +If a replacement rule is found, target tbl24 and tbl8 entries are updated to have the same depth and next hop +value with the replacement rule. + +If no replacement rule can be found, target tbl24 and tbl8 entries will be cleared. + +Prefix expansion is performed if the rule's depth is not exactly 24 bits or 32 bits. + +After deleting a rule, a group of tbl8s that belongs to the same tbl24 entry are freed in following cases: + +* All tbl8s in the group are empty . + +* All tbl8s in the group have the same values and with depth no greater than 24. + +Free of tbl8s have different behaviors: + +* If RCU is not used, tbl8s are cleared and reclaimed immediately. + +* If RCU is used, tbl8s are reclaimed when readers are in quiescent state. + +When the LPM is not using RCU, tbl8 group can be freed immediately even though the readers might be using +the tbl8 group entries. This might result in incorrect lookup results. + +RCU QSBR process is integrated for safe tbl8 group reclamation. Application has certain responsibilities +while using this feature. Please refer to resource reclamation framework of :ref:`RCU library <RCU_Library>` +for more details. + Lookup ~~~~~~lib/librte_lpm/Makefile +1
-1@@ -8,7 +8,7 @@ LIB = librte_lpm.a CFLAGS += -O3 CFLAGS += $(WERROR_FLAGS) -I$(SRCDIR) -LDLIBS += -lrte_eal -lrte_hash +LDLIBS += -lrte_eal -lrte_hash -lrte_rcu EXPORT_MAP := rte_lpm_version.maplib/librte_lpm/meson.build +1
-0@@ -7,3 +7,4 @@ headers = files('rte_lpm.h', 'rte_lpm6.h') # without worrying about which architecture we actually need headers += files('rte_lpm_altivec.h', 'rte_lpm_neon.h', 'rte_lpm_sse.h') deps += ['hash'] +deps += ['rcu']lib/librte_lpm/rte_lpm.c +109
-11@@ -1,5 +1,6 @@/* SPDX-License-Identifier: BSD-3-Clause * Copyright(c) 2010-2014 Intel Corporation +* Copyright(c) 2020 Arm Limited */ #include <string.h> @@ -246,12 +247,82 @@ rte_lpm_free(struct rte_lpm *lpm)rte_mcfg_tailq_write_unlock (); +if (lpm->dq) +rte_rcu_qsbr_dq_delete (lpm->dq);rte_free (lpm->tbl8);rte_free (lpm->rules_tbl);rte_free (lpm);rte_free (te); } +static void +__lpm_rcu_qsbr_free_resource (void *p,void *data,unsigned int n) +{ +struct rte_lpm_tbl_entry zero_tbl8_entry = {0 }; +uint32_t tbl8_group_index = *(uint32_t *)data; +struct rte_lpm_tbl_entry *tbl8 = ((struct rte_lpm *)p)->tbl8; + +RTE_SET_USED (n); +/* Set tbl8 group invalid */ +__atomic_store (&tbl8[tbl8_group_index], &zero_tbl8_entry, + __ATOMIC_RELAXED); +} + +/* Associate QSBR variable with an LPM object. +*/ +int +rte_lpm_rcu_qsbr_add (struct rte_lpm *lpm,struct rte_lpm_rcu_config *cfg, +struct rte_rcu_qsbr_dq **dq) +{ +char rcu_dq_name[RTE_RCU_QSBR_DQ_NAMESIZE ]; +struct rte_rcu_qsbr_dq_parameters params = {0 }; + +if ((lpm ==NULL ) || (cfg ==NULL )) { + rte_errno =EINVAL ; +return 1 ; + } + +if (lpm->v) { + rte_errno =EEXIST ; +return 1 ; + } + +if (cfg->mode ==RTE_LPM_QSBR_MODE_SYNC ) { +/* No other things to do. */ + }else if (cfg->mode ==RTE_LPM_QSBR_MODE_DQ ) { +/* Init QSBR defer queue. */ +snprintf (rcu_dq_name,sizeof (rcu_dq_name), +"LPM_RCU_%s" , lpm->name); + params.name = rcu_dq_name; + params.size = cfg->dq_size; +if (params.size ==0 ) + params.size = lpm->number_tbl8s; + params.trigger_reclaim_limit = cfg->reclaim_thd; + params.max_reclaim_size = cfg->reclaim_max; +if (params.max_reclaim_size ==0 ) + params.max_reclaim_size =RTE_LPM_RCU_DQ_RECLAIM_MAX ; + params.esize =sizeof (uint32_t );/* tbl8 group index */ + params.free_fn = __lpm_rcu_qsbr_free_resource; + params.p = lpm; + params.v = cfg->v; + lpm->dq =rte_rcu_qsbr_dq_create (¶ms); +if (lpm->dq ==NULL ) { +RTE_LOG (ERR ,LPM , +"LPM QS defer queue creation failed\n" ); +return 1 ; + } +if (dq) + *dq = lpm->dq; + }else { + rte_errno =EINVAL ; +return 1 ; + } + lpm->rcu_mode = cfg->mode; + lpm->v = cfg->v; + +return 0 ; +} +/* * Adds a rule to the rule table. * @@ -394,14 +465,15 @@ rule_find(struct rte_lpm *lpm, uint32_t ip_masked, uint8_t depth)* Find, clean and allocate a tbl8. */ static int32_t -tbl8_alloc (struct rte_lpm_tbl_entry *tbl8,uint32_t number_tbl8s) +_tbl8_alloc (struct rte_lpm *lpm) {uint32_t group_idx;/* tbl8 group index. */ struct rte_lpm_tbl_entry *tbl8_entry;/* Scan through tbl8 to find a free (i.e. INVALID) tbl8 group. */ -for (group_idx =0 ; group_idx < number_tbl8s; group_idx++) { - tbl8_entry = &tbl8[group_idx *RTE_LPM_TBL8_GROUP_NUM_ENTRIES ]; +for (group_idx =0 ; group_idx < lpm->number_tbl8s; group_idx++) { + tbl8_entry = &lpm->tbl8[group_idx * +RTE_LPM_TBL8_GROUP_NUM_ENTRIES ];/* If a free tbl8 group is found clean it and set as VALID. */ if (!tbl8_entry->valid_group) { struct rte_lpm_tbl_entry new_tbl8_entry = {@@ -427,14 +499,40 @@ tbl8_alloc(struct rte_lpm_tbl_entry *tbl8, uint32_t number_tbl8s)return -ENOSPC ; } +static int32_t +tbl8_alloc (struct rte_lpm *lpm) +{ +int32_t group_idx;/* tbl8 group index. */ + + group_idx =_tbl8_alloc (lpm); +if ((group_idx == -ENOSPC ) && (lpm->dq !=NULL )) { +/* If there are no tbl8 groups try to reclaim one. */ +if (rte_rcu_qsbr_dq_reclaim (lpm->dq,1 ,NULL ,NULL ,NULL ) ==0 ) + group_idx =_tbl8_alloc (lpm); + } + +return group_idx; +} +static void -tbl8_free (struct rte_lpm_tbl_entry *tbl8,uint32_t tbl8_group_start) +tbl8_free (struct rte_lpm *lpm,uint32_t tbl8_group_start) { -/* Set tbl8 group invalid*/ struct rte_lpm_tbl_entry zero_tbl8_entry = {0 }; -__atomic_store (&tbl8[tbl8_group_start], &zero_tbl8_entry, - __ATOMIC_RELAXED); +if (!lpm->v) { +/* Set tbl8 group invalid*/ +__atomic_store (&lpm->tbl8[tbl8_group_start], &zero_tbl8_entry, + __ATOMIC_RELAXED); + }else if (lpm->rcu_mode ==RTE_LPM_QSBR_MODE_SYNC ) { +/* Wait for quiescent state change. */ +rte_rcu_qsbr_synchronize (lpm->v,RTE_QSBR_THRID_INVALID ); +/* Set tbl8 group invalid*/ +__atomic_store (&lpm->tbl8[tbl8_group_start], &zero_tbl8_entry, + __ATOMIC_RELAXED); + }else if (lpm->rcu_mode ==RTE_LPM_QSBR_MODE_DQ ) { +/* Push into QSBR defer queue. */ +rte_rcu_qsbr_dq_enqueue (lpm->dq, (void *)&tbl8_group_start); + } }static __rte_noinline int32_t@@ -523,7 +621,7 @@ add_depth_big(struct rte_lpm *lpm, uint32_t ip_masked, uint8_t depth,if (!lpm->tbl24[tbl24_index].valid) {/* Search for a free tbl8 group. */ - tbl8_group_index =tbl8_alloc (lpm->tbl8, lpm->number_tbl8s); + tbl8_group_index =tbl8_alloc (lpm);/* Check tbl8 allocation was successful. */ if (tbl8_group_index <0 ) {@@ -569,7 +667,7 @@ add_depth_big(struct rte_lpm *lpm, uint32_t ip_masked, uint8_t depth, }/* If valid entry but not extended calculate the index into Table8. */ else if (lpm->tbl24[tbl24_index].valid_group ==0 ) {/* Search for free tbl8 group. */ - tbl8_group_index =tbl8_alloc (lpm->tbl8, lpm->number_tbl8s); + tbl8_group_index =tbl8_alloc (lpm);if (tbl8_group_index <0 ) {return tbl8_group_index;@@ -977,7 +1075,7 @@ delete_depth_big(struct rte_lpm *lpm, uint32_t ip_masked,*/ lpm->tbl24[tbl24_index].valid =0 ;__atomic_thread_fence (__ATOMIC_RELEASE); -tbl8_free (lpm->tbl8, tbl8_group_start); +tbl8_free (lpm, tbl8_group_start); }else if (tbl8_recycle_index >-1 ) {/* Update tbl24 entry. */ struct rte_lpm_tbl_entry new_tbl24_entry = {@@ -993,7 +1091,7 @@ delete_depth_big(struct rte_lpm *lpm, uint32_t ip_masked,__atomic_store (&lpm->tbl24[tbl24_index], &new_tbl24_entry, __ATOMIC_RELAXED);__atomic_thread_fence (__ATOMIC_RELEASE); -tbl8_free (lpm->tbl8, tbl8_group_start); +tbl8_free (lpm, tbl8_group_start); }#undef group_idxreturn 0 ;lib/librte_lpm/rte_lpm.h +59
-0@@ -1,5 +1,6 @@/* SPDX-License-Identifier: BSD-3-Clause * Copyright(c) 2010-2014 Intel Corporation +* Copyright(c) 2020 Arm Limited */ #ifndef _RTE_LPM_H_@@ -20,6 +21,7 @@#include <rte_memory.h> #include <rte_common.h> #include <rte_vect.h> +#include <rte_rcu_qsbr.h> #ifdef __cplusplusextern "C" {@@ -62,6 +64,17 @@ extern "C" {/** Bitmask used to indicate successful lookup */ #define RTE_LPM_LOOKUP_SUCCESS 0x01000000 +/** @internal Default RCU defer queue entries to reclaim in one go. */ +#define RTE_LPM_RCU_DQ_RECLAIM_MAX 16 + +/** RCU reclamation modes */ +enum rte_lpm_qsbr_mode { +/** Create defer queue for reclaim. */ +RTE_LPM_QSBR_MODE_DQ =0 , +/** Use blocking mode reclaim. No defer queue created. */ +RTE_LPM_QSBR_MODE_SYNC +}; +#if RTE_BYTE_ORDER ==RTE_LITTLE_ENDIAN /** @internal Tbl24 entry structure. */ __extension__@@ -130,6 +143,28 @@ struct rte_lpm { __rte_cache_aligned;/**< LPM tbl24 table. */ struct rte_lpm_tbl_entry *tbl8;/**< LPM tbl8 table. */ struct rte_lpm_rule *rules_tbl;/**< LPM rules. */ +#ifdef ALLOW_EXPERIMENTAL_API +/* RCU config. */ +struct rte_rcu_qsbr *v;/* RCU QSBR variable. */ +enum rte_lpm_qsbr_mode rcu_mode;/* Blocking, defer queue. */ +struct rte_rcu_qsbr_dq *dq;/* RCU QSBR defer queue. */ +#endif +}; + +/** LPM RCU QSBR configuration structure. */ +struct rte_lpm_rcu_config { +struct rte_rcu_qsbr *v;/* RCU QSBR variable. */ +/* Mode of RCU QSBR. RTE_LPM_QSBR_MODE_xxx +* '0' for default: create defer queue for reclaim. +*/ +enum rte_lpm_qsbr_mode mode; +uint32_t dq_size;/* RCU defer queue size. +* default: lpm->number_tbl8s. +*/ +uint32_t reclaim_thd;/* Threshold to trigger auto reclaim. */ +uint32_t reclaim_max;/* Max entries to reclaim in one go. +* default: RTE_LPM_RCU_DQ_RECLAIM_MAX. +*/ };/** @@ -179,6 +214,30 @@ rte_lpm_find_existing(const char *name);void rte_lpm_free (struct rte_lpm *lpm); +/** +* @warning +* @b EXPERIMENTAL: this API may change without prior notice +* +* Associate RCU QSBR variable with an LPM object. +* +* @param lpm +* the lpm object to add RCU QSBR +* @param cfg +* RCU QSBR configuration +* @param dq +* handler of created RCU QSBR defer queue +* @return +* On success - 0 +* On error - 1 with error code set in rte_errno. +* Possible rte_errno codes are: +* - EINVAL - invalid pointer +* - EEXIST - already added QSBR +* - ENOMEM - memory allocation failure +*/ +__rte_experimental +int rte_lpm_rcu_qsbr_add(struct rte_lpm *lpm, struct rte_lpm_rcu_config *cfg, +struct rte_rcu_qsbr_dq **dq); +/** * Add a rule to the LPM table. * lib/librte_lpm/rte_lpm_version.map +0
-0
lib/librte_lpm/rte_lpm_version.map DPDK_20.0 { · line 29
Quoted 9 lines
lib/librte_lpm/rte_lpm_version.map +6
-0@@ -21,3 +21,9 @@ DPDK_20.0 { local: *; }; + +EXPERIMENTAL { + global: + + rte_lpm_rcu_qsbr_add; +};
Signature · 2 lines
Regards, Vladimir
Re: [dpdk-dev] [PATCH v7 1/3] lib/lpm: integrate RCU QSBR
In reply to Ruifeng WangQuoted 38 lines · Ruifeng Wang
lib/librte_lpm/rte_lpm.h +13
-0@@ -1,5 +1,6 @@/* SPDX-License-Identifier: BSD-3-Clause * Copyright(c) 2010-2014 Intel Corporation +* Copyright(c) 2020 Arm Limited */ #ifndef _RTE_LPM_H_@@ -20,6 +21,7 @@#include <rte_memory.h> #include <rte_common.h> #include <rte_vect.h> +#include <rte_rcu_qsbr.h> #ifdef __cplusplusextern "C" {@@ -62,6 +64,17 @@ extern "C" {/** Bitmask used to indicate successful lookup */ #define RTE_LPM_LOOKUP_SUCCESS 0x01000000 +/** @internal Default RCU defer queue entries to reclaim in one go. */ +#define RTE_LPM_RCU_DQ_RECLAIM_MAX 16 + +/** RCU reclamation modes */ +enum rte_lpm_qsbr_mode { +/** Create defer queue for reclaim. */ +RTE_LPM_QSBR_MODE_DQ =0 , +/** Use blocking mode reclaim. No defer queue created. */ +RTE_LPM_QSBR_MODE_SYNC +}; +#if RTE_BYTE_ORDER ==RTE_LITTLE_ENDIAN /** @internal Tbl24 entry structure. */ __extension__
lib/librte_lpm/rte_lpm.h struct rte_lpm { · line 152
Quoted 10 lines
lib/librte_lpm/rte_lpm.h +7
-0@@ -130,6 +143,28 @@ struct rte_lpm { __rte_cache_aligned;/**< LPM tbl24 table. */ struct rte_lpm_tbl_entry *tbl8;/**< LPM tbl8 table. */ struct rte_lpm_rule *rules_tbl;/**< LPM rules. */ +#ifdef ALLOW_EXPERIMENTAL_API +/* RCU config. */ +struct rte_rcu_qsbr *v;/* RCU QSBR variable. */ +enum rte_lpm_qsbr_mode rcu_mode;/* Blocking, defer queue. */ +struct rte_rcu_qsbr_dq *dq;/* RCU QSBR defer queue. */ +#endif +};
I can see failures in travis reports for v7 and v6. I reproduced them in my env.
1 function with some indirect sub-type change:
[C]'function int rte_lpm_add(rte_lpm*, uint32_t, uint8_t, uint32_t)'
at rte_lpm.c:764:1 has some indirect sub-type changes:
parameter 1 of type 'rte_lpm*' has sub-type changes:
in pointed to type 'struct rte_lpm' at rte_lpm.h:134:1:
type size hasn't changed
3 data member insertions:
'rte_rcu_qsbr* rte_lpm::v', at offset 536873600 (in bits) at
rte_lpm.h:148:1
'rte_lpm_qsbr_mode rte_lpm::rcu_mode', at offset 536873664
(in bits) at rte_lpm.h:149:1
'rte_rcu_qsbr_dq* rte_lpm::dq', at offset 536873728 (inbits) at rte_lpm.h:150:1
Going back to my proposal of hiding what does not need to be seen.
Disclaimer, *this is quick & dirty* but it builds and passes ABI check:
$ git diff
lib/librte_lpm/rte_lpm.c +23 -10
@@ -115,6 +115,15 @@ rte_lpm_find_existing(const char *name)return l; } +struct internal_lpm { +/* Public object */ +struct rte_lpm lpm; +/* RCU config. */ +struct rte_rcu_qsbr *v;/* RCU QSBR variable. */ +enum rte_lpm_qsbr_mode rcu_mode;/* Blocking, defer queue. */ +struct rte_rcu_qsbr_dq *dq;/* RCU QSBR defer queue. */ +}; +/* * Allocates memory for LPM object */
@@ -123,6 +132,7 @@ rte_lpm_create(const char *name, int socket_id, const struct rte_lpm_config *config) {char mem_name[RTE_LPM_NAMESIZE ]; +struct internal_lpm *internal =NULL ;struct rte_lpm *lpm =NULL ;struct rte_tailq_entry *te;uint32_t mem_size, rules_size, tbl8s_size;
@@ -141,12 +151,6 @@ rte_lpm_create(const char *name, int socket_id,snprintf (mem_name,sizeof (mem_name),"LPM_%s" , name); -/* Determine the amount of memory to allocate. */ - mem_size =sizeof (*lpm); - rules_size =sizeof (struct rte_lpm_rule ) * config->max_rules; - tbl8s_size = (sizeof (struct rte_lpm_tbl_entry ) * -RTE_LPM_TBL8_GROUP_NUM_ENTRIES * config->number_tbl8s); -rte_mcfg_tailq_write_lock ();/* guarantee there's no existing */
@@ -170,16 +174,23 @@ rte_lpm_create(const char *name, int socket_id, goto exit; } +/* Determine the amount of memory to allocate. */ + mem_size =sizeof (*internal); + rules_size =sizeof (struct rte_lpm_rule ) * config->max_rules; + tbl8s_size = (sizeof (struct rte_lpm_tbl_entry ) * +RTE_LPM_TBL8_GROUP_NUM_ENTRIES * config->number_tbl8s); +/* Allocate memory to store the LPM data structures. */ - lpm =rte_zmalloc_socket (mem_name, mem_size, + internal =rte_zmalloc_socket (mem_name, mem_size,RTE_CACHE_LINE_SIZE , socket_id); -if (lpm ==NULL ) { +if (internal ==NULL ) {RTE_LOG (ERR ,LPM ,"LPM memory allocation failed\n" );rte_free (te); rte_errno =ENOMEM ; goto exit; } + lpm = &internal->lpm; lpm->rules_tbl =rte_zmalloc_socket (NULL , (size_t )rules_size,RTE_CACHE_LINE_SIZE , socket_id);
@@ -226,6 +237,7 @@ rte_lpm_create(const char *name, int socket_id,void rte_lpm_free (struct rte_lpm *lpm) { +struct internal_lpm *internal;struct rte_lpm_list *lpm_list;struct rte_tailq_entry *te;
@@ -247,8 +259,9 @@ rte_lpm_free(struct rte_lpm *lpm)rte_mcfg_tailq_write_unlock (); -if (lpm->dq) -rte_rcu_qsbr_dq_delete (lpm->dq); + internal = container_of(lpm, struct internal_lpm, lpm); +if (internal->dq !=NULL ) +rte_rcu_qsbr_dq_delete (internal->dq);rte_free (lpm->tbl8);rte_free (lpm->rules_tbl);rte_free (lpm);
@@ -276,13 +289,15 @@ rte_lpm_rcu_qsbr_add(struct rte_lpm *lpm, struct
rte_lpm_rcu_config *cfg,
{
char rcu_dq_name[RTE_RCU_QSBR_DQ_NAMESIZE];
struct rte_rcu_qsbr_dq_parameters params = {0};+ struct internal_lpm *internal;
- if ((lpm == NULL) || (cfg == NULL)) {
+ if (lpm == NULL || cfg == NULL) {
rte_errno = EINVAL;
return 1;
}- if (lpm->v) {
+ internal = container_of(lpm, struct internal_lpm, lpm);
+ if (internal->v != NULL) {
rte_errno = EEXIST;
return 1;
}
@@ -305,20 +320,19 @@ rte_lpm_rcu_qsbr_add(struct rte_lpm *lpm, struct
rte_lpm_rcu_config *cfg,
params.free_fn = __lpm_rcu_qsbr_free_resource;
params.p = lpm;
params.v = cfg->v;- lpm->dq = rte_rcu_qsbr_dq_create(¶ms);
- if (lpm->dq == NULL) {
- RTE_LOG(ERR, LPM,
- "LPM QS defer queue creation failed\n");
+ internal->dq = rte_rcu_qsbr_dq_create(¶ms);
+ if (internal->dq == NULL) {
+ RTE_LOG(ERR, LPM, "LPM QS defer queue creation
failed\n");
return 1;
}
if (dq)
- *dq = lpm->dq;
+ *dq = internal->dq;
} else {
rte_errno = EINVAL;
return 1;
}
- lpm->rcu_mode = cfg->mode;
- lpm->v = cfg->v;
+ internal->rcu_mode = cfg->mode;
+ internal->v = cfg->v;return 0;
}
@@ -502,12 +516,13 @@ _tbl8_alloc(struct rte_lpm *lpm)
static int32_t
tbl8_alloc(struct rte_lpm *lpm)
{
+ struct internal_lpm *internal = container_of(lpm, struct
internal_lpm, lpm);
int32_t group_idx; /* tbl8 group index. */
group_idx = _tbl8_alloc(lpm);
- if ((group_idx == -ENOSPC) && (lpm->dq != NULL)) {
+ if (group_idx == -ENOSPC && internal->dq != NULL) {
/* If there are no tbl8 groups try to reclaim one. */
- if (rte_rcu_qsbr_dq_reclaim(lpm->dq, 1, NULL, NULL, NULL) == 0)
+ if (rte_rcu_qsbr_dq_reclaim(internal->dq, 1, NULL,
NULL, NULL) == 0)
group_idx = _tbl8_alloc(lpm);
}@@ -518,20 +533,21 @@ static void
tbl8_free(struct rte_lpm *lpm, uint32_t tbl8_group_start)
{
struct rte_lpm_tbl_entry zero_tbl8_entry = {0};+ struct internal_lpm *internal = container_of(lpm, structinternal_lpm, lpm);
- if (!lpm->v) {
+ if (internal->v == NULL) {
/* Set tbl8 group invalid*/
__atomic_store(&lpm->tbl8[tbl8_group_start], &zero_tbl8_entry,
__ATOMIC_RELAXED);
- } else if (lpm->rcu_mode == RTE_LPM_QSBR_MODE_SYNC) {
+ } else if (internal->rcu_mode == RTE_LPM_QSBR_MODE_SYNC) {
/* Wait for quiescent state change. */
- rte_rcu_qsbr_synchronize(lpm->v, RTE_QSBR_THRID_INVALID);
+ rte_rcu_qsbr_synchronize(internal->v, RTE_QSBR_THRID_INVALID);
/* Set tbl8 group invalid*/
__atomic_store(&lpm->tbl8[tbl8_group_start], &zero_tbl8_entry,
__ATOMIC_RELAXED);
- } else if (lpm->rcu_mode == RTE_LPM_QSBR_MODE_DQ) {
+ } else if (internal->rcu_mode == RTE_LPM_QSBR_MODE_DQ) {
/* Push into QSBR defer queue. */
- rte_rcu_qsbr_dq_enqueue(lpm->dq, (void *)&tbl8_group_start);
+ rte_rcu_qsbr_dq_enqueue(internal->dq, (void
*)&tbl8_group_start);
}}
lib/librte_lpm/rte_lpm.h +0 -6
@@ -143,12 +143,6 @@ struct rte_lpm { __rte_cache_aligned;/**< LPM tbl24 table. */ struct rte_lpm_tbl_entry *tbl8;/**< LPM tbl8 table. */ struct rte_lpm_rule *rules_tbl;/**< LPM rules. */ -#ifdef ALLOW_EXPERIMENTAL_API -/* RCU config. */ -struct rte_rcu_qsbr *v;/* RCU QSBR variable. */ -enum rte_lpm_qsbr_mode rcu_mode;/* Blocking, defer queue. */ -struct rte_rcu_qsbr_dq *dq;/* RCU QSBR defer queue. */ -#endif };/** LPM RCU QSBR configuration structure. */
Signature · 1 line
David Marchand
Re: [dpdk-dev] [PATCH v7 1/3] lib/lpm: integrate RCU QSBR
Quoted 77 lines
-----Original Message-----
From: David Marchand <[email protected]>
Sent: Wednesday, July 8, 2020 10:30 PM
To: Ruifeng Wang <[email protected]>
Cc: Bruce Richardson <[email protected]>; Vladimir Medvedkin <[email protected]>; John McNamara <[email protected]>; Marko Kovacevic <[email protected]>; Ray Kinsella <[email protected]>; Neil Horman <[email protected]>; dev <[email protected]>; Ananyev, Konstantin <[email protected]>; Honnappa Nagarahalli <[email protected]>; nd <[email protected]>
Subject: Re: [dpdk-dev] [PATCH v7 1/3] lib/lpm: integrate RCU QSBRQuoted 37 lines · Ruifeng Wang
lib/librte_lpm/rte_lpm.h index renamed from lib/librte_lpm/rte_lpm.h +0
-0
b9d49ac87..7889f21b3100644lib/librte_lpm/rte_lpm.h +14
-0@@ -1,5 +1,6 @@/* SPDX-License-Identifier: BSD-3-Clause * Copyright(c) 2010-2014 Intel Corporation +* Copyright(c) 2020 Arm Limited */ #ifndef _RTE_LPM_H_@@ -20,6 +21,7 @@#include <rte_memory.h> #include <rte_common.h> #include <rte_vect.h> +#include <rte_rcu_qsbr.h> #ifdef __cplusplusextern "C" {@@ -62,6 +64,17 @@ extern "C" {/** Bitmask used to indicate successful lookup */ #define RTE_LPM_LOOKUP_SUCCESS 0x01000000 +/** @internal Default RCU defer queue entries to reclaim in one go. */ +#define RTE_LPM_RCU_DQ_RECLAIM_MAX 16 + +/** RCU reclamation modes */ +enum rte_lpm_qsbr_mode { +/** Create defer queue for reclaim. */ +RTE_LPM_QSBR_MODE_DQ =0 , +/** Use blocking mode reclaim. No defer queue created. */ +RTE_LPM_QSBR_MODE_SYNC +}; +#if RTE_BYTE_ORDER ==RTE_LITTLE_ENDIAN /** @internal Tbl24 entry structure. */ __extension__ @@ -130,6 +143,28 @@ struct rte_lpm {lib/librte_lpm/rte_lpm.h extern "C" {
Quoted 10 lines
lib/librte_lpm/rte_lpm.h +7
-0__rte_cache_aligned;/**< LPM tbl24 table. */ struct rte_lpm_tbl_entry *tbl8;/**< LPM tbl8 table. */ struct rte_lpm_rule *rules_tbl;/**< LPM rules. */ +#ifdef ALLOW_EXPERIMENTAL_API +/* RCU config. */ +struct rte_rcu_qsbr *v;/* RCU QSBR variable. */ +enum rte_lpm_qsbr_mode rcu_mode;/* Blocking, defer queue. */ +struct rte_rcu_qsbr_dq *dq;/* RCU QSBR defer queue. */ +#endif +};I can see failures in travis reports for v7 and v6. I reproduced them in my env.
1 function with some indirect sub-type change:
[C]'function int
rte_lpm_add(rte_lpm*, uint32_t, uint8_t, uint32_t)'
at rte_lpm.c:764:1 has some indirect sub-type changes:
parameter 1 of type 'rte_lpm*' has sub-type changes:
in pointed to type 'structrte_lpm' at rte_lpm.h:134:1:
type size hasn't changed
3 data member insertions:
'rte_rcu_qsbr*rte_lpm::v', at offset 536873600 (in bits) at
rte_lpm.h:148:1
Quoted 5 lines
'rte_lpm_qsbr_mode rte_lpm::rcu_mode', at offset 536873664 (in bits) at rte_lpm.h:149:1 'rte_rcu_qsbr_dq* rte_lpm::dq', at offset 536873728 (inbits) at rte_lpm.h:150:1
Sorry, I thought if ALLOW_EXPERIMENTAL was added, ABI would be kept when experimental was not allowed by user. ABI and ALLOW_EXPERIMENTAL should be two different things.
lib/librte_lpm/rte_lpm.c
Quoted 10 lines
Going back to my proposal of hiding what does not need to be seen.
Disclaimer, *this is quick & dirty* but it builds and passes ABI check:
$ git difflib/librte_lpm/rte_lpm.c index renamed from lib/librte_lpm/rte_lpm.c +0
-0
d498ba761..7109aef6a100644lib/librte_lpm/rte_lpm.c +0
-0
I understand your proposal in v5 now. A new data structure encloses rte_lpm and new members that for RCU use. In this way, rte_lpm ABI is kept. And we can move out other members in rte_lpm that not need to be exposed in 20.11 release. I will fix the ABI issue in next version.
Quoted 197 lines
lib/librte_lpm/rte_lpm.c +10
-0@@ -115,6 +115,15 @@ rte_lpm_find_existing(const char *name)return l; } +struct internal_lpm { +/* Public object */ +struct rte_lpm lpm; +/* RCU config. */ +struct rte_rcu_qsbr *v;/* RCU QSBR variable. */ +enum rte_lpm_qsbr_mode rcu_mode;/* Blocking, defer queue. */ +struct rte_rcu_qsbr_dq *dq;/* RCU QSBR defer queue. */ +}; +/* * Allocates memory for LPM object */ @@ -123,6 +132,7 @@ rte_lpm_create(const char *name, int socket_id, const struct rte_lpm_config *config) {char mem_name[RTE_LPM_NAMESIZE ]; +struct internal_lpm *internal =NULL ;struct rte_lpm *lpm =NULL ;struct rte_tailq_entry *te; uint32_t mem_size, rules_size, tbl8s_size; @@ -141,12 +151,6 @@ rte_lpm_create(const char *name, int socket_id,snprintf(mem_name, sizeof(mem_name), "LPM_%s", name);lib/librte_lpm/rte_lpm.c +0
-5-/* Determine the amount of memory to allocate. */ - mem_size =sizeof (*lpm); - rules_size =sizeof (struct rte_lpm_rule ) * config->max_rules; - tbl8s_size = (sizeof(struct rte_lpm_tbl_entry) * - RTE_LPM_TBL8_GROUP_NUM_ENTRIES * config-Quoted 1 line
number_tbl8s);-
rte_mcfg_tailq_write_lock(); /* guarantee there's no existing */ @@ -170,16 +174,23 @@ rte_lpm_create(const char *name, int socket_id, goto exit; }lib/librte_lpm/rte_lpm.c +24
-13+/* Determine the amount of memory to allocate. */ + mem_size =sizeof (*internal); + rules_size =sizeof (struct rte_lpm_rule ) * config->max_rules; + tbl8s_size = (sizeof (struct rte_lpm_tbl_entry ) * +RTE_LPM_TBL8_GROUP_NUM_ENTRIES * + config->number_tbl8s); +/* Allocate memory to store the LPM data structures. */ - lpm =rte_zmalloc_socket (mem_name, mem_size, + internal =rte_zmalloc_socket (mem_name, mem_size,RTE_CACHE_LINE_SIZE , socket_id); -if (lpm ==NULL ) { +if (internal ==NULL ) {RTE_LOG (ERR ,LPM ,"LPM memory allocation failed\n" );rte_free (te); rte_errno =ENOMEM ; goto exit; } + lpm = &internal->lpm; lpm->rules_tbl =rte_zmalloc_socket (NULL , (size_t )rules_size,RTE_CACHE_LINE_SIZE , socket_id);@@ -226,6 +237,7 @@ rte_lpm_create(const char *name, int socket_id,void rte_lpm_free (struct rte_lpm *lpm) { +struct internal_lpm *internal;struct rte_lpm_list *lpm_list;struct rte_tailq_entry *te;@@ -247,8 +259,9 @@ rte_lpm_free(struct rte_lpm *lpm)rte_mcfg_tailq_write_unlock (); -if (lpm->dq) -rte_rcu_qsbr_dq_delete (lpm->dq); + internal = container_of(lpm, struct internal_lpm, lpm); +if (internal->dq !=NULL ) +rte_rcu_qsbr_dq_delete (internal->dq);rte_free (lpm->tbl8);rte_free (lpm->rules_tbl);rte_free (lpm);@@ -276,13 +289,15 @@ rte_lpm_rcu_qsbr_add(struct rte_lpm *lpm, struct rte_lpm_rcu_config *cfg, { char rcu_dq_name[RTE_RCU_QSBR_DQ_NAMESIZE];struct rte_rcu_qsbr_dq_parameters params = {0 }; +struct internal_lpm *internal; -if ((lpm ==NULL ) || (cfg ==NULL )) { +if (lpm ==NULL || cfg ==NULL ) { rte_errno =EINVAL ;return 1 ; } -if (lpm->v) { + internal = container_of(lpm, struct internal_lpm, lpm); +if (internal->v !=NULL ) { rte_errno =EEXIST ;return 1 ; }@@ -305,20 +320,19 @@ rte_lpm_rcu_qsbr_add(struct rte_lpm *lpm, struct rte_lpm_rcu_config *cfg, params.free_fn = __lpm_rcu_qsbr_free_resource; params.p = lpm; params.v = cfg->v; - lpm->dq =rte_rcu_qsbr_dq_create (¶ms); -if (lpm->dq ==NULL ) { -RTE_LOG (ERR ,LPM , -"LPM QS defer queue creation failed\n" ); + internal->dq =rte_rcu_qsbr_dq_create (¶ms); +if (internal->dq ==NULL ) { +RTE_LOG (ERR ,LPM ,"LPM QS defer queue creation failed\n");return 1 ; }if (dq) - *dq = lpm->dq; + *dq = internal->dq; }else { rte_errno =EINVAL ;return 1 ; } - lpm->rcu_mode = cfg->mode; - lpm->v = cfg->v; + internal->rcu_mode = cfg->mode; + internal->v = cfg->v;return 0;}
lib/librte_lpm/rte_lpm.c +10
-7@@ -502,12 +516,13 @@ _tbl8_alloc(struct rte_lpm *lpm) static int32_t tbl8_alloc(struct rte_lpm *lpm) { + struct internal_lpm *internal = container_of(lpm, struct internal_lpm, lpm);int32_t group_idx;/* tbl8 group index. */ group_idx =_tbl8_alloc (lpm); -if ((group_idx == -ENOSPC ) && (lpm->dq !=NULL )) { +if (group_idx == -ENOSPC && internal->dq !=NULL ) {/* If there are no tbl8 groups try to reclaim one. */ -if (rte_rcu_qsbr_dq_reclaim (lpm->dq,1 ,NULL ,NULL ,NULL ) ==0 ) +if (rte_rcu_qsbr_dq_reclaim (internal->dq,1 ,NULL ,NULL ,NULL ) ==0 ) group_idx =_tbl8_alloc (lpm); }@@ -518,20 +533,21 @@ static void tbl8_free(struct rte_lpm *lpm, uint32_t tbl8_group_start) {struct rte_lpm_tbl_entry zero_tbl8_entry = {0 }; + struct internal_lpm *internal = container_of(lpm, struct internal_lpm, lpm); -if (!lpm->v) { +if (internal->v ==NULL ) {/* Set tbl8 group invalid*/ __atomic_store (&lpm->tbl8[tbl8_group_start], &zero_tbl8_entry, __ATOMIC_RELAXED); - }else if (lpm->rcu_mode ==RTE_LPM_QSBR_MODE_SYNC ) { + }else if (internal->rcu_mode ==RTE_LPM_QSBR_MODE_SYNC ) {/* Wait for quiescent state change. */ -rte_rcu_qsbr_synchronize (lpm->v,RTE_QSBR_THRID_INVALID ); +rte_rcu_qsbr_synchronize (internal->v, +RTE_QSBR_THRID_INVALID );/* Set tbl8 group invalid*/ __atomic_store (&lpm->tbl8[tbl8_group_start], &zero_tbl8_entry, __ATOMIC_RELAXED); - }else if (lpm->rcu_mode ==RTE_LPM_QSBR_MODE_DQ ) { + }else if (internal->rcu_mode ==RTE_LPM_QSBR_MODE_DQ ) {/* Push into QSBR defer queue. */ -rte_rcu_qsbr_dq_enqueue (lpm->dq, (void *)&tbl8_group_start); +rte_rcu_qsbr_dq_enqueue (internal->dq, (void *)&tbl8_group_start); } }lib/librte_lpm/rte_lpm.h index renamed from lib/librte_lpm/rte_lpm.h +0
-0
7889f21b3..a9568fcdd100644lib/librte_lpm/rte_lpm.h +0
-0@@ -143,12 +143,6 @@ struct rte_lpm { __rte_cache_aligned;/**< LPM tbl24 table. */ struct rte_lpm_tbl_entry *tbl8;/**< LPM tbl8 table. */ struct rte_lpm_rule *rules_tbl; /**< LPM rules. */ -#ifdef
ALLOW_EXPERIMENTAL_APIlib/librte_lpm/rte_lpm.h +0
-6-/* RCU config. */ -struct rte_rcu_qsbr *v;/* RCU QSBR variable. */ -enum rte_lpm_qsbr_mode rcu_mode;/* Blocking, defer queue. */ -struct rte_rcu_qsbr_dq *dq;/* RCU QSBR defer queue. */ -#endif };/** LPM RCU QSBR configuration structure. */ --David Marchand
PATCH v7 2/3 test/lpm: add LPM RCU integration functional tests
In reply to Ruifeng WangAdd positive and negative tests for API rte_lpm_rcu_qsbr_add. Also test LPM library behavior when RCU QSBR is enabled.
--- app/test/test_lpm.c | 291 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 290 insertions(+), 1 deletion(-)
app/test/test_lpm.c +290 -1
@@ -8,6 +8,7 @@#include <rte_ip.h> #include <rte_lpm.h> +#include <rte_malloc.h> #include "test.h" #include "test_xmmt_ops.h"
@@ -40,6 +41,9 @@ static int32_t test15(void);static int32_t test16 (void );static int32_t test17 (void );static int32_t test18 (void ); +static int32_t test19 (void ); +static int32_t test20 (void ); +static int32_t test21 (void );rte_lpm_test tests[] = {/* Test Cases */
@@ -61,7 +65,10 @@ rte_lpm_test tests[] = { test15, test16, test17, - test18 + test18, + test19, + test20, + test21 };#define MAX_DEPTH 32
@@ -1265,6 +1272,288 @@ test18(void)return PASS ; } +/* +* rte_lpm_rcu_qsbr_add positive and negative tests. +* - Add RCU QSBR variable to LPM +* - Add another RCU QSBR variable to LPM +* - Check returns +*/ +int32_t +test19 (void ) +{ +struct rte_lpm *lpm =NULL ; +struct rte_lpm_config config; +size_t sz; +struct rte_rcu_qsbr *qsv; +struct rte_rcu_qsbr *qsv2; +int32_t status; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + + config.max_rules =MAX_RULES ; + config.number_tbl8s =NUMBER_TBL8S ; + config.flags =0 ; + + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Create RCU QSBR variable */ + sz =rte_rcu_qsbr_get_memsize (RTE_MAX_LCORE ); + qsv = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (qsv !=NULL ); + + status =rte_rcu_qsbr_init (qsv,RTE_MAX_LCORE ); +TEST_LPM_ASSERT (status ==0 ); + + rcu_cfg.v = qsv; +/* Invalid QSBR mode */ + rcu_cfg.mode =2 ; + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status !=0 ); + + rcu_cfg.mode =RTE_LPM_QSBR_MODE_DQ ; +/* Attach RCU QSBR to LPM table */ + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status ==0 ); + +/* Create and attach another RCU QSBR to LPM table */ + qsv2 = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (qsv2 !=NULL ); + + rcu_cfg.v = qsv2; + rcu_cfg.mode =RTE_LPM_QSBR_MODE_SYNC ; + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status !=0 ); + +rte_lpm_free (lpm); +rte_free (qsv); +rte_free (qsv2); + +return PASS ; +} + +/* +* rte_lpm_rcu_qsbr_add DQ mode functional test. +* Reader and writer are in the same thread in this test. +* - Create LPM which supports 1 tbl8 group at max +* - Add RCU QSBR variable to LPM +* - Add a rule with depth=28 (> 24) +* - Register a reader thread (not a real thread) +* - Reader lookup existing rule +* - Writer delete the rule +* - Reader lookup the rule +* - Writer re-add the rule (no available tbl8 group) +* - Reader report quiescent state and unregister +* - Writer re-add the rule +* - Reader lookup the rule +*/ +int32_t +test20 (void ) +{ +struct rte_lpm *lpm =NULL ; +struct rte_lpm_config config; +size_t sz; +struct rte_rcu_qsbr *qsv; +int32_t status; +uint32_t ip, next_hop, next_hop_return; +uint8_t depth; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + + config.max_rules =MAX_RULES ; + config.number_tbl8s =1 ; + config.flags =0 ; + + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Create RCU QSBR variable */ + sz =rte_rcu_qsbr_get_memsize (1 ); + qsv = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (qsv !=NULL ); + + status =rte_rcu_qsbr_init (qsv,1 ); +TEST_LPM_ASSERT (status ==0 ); + + rcu_cfg.v = qsv; + rcu_cfg.mode =RTE_LPM_QSBR_MODE_DQ ; +/* Attach RCU QSBR to LPM table */ + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status ==0 ); + + ip =RTE_IPV4 (192 ,18 ,100 ,100 ); + depth =28 ; + next_hop =1 ; + status =rte_lpm_add (lpm, ip, depth, next_hop); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (lpm->tbl24[ip>>8 ].valid_group); + +/* Register pseudo reader */ + status =rte_rcu_qsbr_thread_register (qsv,0 ); +TEST_LPM_ASSERT (status ==0 ); +rte_rcu_qsbr_thread_online (qsv,0 ); + + status =rte_lpm_lookup (lpm, ip, &next_hop_return); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (next_hop_return == next_hop); + +/* Writer update */ + status =rte_lpm_delete (lpm, ip, depth); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (!lpm->tbl24[ip>>8 ].valid); + + status =rte_lpm_lookup (lpm, ip, &next_hop_return); +TEST_LPM_ASSERT (status !=0 ); + + status =rte_lpm_add (lpm, ip, depth, next_hop); +TEST_LPM_ASSERT (status !=0 ); + +/* Reader quiescent */ +rte_rcu_qsbr_quiescent (qsv,0 ); + + status =rte_lpm_add (lpm, ip, depth, next_hop); +TEST_LPM_ASSERT (status ==0 ); + +rte_rcu_qsbr_thread_offline (qsv,0 ); + status =rte_rcu_qsbr_thread_unregister (qsv,0 ); +TEST_LPM_ASSERT (status ==0 ); + + status =rte_lpm_lookup (lpm, ip, &next_hop_return); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (next_hop_return == next_hop); + +rte_lpm_free (lpm); +rte_free (qsv); + +return PASS ; +} + +static struct rte_lpm *g_lpm; +static struct rte_rcu_qsbr *g_v; +static uint32_t g_ip =RTE_IPV4 (192 ,18 ,100 ,100 ); +static volatile uint8_t writer_done; +/* Report quiescent state interval every 1024 lookups. Larger critical +* sections in reader will result in writer polling multiple times. +*/ +#define QSBR_REPORTING_INTERVAL 1024 +#define WRITER_ITERATIONS 512 + +/* +* Reader thread using rte_lpm data structure with RCU. +*/ +static int +test_lpm_rcu_qsbr_reader (void *arg) +{ +int i; +uint32_t next_hop_return =0 ; + +RTE_SET_USED (arg); +/* Register this thread to report quiescent state */ +rte_rcu_qsbr_thread_register (g_v,0 ); +rte_rcu_qsbr_thread_online (g_v,0 ); + +do { +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) +rte_lpm_lookup (g_lpm, g_ip, &next_hop_return); + +/* Update quiescent state */ +rte_rcu_qsbr_quiescent (g_v,0 ); + }while (!writer_done); + +rte_rcu_qsbr_thread_offline (g_v,0 ); +rte_rcu_qsbr_thread_unregister (g_v,0 ); + +return 0 ; +} + +/* +* rte_lpm_rcu_qsbr_add sync mode functional test. +* 1 Reader and 1 writer. They cannot be in the same thread in this test. +* - Create LPM which supports 1 tbl8 group at max +* - Add RCU QSBR variable with sync mode to LPM +* - Register a reader thread. Reader keeps looking up a specific rule. +* - Writer keeps adding and deleting a specific rule with depth=28 (> 24) +*/ +int32_t +test21 (void ) +{ +struct rte_lpm_config config; +size_t sz; +int32_t status; +uint32_t i, next_hop; +uint8_t depth; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + +if (rte_lcore_count () <2 ) { +printf ("Not enough cores for %s, expecting at least 2\n" , + __func__); +return TEST_SKIPPED ; + } + + config.max_rules =MAX_RULES ; + config.number_tbl8s =1 ; + config.flags =0 ; + + g_lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (g_lpm !=NULL ); + +/* Create RCU QSBR variable */ + sz =rte_rcu_qsbr_get_memsize (1 ); + g_v = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (g_v !=NULL ); + + status =rte_rcu_qsbr_init (g_v,1 ); +TEST_LPM_ASSERT (status ==0 ); + + rcu_cfg.v = g_v; + rcu_cfg.mode =RTE_LPM_QSBR_MODE_SYNC ; +/* Attach RCU QSBR to LPM table */ + status =rte_lpm_rcu_qsbr_add (g_lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status ==0 ); + + writer_done =0 ; +/* Launch reader thread */ +rte_eal_remote_launch (test_lpm_rcu_qsbr_reader,NULL , +rte_get_next_lcore (-1 ,1 ,0 )); + + depth =28 ; + next_hop =1 ; + status =rte_lpm_add (g_lpm, g_ip, depth, next_hop); +if (status !=0 ) { +printf ("%s: Failed to add rule\n" , __func__); + goto error; + } + +/* Writer update */ +for (i =0 ; i <WRITER_ITERATIONS ; i++) { + status =rte_lpm_delete (g_lpm, g_ip, depth); +if (status !=0 ) { +printf ("%s: Failed to delete rule at iteration %d\n" , + __func__, i); + goto error; + } + + status =rte_lpm_add (g_lpm, g_ip, depth, next_hop); +if (status !=0 ) { +printf ("%s: Failed to add rule at iteration %d\n" , + __func__, i); + goto error; + } + } + +error: + writer_done =1 ; +/* Wait until reader exited. */ +rte_eal_mp_wait_lcore (); + +rte_lpm_free (g_lpm); +rte_free (g_v); + +return (status ==0 ) ?PASS :-1 ; +} +/* * Do all unit tests. */
Signature · 1 line
2.17.1
Re: [dpdk-dev] [PATCH v7 2/3] test/lpm: add LPM RCU integration functional tests
Hi Ruifeng,
Just a few nits
Quoted 149 lines · Ruifeng Wang
Add positive and negative tests for API
rte_lpm_rcu_qsbr_add. Also test LPM library behavior when RCU QSBR is enabled.Signed-off-by Ruifeng Wang <[email protected]>Reviewed-by Gavin Hu <[email protected]>Reviewed-by Honnappa Nagarahalli <[email protected]>--- app/test/test_lpm.c | 291 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 290 insertions(+), 1 deletion(-)app/test/test_lpm.c +109
-1@@ -8,6 +8,7 @@#include <rte_ip.h> #include <rte_lpm.h> +#include <rte_malloc.h> #include "test.h" #include "test_xmmt_ops.h" @@ -40,6 +41,9 @@ static int32_t test15(void);static int32_t test16 (void );static int32_t test17 (void );static int32_t test18 (void ); +static int32_t test19 (void ); +static int32_t test20 (void ); +static int32_t test21 (void );rte_lpm_test tests[] = {/* Test Cases */ @@ -61,7 +65,10 @@ rte_lpm_test tests[] = { test15, test16, test17, - test18 + test18, + test19, + test20, + test21 };#define MAX_DEPTH 32@@ -1265,6 +1272,288 @@ test18(void)return PASS ; } +/* +* rte_lpm_rcu_qsbr_add positive and negative tests. +* - Add RCU QSBR variable to LPM +* - Add another RCU QSBR variable to LPM +* - Check returns +*/ +int32_t +test19 (void ) +{ +struct rte_lpm *lpm =NULL ; +struct rte_lpm_config config; +size_t sz; +struct rte_rcu_qsbr *qsv; +struct rte_rcu_qsbr *qsv2; +int32_t status; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + + config.max_rules =MAX_RULES ; + config.number_tbl8s =NUMBER_TBL8S ; + config.flags =0 ; + + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Create RCU QSBR variable */ + sz =rte_rcu_qsbr_get_memsize (RTE_MAX_LCORE ); + qsv = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (qsv !=NULL ); + + status =rte_rcu_qsbr_init (qsv,RTE_MAX_LCORE ); +TEST_LPM_ASSERT (status ==0 ); + + rcu_cfg.v = qsv; +/* Invalid QSBR mode */ + rcu_cfg.mode =2 ; + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status !=0 ); + + rcu_cfg.mode =RTE_LPM_QSBR_MODE_DQ ; +/* Attach RCU QSBR to LPM table */ + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status ==0 ); + +/* Create and attach another RCU QSBR to LPM table */ + qsv2 = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (qsv2 !=NULL ); + + rcu_cfg.v = qsv2; + rcu_cfg.mode =RTE_LPM_QSBR_MODE_SYNC ; + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status !=0 ); + +rte_lpm_free (lpm); +rte_free (qsv); +rte_free (qsv2); + +return PASS ; +} + +/* +* rte_lpm_rcu_qsbr_add DQ mode functional test. +* Reader and writer are in the same thread in this test. +* - Create LPM which supports 1 tbl8 group at max +* - Add RCU QSBR variable to LPM +* - Add a rule with depth=28 (> 24) +* - Register a reader thread (not a real thread) +* - Reader lookup existing rule +* - Writer delete the rule +* - Reader lookup the rule +* - Writer re-add the rule (no available tbl8 group) +* - Reader report quiescent state and unregister +* - Writer re-add the rule +* - Reader lookup the rule +*/ +int32_t +test20 (void ) +{ +struct rte_lpm *lpm =NULL ; +struct rte_lpm_config config; +size_t sz; +struct rte_rcu_qsbr *qsv; +int32_t status; +uint32_t ip, next_hop, next_hop_return; +uint8_t depth; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + + config.max_rules =MAX_RULES ; + config.number_tbl8s =1 ; + config.flags =0 ; + + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Create RCU QSBR variable */ + sz =rte_rcu_qsbr_get_memsize (1 ); + qsv = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (qsv !=NULL ); +
app/test/test_lpm.c test18(void) · line 1385
Quoted 10 lines
app/test/test_lpm.c +10
-0+ status =rte_rcu_qsbr_init (qsv,1 ); +TEST_LPM_ASSERT (status ==0 ); + + rcu_cfg.v = qsv; + rcu_cfg.mode =RTE_LPM_QSBR_MODE_DQ ; +/* Attach RCU QSBR to LPM table */ + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status ==0 ); + + ip =RTE_IPV4 (192 ,18 ,100 ,100 );
This is a globally routed ip, it looks like you missed "6" in the second octet. Here it is better to use the rfc5737 address, rather than rfc1918.
Quoted 39 lines
app/test/test_lpm.c +39
-0+ depth =28 ; + next_hop =1 ; + status =rte_lpm_add (lpm, ip, depth, next_hop); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (lpm->tbl24[ip>>8 ].valid_group); + +/* Register pseudo reader */ + status =rte_rcu_qsbr_thread_register (qsv,0 ); +TEST_LPM_ASSERT (status ==0 ); +rte_rcu_qsbr_thread_online (qsv,0 ); + + status =rte_lpm_lookup (lpm, ip, &next_hop_return); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (next_hop_return == next_hop); + +/* Writer update */ + status =rte_lpm_delete (lpm, ip, depth); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (!lpm->tbl24[ip>>8 ].valid); + + status =rte_lpm_lookup (lpm, ip, &next_hop_return); +TEST_LPM_ASSERT (status !=0 ); + + status =rte_lpm_add (lpm, ip, depth, next_hop); +TEST_LPM_ASSERT (status !=0 ); + +/* Reader quiescent */ +rte_rcu_qsbr_quiescent (qsv,0 ); + + status =rte_lpm_add (lpm, ip, depth, next_hop); +TEST_LPM_ASSERT (status ==0 ); + +rte_rcu_qsbr_thread_offline (qsv,0 ); + status =rte_rcu_qsbr_thread_unregister (qsv,0 ); +TEST_LPM_ASSERT (status ==0 ); + + status =rte_lpm_lookup (lpm, ip, &next_hop_return); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (next_hop_return == next_hop);
app/test/test_lpm.c test18(void) · line 1434
Quoted 10 lines
app/test/test_lpm.c +10
-0+ +rte_lpm_free (lpm); +rte_free (qsv); + +return PASS ; +} + +static struct rte_lpm *g_lpm; +static struct rte_rcu_qsbr *g_v; +static uint32_t g_ip =RTE_IPV4 (192 ,18 ,100 ,100 );
Same here as above
Quoted 115 lines
app/test/test_lpm.c +115
-0+static volatile uint8_t writer_done; +/* Report quiescent state interval every 1024 lookups. Larger critical +* sections in reader will result in writer polling multiple times. +*/ +#define QSBR_REPORTING_INTERVAL 1024 +#define WRITER_ITERATIONS 512 + +/* +* Reader thread using rte_lpm data structure with RCU. +*/ +static int +test_lpm_rcu_qsbr_reader (void *arg) +{ +int i; +uint32_t next_hop_return =0 ; + +RTE_SET_USED (arg); +/* Register this thread to report quiescent state */ +rte_rcu_qsbr_thread_register (g_v,0 ); +rte_rcu_qsbr_thread_online (g_v,0 ); + +do { +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) +rte_lpm_lookup (g_lpm, g_ip, &next_hop_return); + +/* Update quiescent state */ +rte_rcu_qsbr_quiescent (g_v,0 ); + }while (!writer_done); + +rte_rcu_qsbr_thread_offline (g_v,0 ); +rte_rcu_qsbr_thread_unregister (g_v,0 ); + +return 0 ; +} + +/* +* rte_lpm_rcu_qsbr_add sync mode functional test. +* 1 Reader and 1 writer. They cannot be in the same thread in this test. +* - Create LPM which supports 1 tbl8 group at max +* - Add RCU QSBR variable with sync mode to LPM +* - Register a reader thread. Reader keeps looking up a specific rule. +* - Writer keeps adding and deleting a specific rule with depth=28 (> 24) +*/ +int32_t +test21 (void ) +{ +struct rte_lpm_config config; +size_t sz; +int32_t status; +uint32_t i, next_hop; +uint8_t depth; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + +if (rte_lcore_count () <2 ) { +printf ("Not enough cores for %s, expecting at least 2\n" , + __func__); +return TEST_SKIPPED ; + } + + config.max_rules =MAX_RULES ; + config.number_tbl8s =1 ; + config.flags =0 ; + + g_lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (g_lpm !=NULL ); + +/* Create RCU QSBR variable */ + sz =rte_rcu_qsbr_get_memsize (1 ); + g_v = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (g_v !=NULL ); + + status =rte_rcu_qsbr_init (g_v,1 ); +TEST_LPM_ASSERT (status ==0 ); + + rcu_cfg.v = g_v; + rcu_cfg.mode =RTE_LPM_QSBR_MODE_SYNC ; +/* Attach RCU QSBR to LPM table */ + status =rte_lpm_rcu_qsbr_add (g_lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status ==0 ); + + writer_done =0 ; +/* Launch reader thread */ +rte_eal_remote_launch (test_lpm_rcu_qsbr_reader,NULL , +rte_get_next_lcore (-1 ,1 ,0 )); + + depth =28 ; + next_hop =1 ; + status =rte_lpm_add (g_lpm, g_ip, depth, next_hop); +if (status !=0 ) { +printf ("%s: Failed to add rule\n" , __func__); + goto error; + } + +/* Writer update */ +for (i =0 ; i <WRITER_ITERATIONS ; i++) { + status =rte_lpm_delete (g_lpm, g_ip, depth); +if (status !=0 ) { +printf ("%s: Failed to delete rule at iteration %d\n" , + __func__, i); + goto error; + } + + status =rte_lpm_add (g_lpm, g_ip, depth, next_hop); +if (status !=0 ) { +printf ("%s: Failed to add rule at iteration %d\n" , + __func__, i); + goto error; + } + } + +error: + writer_done =1 ; +/* Wait until reader exited. */ +rte_eal_mp_wait_lcore ();
app/test/test_lpm.c test18(void) · line 1559
Quoted 10 lines
app/test/test_lpm.c +7
-0+ +rte_lpm_free (g_lpm); +rte_free (g_v); + +return (status ==0 ) ?PASS :-1 ; +} +/* * Do all unit tests. */
Signature · 2 lines
Regards, Vladimir
Re: [dpdk-dev] [PATCH v7 2/3] test/lpm: add LPM RCU integration functional tests
From: Medvedkin, Vladimir <[email protected]>
Sent: Wednesday, July 8, 2020 8:37 PM
To: Ruifeng Wang <[email protected]>; Bruce Richardson <[email protected]>
Cc: [email protected]; [email protected]; [email protected]; Honnappa Nagarahalli <[email protected]>; nd <[email protected]>
Subject: Re: [PATCH v7 2/3] test/lpm: add LPM RCU integration functional tests
Hi Ruifeng,
Just a few nits
[Ruifeng] Thank you for reviewing this patch.
On 07/07/2020 16:15, Ruifeng Wang wrote:
Add positive and negative tests for API rte_lpm_rcu_qsbr_add.
Also test LPM library behavior when RCU QSBR is enabled.
---
app/test/test_lpm.c | 291 +++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 290 insertions(+), 1 deletion(-)
app/test/test_lpm.c +0 -0
index 3a3fd097f..93742e3c7 100644
--- a/app/test/test_lpm.c
+++ b/app/test/test_lpm.c
@@ -8,6 +8,7 @@
#include <rte_ip.h>
#include <rte_lpm.h>
+#include <rte_malloc.h>
#include "test.h"
#include "test_xmmt_ops.h"
@@ -40,6 +41,9 @@ static int32_t test15(void);
static int32_t test16(void);
static int32_t test17(void);
static int32_t test18(void);
+static int32_t test19(void);
+static int32_t test20(void);
+static int32_t test21(void);
rte_lpm_test tests[] = {
/* Test Cases */
@@ -61,7 +65,10 @@ rte_lpm_test tests[] = {
test15,
test16,
test17,- test18
+ test18,
+ test19,
+ test20,
+ test21
};
#define MAX_DEPTH 32
@@ -1265,6 +1272,288 @@ test18(void)
return PASS;
}
+/*
+ * rte_lpm_rcu_qsbr_add positive and negative tests.
+ * - Add RCU QSBR variable to LPM
+ * - Add another RCU QSBR variable to LPM
+ * - Check returns
+ */
+int32_t
+test19(void)
+{
+ struct rte_lpm *lpm = NULL;
+ struct rte_lpm_config config;
+ size_t sz;
+ struct rte_rcu_qsbr *qsv;
+ struct rte_rcu_qsbr *qsv2;
+ int32_t status;
+ struct rte_lpm_rcu_config rcu_cfg = {0};
+
+ config.max_rules = MAX_RULES;
+ config.number_tbl8s = NUMBER_TBL8S;
+ config.flags = 0;
+
+ lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
+ TEST_LPM_ASSERT(lpm != NULL);
+
+ /* Create RCU QSBR variable */
+ sz = rte_rcu_qsbr_get_memsize(RTE_MAX_LCORE);
+ qsv = (struct rte_rcu_qsbr *)rte_zmalloc_socket(NULL, sz,
+ RTE_CACHE_LINE_SIZE, SOCKET_ID_ANY);
+ TEST_LPM_ASSERT(qsv != NULL);
+
+ status = rte_rcu_qsbr_init(qsv, RTE_MAX_LCORE);
+ TEST_LPM_ASSERT(status == 0);
+
+ rcu_cfg.v = qsv;
+ /* Invalid QSBR mode */
+ rcu_cfg.mode = 2;
+ status = rte_lpm_rcu_qsbr_add(lpm, &rcu_cfg, NULL);
+ TEST_LPM_ASSERT(status != 0);
+
+ rcu_cfg.mode = RTE_LPM_QSBR_MODE_DQ;
+ /* Attach RCU QSBR to LPM table */
+ status = rte_lpm_rcu_qsbr_add(lpm, &rcu_cfg, NULL);
+ TEST_LPM_ASSERT(status == 0);
+
+ /* Create and attach another RCU QSBR to LPM table */
+ qsv2 = (struct rte_rcu_qsbr *)rte_zmalloc_socket(NULL, sz,
+ RTE_CACHE_LINE_SIZE, SOCKET_ID_ANY);
+ TEST_LPM_ASSERT(qsv2 != NULL);
+
+ rcu_cfg.v = qsv2;
+ rcu_cfg.mode = RTE_LPM_QSBR_MODE_SYNC;
+ status = rte_lpm_rcu_qsbr_add(lpm, &rcu_cfg, NULL);
+ TEST_LPM_ASSERT(status != 0);
+
+ rte_lpm_free(lpm);
+ rte_free(qsv);
+ rte_free(qsv2);
+
+ return PASS;
+}
+
+/*
+ * rte_lpm_rcu_qsbr_add DQ mode functional test.
+ * Reader and writer are in the same thread in this test.
+ * - Create LPM which supports 1 tbl8 group at max
+ * - Add RCU QSBR variable to LPM
+ * - Add a rule with depth=28 (> 24)
+ * - Register a reader thread (not a real thread)
+ * - Reader lookup existing rule
+ * - Writer delete the rule
+ * - Reader lookup the rule
+ * - Writer re-add the rule (no available tbl8 group)
+ * - Reader report quiescent state and unregister
+ * - Writer re-add the rule
+ * - Reader lookup the rule
+ */
+int32_t
+test20(void)
+{
+ struct rte_lpm *lpm = NULL;
+ struct rte_lpm_config config;
+ size_t sz;
+ struct rte_rcu_qsbr *qsv;
+ int32_t status;
+ uint32_t ip, next_hop, next_hop_return;
+ uint8_t depth;
+ struct rte_lpm_rcu_config rcu_cfg = {0};
+
+ config.max_rules = MAX_RULES;
+ config.number_tbl8s = 1;
+ config.flags = 0;
+
+ lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
+ TEST_LPM_ASSERT(lpm != NULL);
+
+ /* Create RCU QSBR variable */
+ sz = rte_rcu_qsbr_get_memsize(1);
+ qsv = (struct rte_rcu_qsbr *)rte_zmalloc_socket(NULL, sz,
+ RTE_CACHE_LINE_SIZE, SOCKET_ID_ANY);
+ TEST_LPM_ASSERT(qsv != NULL);
+
+ status = rte_rcu_qsbr_init(qsv, 1);
+ TEST_LPM_ASSERT(status == 0);
+
+ rcu_cfg.v = qsv;
+ rcu_cfg.mode = RTE_LPM_QSBR_MODE_DQ;
+ /* Attach RCU QSBR to LPM table */
+ status = rte_lpm_rcu_qsbr_add(lpm, &rcu_cfg, NULL);
+ TEST_LPM_ASSERT(status == 0);
+
+ ip = RTE_IPV4(192, 18, 100, 100);
This is a globally routed ip, it looks like you missed "6" in the second octet. Here it is better to use the rfc5737 address, rather than rfc1918.
[Ruifeng] Agreed. Use reserved address is better. Will change to rfc5737 address in next version.
+ depth = 28;
+ next_hop = 1;
+ status = rte_lpm_add(lpm, ip, depth, next_hop);
+ TEST_LPM_ASSERT(status == 0);
+ TEST_LPM_ASSERT(lpm->tbl24[ip>>8].valid_group);
+
+ /* Register pseudo reader */
+ status = rte_rcu_qsbr_thread_register(qsv, 0);
+ TEST_LPM_ASSERT(status == 0);
+ rte_rcu_qsbr_thread_online(qsv, 0);
+
+ status = rte_lpm_lookup(lpm, ip, &next_hop_return);
+ TEST_LPM_ASSERT(status == 0);
+ TEST_LPM_ASSERT(next_hop_return == next_hop);
+
+ /* Writer update */
+ status = rte_lpm_delete(lpm, ip, depth);
+ TEST_LPM_ASSERT(status == 0);
+ TEST_LPM_ASSERT(!lpm->tbl24[ip>>8].valid);
+
+ status = rte_lpm_lookup(lpm, ip, &next_hop_return);
+ TEST_LPM_ASSERT(status != 0);
+
+ status = rte_lpm_add(lpm, ip, depth, next_hop);
+ TEST_LPM_ASSERT(status != 0);
+
+ /* Reader quiescent */
+ rte_rcu_qsbr_quiescent(qsv, 0);
+
+ status = rte_lpm_add(lpm, ip, depth, next_hop);
+ TEST_LPM_ASSERT(status == 0);
+
+ rte_rcu_qsbr_thread_offline(qsv, 0);
+ status = rte_rcu_qsbr_thread_unregister(qsv, 0);
+ TEST_LPM_ASSERT(status == 0);
+
+ status = rte_lpm_lookup(lpm, ip, &next_hop_return);
+ TEST_LPM_ASSERT(status == 0);
+ TEST_LPM_ASSERT(next_hop_return == next_hop);
+
+ rte_lpm_free(lpm);
+ rte_free(qsv);
+
+ return PASS;
+}
+
+static struct rte_lpm *g_lpm;
+static struct rte_rcu_qsbr *g_v;
+static uint32_t g_ip = RTE_IPV4(192, 18, 100, 100);
Same here as above
[Ruifeng] Will change. Thank you.
+static volatile uint8_t writer_done;
+/* Report quiescent state interval every 1024 lookups. Larger critical
+ * sections in reader will result in writer polling multiple times.
+ */
+#define QSBR_REPORTING_INTERVAL 1024
+#define WRITER_ITERATIONS 512
+
+/*
+ * Reader thread using rte_lpm data structure with RCU.
+ */
+static int
+test_lpm_rcu_qsbr_reader(void *arg)
+{
+ int i;
+ uint32_t next_hop_return = 0;
+
+ RTE_SET_USED(arg);
+ /* Register this thread to report quiescent state */
+ rte_rcu_qsbr_thread_register(g_v, 0);
+ rte_rcu_qsbr_thread_online(g_v, 0);
+
+ do {
+ for (i = 0; i < QSBR_REPORTING_INTERVAL; i++)
+ rte_lpm_lookup(g_lpm, g_ip, &next_hop_return);
+
+ /* Update quiescent state */
+ rte_rcu_qsbr_quiescent(g_v, 0);
+ } while (!writer_done);
+
+ rte_rcu_qsbr_thread_offline(g_v, 0);
+ rte_rcu_qsbr_thread_unregister(g_v, 0);
+
+ return 0;
+}
+
+/*
+ * rte_lpm_rcu_qsbr_add sync mode functional test.
+ * 1 Reader and 1 writer. They cannot be in the same thread in this test.
+ * - Create LPM which supports 1 tbl8 group at max
+ * - Add RCU QSBR variable with sync mode to LPM
+ * - Register a reader thread. Reader keeps looking up a specific rule.
+ * - Writer keeps adding and deleting a specific rule with depth=28 (> 24)
+ */
+int32_t
+test21(void)
+{
+ struct rte_lpm_config config;
+ size_t sz;
+ int32_t status;
+ uint32_t i, next_hop;
+ uint8_t depth;
+ struct rte_lpm_rcu_config rcu_cfg = {0};
+
+ if (rte_lcore_count() < 2) {
+ printf("Not enough cores for %s, expecting at least 2\n",
+ __func__);
+ return TEST_SKIPPED;
+ }
+
+ config.max_rules = MAX_RULES;
+ config.number_tbl8s = 1;
+ config.flags = 0;
+
+ g_lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
+ TEST_LPM_ASSERT(g_lpm != NULL);
+
+ /* Create RCU QSBR variable */
+ sz = rte_rcu_qsbr_get_memsize(1);
+ g_v = (struct rte_rcu_qsbr *)rte_zmalloc_socket(NULL, sz,
+ RTE_CACHE_LINE_SIZE, SOCKET_ID_ANY);
+ TEST_LPM_ASSERT(g_v != NULL);
+
+ status = rte_rcu_qsbr_init(g_v, 1);
+ TEST_LPM_ASSERT(status == 0);
+
+ rcu_cfg.v = g_v;
+ rcu_cfg.mode = RTE_LPM_QSBR_MODE_SYNC;
+ /* Attach RCU QSBR to LPM table */
+ status = rte_lpm_rcu_qsbr_add(g_lpm, &rcu_cfg, NULL);
+ TEST_LPM_ASSERT(status == 0);
+
+ writer_done = 0;
+ /* Launch reader thread */
+ rte_eal_remote_launch(test_lpm_rcu_qsbr_reader, NULL,
+ rte_get_next_lcore(-1, 1, 0));
+
+ depth = 28;
+ next_hop = 1;
+ status = rte_lpm_add(g_lpm, g_ip, depth, next_hop);
+ if (status != 0) {
+ printf("%s: Failed to add rule\n", __func__);
+ goto error;
+ }
+
+ /* Writer update */
+ for (i = 0; i < WRITER_ITERATIONS; i++) {
+ status = rte_lpm_delete(g_lpm, g_ip, depth);
+ if (status != 0) {
+ printf("%s: Failed to delete rule at iteration %d\n",
+ __func__, i);
+ goto error;
+ }
+
+ status = rte_lpm_add(g_lpm, g_ip, depth, next_hop);
+ if (status != 0) {
+ printf("%s: Failed to add rule at iteration %d\n",
+ __func__, i);
+ goto error;
+ }
+ }
+
+error:
+ writer_done = 1;
+ /* Wait until reader exited. */
+ rte_eal_mp_wait_lcore();
+
+ rte_lpm_free(g_lpm);
+ rte_free(g_v);
+
+ return (status == 0) ? PASS : -1;
+}
+
/*
* Do all unit tests.
*/
--
Regards,
Vladimir
PATCH v7 3/3 test/lpm: add RCU integration performance tests
In reply to Ruifeng WangFrom: Honnappa Nagarahalli <[email protected]>
Add performance tests for RCU integration. The performance difference with and without RCU integration is very small (~1% to ~2%) on both Arm and x86 platforms.
--- app/test/test_lpm_perf.c | 492 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 489 insertions(+), 3 deletions(-)
app/test/test_lpm_perf.c +489 -3
@@ -1,5 +1,6 @@/* SPDX-License-Identifier: BSD-3-Clause * Copyright(c) 2010-2014 Intel Corporation +* Copyright(c) 2020 Arm Limited */ #include <stdio.h>
@@ -10,12 +11,27 @@#include <rte_cycles.h> #include <rte_random.h> #include <rte_branch_prediction.h> +#include <rte_malloc.h> #include <rte_ip.h> #include <rte_lpm.h> #include "test.h" #include "test_xmmt_ops.h" +struct rte_lpm *lpm; +static struct rte_rcu_qsbr *rv; +static volatile uint8_t writer_done; +static volatile uint32_t thr_id; +static uint64_t gwrite_cycles; +static uint64_t gwrites; +/* LPM APIs are not thread safe, use mutex to provide thread safety */ +static pthread_mutex_t lpm_mutex =PTHREAD_MUTEX_INITIALIZER ; + +/* Report quiescent state interval every 1024 lookups. Larger critical +* sections in reader will result in writer polling multiple times. +*/ +#define QSBR_REPORTING_INTERVAL 1024 +#define TEST_LPM_ASSERT (cond) do { \ if (!(cond)) { \ printf("Error at line %d: \n", __LINE__); \
@@ -24,6 +40,7 @@ } while(0)#define ITERATIONS (1 << 10) +#define RCU_ITERATIONS 10#define BATCH_SIZE (1 << 12)#define BULK_SIZE 32
@@ -35,9 +52,13 @@ struct route_rule { };static struct route_rule large_route_table[MAX_RULE_NUM ]; +/* Route table for routes with depth > 24 */ +struct route_rule large_ldepth_route_table[MAX_RULE_NUM ];static uint32_t num_route_entries; +static uint32_t num_ldepth_route_entries;#define NUM_ROUTE_ENTRIES num_route_entries +#define NUM_LDEPTH_ROUTE_ENTRIES num_ldepth_route_entriesenum {IP_CLASS_A ,
@@ -191,7 +212,7 @@ static void generate_random_rule_prefix(uint32_t ip_class, uint8_t depth)uint32_t ip_head_mask;uint32_t rule_num;uint32_t k; -struct route_rule *ptr_rule; +struct route_rule *ptr_rule, *ptr_ldepth_rule;if (ip_class ==IP_CLASS_A ) {/* IP Address class A */ fixed_bit_num =IP_HEAD_BIT_NUM_A ;
@@ -236,10 +257,20 @@ static void generate_random_rule_prefix(uint32_t ip_class, uint8_t depth)*/ start =lrand48 () & mask; ptr_rule = &large_route_table[num_route_entries]; + ptr_ldepth_rule = &large_ldepth_route_table[num_ldepth_route_entries];for (k =0 ; k < rule_num; k++) { ptr_rule->ip = (start << (RTE_LPM_MAX_DEPTH - depth)) | ip_head_mask; ptr_rule->depth = depth; +/* If the depth of the route is more than 24, store it +* in another table as well. +*/ +if (depth >24 ) { + ptr_ldepth_rule->ip = ptr_rule->ip; + ptr_ldepth_rule->depth = ptr_rule->depth; + ptr_ldepth_rule++; + num_ldepth_route_entries++; + } ptr_rule++; start = (start + step) & mask; }
@@ -273,6 +304,7 @@ static void generate_large_route_rule_table(void)uint8_t depth; num_route_entries =0 ; + num_ldepth_route_entries =0 ;memset (large_route_table,0 ,sizeof (large_route_table));for (ip_class =IP_CLASS_A ; ip_class <=IP_CLASS_C ; ip_class++) {
@@ -316,10 +348,460 @@ print_route_distribution(const struct route_rule *table, uint32_t n)printf ("\n" ); } +/* Check condition and return an error if true. */ +static uint16_t enabled_core_ids[RTE_MAX_LCORE ]; +static unsigned int num_cores; + +/* Simple way to allocate thread ids in 0 to RTE_MAX_LCORE space */ +static inline uint32_t +alloc_thread_id (void ) +{ +uint32_t tmp_thr_id; + + tmp_thr_id =__atomic_fetch_add (&thr_id,1 , __ATOMIC_RELAXED); +if (tmp_thr_id >=RTE_MAX_LCORE ) +printf ("Invalid thread id %u\n" , tmp_thr_id); + +return tmp_thr_id; +} + +/* +* Reader thread using rte_lpm data structure without RCU. +*/ +static int +test_lpm_reader (void *arg) +{ +int i; +uint32_t ip_batch[QSBR_REPORTING_INTERVAL ]; +uint32_t next_hop_return =0 ; + +RTE_SET_USED (arg); +do { +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) + ip_batch[i] =rte_rand (); + +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) +rte_lpm_lookup (lpm, ip_batch[i], &next_hop_return); + + }while (!writer_done); + +return 0 ; +} + +/* +* Reader thread using rte_lpm data structure with RCU. +*/ +static int +test_lpm_rcu_qsbr_reader (void *arg) +{ +int i; +uint32_t thread_id =alloc_thread_id (); +uint32_t ip_batch[QSBR_REPORTING_INTERVAL ]; +uint32_t next_hop_return =0 ; + +RTE_SET_USED (arg); +/* Register this thread to report quiescent state */ +rte_rcu_qsbr_thread_register (rv, thread_id); +rte_rcu_qsbr_thread_online (rv, thread_id); + +do { +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) + ip_batch[i] =rte_rand (); + +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) +rte_lpm_lookup (lpm, ip_batch[i], &next_hop_return); + +/* Update quiescent state */ +rte_rcu_qsbr_quiescent (rv, thread_id); + }while (!writer_done); + +rte_rcu_qsbr_thread_offline (rv, thread_id); +rte_rcu_qsbr_thread_unregister (rv, thread_id); + +return 0 ; +} + +/* +* Writer thread using rte_lpm data structure with RCU. +*/ +static int +test_lpm_rcu_qsbr_writer (void *arg) +{ +unsigned int i, j, si, ei; +uint64_t begin, total_cycles; +uint8_t core_id = (uint8_t )((uintptr_t )arg); +uint32_t next_hop_add =0xAA ; + +RTE_SET_USED (arg); +/* 2 writer threads are used */ +if (core_id %2 ==0 ) { + si =0 ; + ei =NUM_LDEPTH_ROUTE_ENTRIES /2 ; + }else { + si =NUM_LDEPTH_ROUTE_ENTRIES /2 ; + ei =NUM_LDEPTH_ROUTE_ENTRIES ; + } + +/* Measure add/delete. */ + begin =rte_rdtsc_precise (); +for (i =0 ; i <RCU_ITERATIONS ; i++) { +/* Add all the entries */ +for (j = si; j < ei; j++) { +pthread_mutex_lock (&lpm_mutex); +if (rte_lpm_add (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth, + next_hop_add) !=0 ) { +printf ("Failed to add iteration %d, route# %d\n" , + i, j); + } +pthread_mutex_unlock (&lpm_mutex); + } + +/* Delete all the entries */ +for (j = si; j < ei; j++) { +pthread_mutex_lock (&lpm_mutex); +if (rte_lpm_delete (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth) !=0 ) { +printf ("Failed to delete iteration %d, route# %d\n" , + i, j); + } +pthread_mutex_unlock (&lpm_mutex); + } + } + + total_cycles =rte_rdtsc_precise () - begin; + +__atomic_fetch_add (&gwrite_cycles, total_cycles, __ATOMIC_RELAXED); +__atomic_fetch_add (&gwrites, +2 *NUM_LDEPTH_ROUTE_ENTRIES *RCU_ITERATIONS , + __ATOMIC_RELAXED); + +return 0 ; +} + +/* +* Functional test: +* 2 writers, rest are readers +*/ +static int +test_lpm_rcu_perf_multi_writer (void ) +{ +struct rte_lpm_config config; +size_t sz; +unsigned int i; +uint16_t core_id; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + +if (rte_lcore_count () <3 ) { +printf ("Not enough cores for lpm_rcu_perf_autotest, expecting at least 3\n" ); +return TEST_SKIPPED ; + } + + num_cores =0 ; +RTE_LCORE_FOREACH_SLAVE (core_id) { + enabled_core_ids[num_cores] = core_id; + num_cores++; + } + +printf ("\nPerf test: 2 writers, %d readers, RCU integration enabled\n" , + num_cores -2 ); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Init RCU variable */ + sz =rte_rcu_qsbr_get_memsize (num_cores); + rv = (struct rte_rcu_qsbr *)rte_zmalloc ("rcu0" , sz, +RTE_CACHE_LINE_SIZE ); +rte_rcu_qsbr_init (rv, num_cores); + + rcu_cfg.v = rv; +/* Assign the RCU variable to LPM */ +if (rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ) !=0 ) { +printf ("RCU variable assignment failed\n" ); + goto error; + } + + writer_done =0 ; +__atomic_store_n (&gwrite_cycles,0 , __ATOMIC_RELAXED); +__atomic_store_n (&gwrites,0 , __ATOMIC_RELAXED); + +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =2 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_reader,NULL , + enabled_core_ids[i]); + +/* Launch writer threads */ +for (i =0 ; i <2 ; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_writer, + (void *)(uintptr_t )i, + enabled_core_ids[i]); + +/* Wait for writer threads */ +for (i =0 ; i <2 ; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +printf ("Total LPM Adds: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %" PRIu64" cycles\n" , +__atomic_load_n (&gwrite_cycles, __ATOMIC_RELAXED) / +__atomic_load_n (&gwrites, __ATOMIC_RELAXED) + ); + +/* Wait and check return value from reader threads */ + writer_done =1 ; +for (i =2 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +rte_lpm_free (lpm); +rte_free (rv); + lpm =NULL ; + rv =NULL ; + +/* Test without RCU integration */ +printf ("\nPerf test: 2 writers, %d readers, RCU integration disabled\n" , + num_cores -2 ); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + + writer_done =0 ; +__atomic_store_n (&gwrite_cycles,0 , __ATOMIC_RELAXED); +__atomic_store_n (&gwrites,0 , __ATOMIC_RELAXED); +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =2 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_reader,NULL , + enabled_core_ids[i]); + +/* Launch writer threads */ +for (i =0 ; i <2 ; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_writer, + (void *)(uintptr_t )i, + enabled_core_ids[i]); + +/* Wait for writer threads */ +for (i =0 ; i <2 ; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +printf ("Total LPM Adds: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %" PRIu64" cycles\n" , +__atomic_load_n (&gwrite_cycles, __ATOMIC_RELAXED) / +__atomic_load_n (&gwrites, __ATOMIC_RELAXED) + ); + + writer_done =1 ; +/* Wait and check return value from reader threads */ +for (i =2 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +rte_lpm_free (lpm); + +return 0 ; + +error: + writer_done =1 ; +/* Wait until all readers have exited */ +rte_eal_mp_wait_lcore (); + +rte_lpm_free (lpm); +rte_free (rv); + +return -1 ; +} + +/* +* Functional test: +* Single writer, rest are readers +*/ +static int +test_lpm_rcu_perf (void ) +{ +struct rte_lpm_config config; +uint64_t begin, total_cycles; +size_t sz; +unsigned int i, j; +uint16_t core_id; +uint32_t next_hop_add =0xAA ; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + +if (rte_lcore_count () <2 ) { +printf ("Not enough cores for lpm_rcu_perf_autotest, expecting at least 2\n" ); +return TEST_SKIPPED ; + } + + num_cores =0 ; +RTE_LCORE_FOREACH_SLAVE (core_id) { + enabled_core_ids[num_cores] = core_id; + num_cores++; + } + +printf ("\nPerf test: 1 writer, %d readers, RCU integration enabled\n" , + num_cores); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Init RCU variable */ + sz =rte_rcu_qsbr_get_memsize (num_cores); + rv = (struct rte_rcu_qsbr *)rte_zmalloc ("rcu0" , sz, +RTE_CACHE_LINE_SIZE ); +rte_rcu_qsbr_init (rv, num_cores); + + rcu_cfg.v = rv; +/* Assign the RCU variable to LPM */ +if (rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ) !=0 ) { +printf ("RCU variable assignment failed\n" ); + goto error; + } + + writer_done =0 ; +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =0 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_reader,NULL , + enabled_core_ids[i]); + +/* Measure add/delete. */ + begin =rte_rdtsc_precise (); +for (i =0 ; i <RCU_ITERATIONS ; i++) { +/* Add all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_add (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth, + next_hop_add) !=0 ) { +printf ("Failed to add iteration %d, route# %d\n" , + i, j); + goto error; + } + +/* Delete all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_delete (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth) !=0 ) { +printf ("Failed to delete iteration %d, route# %d\n" , + i, j); + goto error; + } + } + total_cycles =rte_rdtsc_precise () - begin; + +printf ("Total LPM Adds: %d\n" ,ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %g cycles\n" , + (double )total_cycles / (NUM_LDEPTH_ROUTE_ENTRIES *ITERATIONS )); + + writer_done =1 ; +/* Wait and check return value from reader threads */ +for (i =0 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +rte_lpm_free (lpm); +rte_free (rv); + lpm =NULL ; + rv =NULL ; + +/* Test without RCU integration */ +printf ("\nPerf test: 1 writer, %d readers, RCU integration disabled\n" , + num_cores); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + + writer_done =0 ; +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =0 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_reader,NULL , + enabled_core_ids[i]); + +/* Measure add/delete. */ + begin =rte_rdtsc_precise (); +for (i =0 ; i <RCU_ITERATIONS ; i++) { +/* Add all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_add (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth, + next_hop_add) !=0 ) { +printf ("Failed to add iteration %d, route# %d\n" , + i, j); + goto error; + } + +/* Delete all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_delete (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth) !=0 ) { +printf ("Failed to delete iteration %d, route# %d\n" , + i, j); + goto error; + } + } + total_cycles =rte_rdtsc_precise () - begin; + +printf ("Total LPM Adds: %d\n" ,ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %g cycles\n" , + (double )total_cycles / (NUM_LDEPTH_ROUTE_ENTRIES *ITERATIONS )); + + writer_done =1 ; +/* Wait and check return value from reader threads */ +for (i =0 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) +printf ("Warning: lcore %u not finished.\n" , + enabled_core_ids[i]); + +rte_lpm_free (lpm); + +return 0 ; + +error: + writer_done =1 ; +/* Wait until all readers have exited */ +rte_eal_mp_wait_lcore (); + +rte_lpm_free (lpm); +rte_free (rv); + +return -1 ; +} +static int test_lpm_perf (void ) { -struct rte_lpm *lpm =NULL ;struct rte_lpm_config config; config.max_rules =2000000 ;
@@ -343,7 +825,7 @@ test_lpm_perf(void) lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config);TEST_LPM_ASSERT (lpm !=NULL ); -/* Measue add. */ +/* Measure add. */ begin =rte_rdtsc ();for (i =0 ; i <NUM_ROUTE_ENTRIES ; i++) {
@@ -478,6 +960,10 @@ test_lpm_perf(void)rte_lpm_delete_all (lpm);rte_lpm_free (lpm); +test_lpm_rcu_perf (); + +test_lpm_rcu_perf_multi_writer (); +return 0 ; }
Signature · 1 line
2.17.1
Re: [dpdk-dev] [PATCH v7 3/3] test/lpm: add RCU integration performance tests
Quoted 575 lines · Ruifeng Wang
From: Honnappa Nagarahalli <[email protected]>
Add performance tests for RCU integration. The performance difference with and without RCU integration is very small (~1% to ~2%) on both Arm and x86 platforms.
Signed-off-by Honnappa Nagarahalli <[email protected]>Reviewed-by Gavin Hu <[email protected]>Reviewed-by Ruifeng Wang <[email protected]>--- app/test/test_lpm_perf.c | 492 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 489 insertions(+), 3 deletions(-)app/test/test_lpm_perf.c +484
-2@@ -1,5 +1,6 @@/* SPDX-License-Identifier: BSD-3-Clause * Copyright(c) 2010-2014 Intel Corporation +* Copyright(c) 2020 Arm Limited */ #include <stdio.h> @@ -10,12 +11,27 @@#include <rte_cycles.h> #include <rte_random.h> #include <rte_branch_prediction.h> +#include <rte_malloc.h> #include <rte_ip.h> #include <rte_lpm.h> #include "test.h" #include "test_xmmt_ops.h" +struct rte_lpm *lpm; +static struct rte_rcu_qsbr *rv; +static volatile uint8_t writer_done; +static volatile uint32_t thr_id; +static uint64_t gwrite_cycles; +static uint64_t gwrites; +/* LPM APIs are not thread safe, use mutex to provide thread safety */ +static pthread_mutex_t lpm_mutex =PTHREAD_MUTEX_INITIALIZER ; + +/* Report quiescent state interval every 1024 lookups. Larger critical +* sections in reader will result in writer polling multiple times. +*/ +#define QSBR_REPORTING_INTERVAL 1024 +#define TEST_LPM_ASSERT (cond) do { \ if (!(cond)) { \ printf("Error at line %d: \n", __LINE__); \@@ -24,6 +40,7 @@ } while(0)#define ITERATIONS (1 << 10) +#define RCU_ITERATIONS 10#define BATCH_SIZE (1 << 12)#define BULK_SIZE 32@@ -35,9 +52,13 @@ struct route_rule { };static struct route_rule large_route_table[MAX_RULE_NUM ]; +/* Route table for routes with depth > 24 */ +struct route_rule large_ldepth_route_table[MAX_RULE_NUM ];static uint32_t num_route_entries; +static uint32_t num_ldepth_route_entries;#define NUM_ROUTE_ENTRIES num_route_entries +#define NUM_LDEPTH_ROUTE_ENTRIES num_ldepth_route_entriesenum {IP_CLASS_A ,@@ -191,7 +212,7 @@ static void generate_random_rule_prefix(uint32_t ip_class, uint8_t depth)uint32_t ip_head_mask;uint32_t rule_num;uint32_t k; -struct route_rule *ptr_rule; +struct route_rule *ptr_rule, *ptr_ldepth_rule;if (ip_class ==IP_CLASS_A ) {/* IP Address class A */ fixed_bit_num =IP_HEAD_BIT_NUM_A ;@@ -236,10 +257,20 @@ static void generate_random_rule_prefix(uint32_t ip_class, uint8_t depth)*/ start =lrand48 () & mask; ptr_rule = &large_route_table[num_route_entries]; + ptr_ldepth_rule = &large_ldepth_route_table[num_ldepth_route_entries];for (k =0 ; k < rule_num; k++) { ptr_rule->ip = (start << (RTE_LPM_MAX_DEPTH - depth)) | ip_head_mask; ptr_rule->depth = depth; +/* If the depth of the route is more than 24, store it +* in another table as well. +*/ +if (depth >24 ) { + ptr_ldepth_rule->ip = ptr_rule->ip; + ptr_ldepth_rule->depth = ptr_rule->depth; + ptr_ldepth_rule++; + num_ldepth_route_entries++; + } ptr_rule++; start = (start + step) & mask; }@@ -273,6 +304,7 @@ static void generate_large_route_rule_table(void)uint8_t depth; num_route_entries =0 ; + num_ldepth_route_entries =0 ;memset (large_route_table,0 ,sizeof (large_route_table));for (ip_class =IP_CLASS_A ; ip_class <=IP_CLASS_C ; ip_class++) {@@ -316,10 +348,460 @@ print_route_distribution(const struct route_rule *table, uint32_t n)printf ("\n" ); } +/* Check condition and return an error if true. */ +static uint16_t enabled_core_ids[RTE_MAX_LCORE ]; +static unsigned int num_cores; + +/* Simple way to allocate thread ids in 0 to RTE_MAX_LCORE space */ +static inline uint32_t +alloc_thread_id (void ) +{ +uint32_t tmp_thr_id; + + tmp_thr_id =__atomic_fetch_add (&thr_id,1 , __ATOMIC_RELAXED); +if (tmp_thr_id >=RTE_MAX_LCORE ) +printf ("Invalid thread id %u\n" , tmp_thr_id); + +return tmp_thr_id; +} + +/* +* Reader thread using rte_lpm data structure without RCU. +*/ +static int +test_lpm_reader (void *arg) +{ +int i; +uint32_t ip_batch[QSBR_REPORTING_INTERVAL ]; +uint32_t next_hop_return =0 ; + +RTE_SET_USED (arg); +do { +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) + ip_batch[i] =rte_rand (); + +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) +rte_lpm_lookup (lpm, ip_batch[i], &next_hop_return); + + }while (!writer_done); + +return 0 ; +} + +/* +* Reader thread using rte_lpm data structure with RCU. +*/ +static int +test_lpm_rcu_qsbr_reader (void *arg) +{ +int i; +uint32_t thread_id =alloc_thread_id (); +uint32_t ip_batch[QSBR_REPORTING_INTERVAL ]; +uint32_t next_hop_return =0 ; + +RTE_SET_USED (arg); +/* Register this thread to report quiescent state */ +rte_rcu_qsbr_thread_register (rv, thread_id); +rte_rcu_qsbr_thread_online (rv, thread_id); + +do { +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) + ip_batch[i] =rte_rand (); + +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) +rte_lpm_lookup (lpm, ip_batch[i], &next_hop_return); + +/* Update quiescent state */ +rte_rcu_qsbr_quiescent (rv, thread_id); + }while (!writer_done); + +rte_rcu_qsbr_thread_offline (rv, thread_id); +rte_rcu_qsbr_thread_unregister (rv, thread_id); + +return 0 ; +} + +/* +* Writer thread using rte_lpm data structure with RCU. +*/ +static int +test_lpm_rcu_qsbr_writer (void *arg) +{ +unsigned int i, j, si, ei; +uint64_t begin, total_cycles; +uint8_t core_id = (uint8_t )((uintptr_t )arg); +uint32_t next_hop_add =0xAA ; + +RTE_SET_USED (arg); +/* 2 writer threads are used */ +if (core_id %2 ==0 ) { + si =0 ; + ei =NUM_LDEPTH_ROUTE_ENTRIES /2 ; + }else { + si =NUM_LDEPTH_ROUTE_ENTRIES /2 ; + ei =NUM_LDEPTH_ROUTE_ENTRIES ; + } + +/* Measure add/delete. */ + begin =rte_rdtsc_precise (); +for (i =0 ; i <RCU_ITERATIONS ; i++) { +/* Add all the entries */ +for (j = si; j < ei; j++) { +pthread_mutex_lock (&lpm_mutex); +if (rte_lpm_add (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth, + next_hop_add) !=0 ) { +printf ("Failed to add iteration %d, route# %d\n" , + i, j); + } +pthread_mutex_unlock (&lpm_mutex); + } + +/* Delete all the entries */ +for (j = si; j < ei; j++) { +pthread_mutex_lock (&lpm_mutex); +if (rte_lpm_delete (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth) !=0 ) { +printf ("Failed to delete iteration %d, route# %d\n" , + i, j); + } +pthread_mutex_unlock (&lpm_mutex); + } + } + + total_cycles =rte_rdtsc_precise () - begin; + +__atomic_fetch_add (&gwrite_cycles, total_cycles, __ATOMIC_RELAXED); +__atomic_fetch_add (&gwrites, +2 *NUM_LDEPTH_ROUTE_ENTRIES *RCU_ITERATIONS , + __ATOMIC_RELAXED); + +return 0 ; +} + +/* +* Functional test: +* 2 writers, rest are readers +*/ +static int +test_lpm_rcu_perf_multi_writer (void ) +{ +struct rte_lpm_config config; +size_t sz; +unsigned int i; +uint16_t core_id; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + +if (rte_lcore_count () <3 ) { +printf ("Not enough cores for lpm_rcu_perf_autotest, expecting at least 3\n" ); +return TEST_SKIPPED ; + } + + num_cores =0 ; +RTE_LCORE_FOREACH_SLAVE (core_id) { + enabled_core_ids[num_cores] = core_id; + num_cores++; + } + +printf ("\nPerf test: 2 writers, %d readers, RCU integration enabled\n" , + num_cores -2 ); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Init RCU variable */ + sz =rte_rcu_qsbr_get_memsize (num_cores); + rv = (struct rte_rcu_qsbr *)rte_zmalloc ("rcu0" , sz, +RTE_CACHE_LINE_SIZE ); +rte_rcu_qsbr_init (rv, num_cores); + + rcu_cfg.v = rv; +/* Assign the RCU variable to LPM */ +if (rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ) !=0 ) { +printf ("RCU variable assignment failed\n" ); + goto error; + } + + writer_done =0 ; +__atomic_store_n (&gwrite_cycles,0 , __ATOMIC_RELAXED); +__atomic_store_n (&gwrites,0 , __ATOMIC_RELAXED); + +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =2 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_reader,NULL , + enabled_core_ids[i]); + +/* Launch writer threads */ +for (i =0 ; i <2 ; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_writer, + (void *)(uintptr_t )i, + enabled_core_ids[i]); + +/* Wait for writer threads */ +for (i =0 ; i <2 ; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +printf ("Total LPM Adds: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %" PRIu64" cycles\n" , +__atomic_load_n (&gwrite_cycles, __ATOMIC_RELAXED) / +__atomic_load_n (&gwrites, __ATOMIC_RELAXED) + ); + +/* Wait and check return value from reader threads */ + writer_done =1 ; +for (i =2 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +rte_lpm_free (lpm); +rte_free (rv); + lpm =NULL ; + rv =NULL ; + +/* Test without RCU integration */ +printf ("\nPerf test: 2 writers, %d readers, RCU integration disabled\n" , + num_cores -2 ); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + + writer_done =0 ; +__atomic_store_n (&gwrite_cycles,0 , __ATOMIC_RELAXED); +__atomic_store_n (&gwrites,0 , __ATOMIC_RELAXED); +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =2 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_reader,NULL , + enabled_core_ids[i]); + +/* Launch writer threads */ +for (i =0 ; i <2 ; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_writer, + (void *)(uintptr_t )i, + enabled_core_ids[i]); + +/* Wait for writer threads */ +for (i =0 ; i <2 ; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +printf ("Total LPM Adds: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %" PRIu64" cycles\n" , +__atomic_load_n (&gwrite_cycles, __ATOMIC_RELAXED) / +__atomic_load_n (&gwrites, __ATOMIC_RELAXED) + ); + + writer_done =1 ; +/* Wait and check return value from reader threads */ +for (i =2 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +rte_lpm_free (lpm); + +return 0 ; + +error: + writer_done =1 ; +/* Wait until all readers have exited */ +rte_eal_mp_wait_lcore (); + +rte_lpm_free (lpm); +rte_free (rv); + +return -1 ; +} + +/* +* Functional test: +* Single writer, rest are readers +*/ +static int +test_lpm_rcu_perf (void ) +{ +struct rte_lpm_config config; +uint64_t begin, total_cycles; +size_t sz; +unsigned int i, j; +uint16_t core_id; +uint32_t next_hop_add =0xAA ; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + +if (rte_lcore_count () <2 ) { +printf ("Not enough cores for lpm_rcu_perf_autotest, expecting at least 2\n" ); +return TEST_SKIPPED ; + } + + num_cores =0 ; +RTE_LCORE_FOREACH_SLAVE (core_id) { + enabled_core_ids[num_cores] = core_id; + num_cores++; + } + +printf ("\nPerf test: 1 writer, %d readers, RCU integration enabled\n" , + num_cores); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Init RCU variable */ + sz =rte_rcu_qsbr_get_memsize (num_cores); + rv = (struct rte_rcu_qsbr *)rte_zmalloc ("rcu0" , sz, +RTE_CACHE_LINE_SIZE ); +rte_rcu_qsbr_init (rv, num_cores); + + rcu_cfg.v = rv; +/* Assign the RCU variable to LPM */ +if (rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ) !=0 ) { +printf ("RCU variable assignment failed\n" ); + goto error; + } + + writer_done =0 ; +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =0 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_reader,NULL , + enabled_core_ids[i]); + +/* Measure add/delete. */ + begin =rte_rdtsc_precise (); +for (i =0 ; i <RCU_ITERATIONS ; i++) { +/* Add all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_add (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth, + next_hop_add) !=0 ) { +printf ("Failed to add iteration %d, route# %d\n" , + i, j); + goto error; + } + +/* Delete all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_delete (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth) !=0 ) { +printf ("Failed to delete iteration %d, route# %d\n" , + i, j); + goto error; + } + } + total_cycles =rte_rdtsc_precise () - begin; + +printf ("Total LPM Adds: %d\n" ,ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %g cycles\n" , + (double )total_cycles / (NUM_LDEPTH_ROUTE_ENTRIES *ITERATIONS )); + + writer_done =1 ; +/* Wait and check return value from reader threads */ +for (i =0 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +rte_lpm_free (lpm); +rte_free (rv); + lpm =NULL ; + rv =NULL ; + +/* Test without RCU integration */ +printf ("\nPerf test: 1 writer, %d readers, RCU integration disabled\n" , + num_cores); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + + writer_done =0 ; +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =0 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_reader,NULL , + enabled_core_ids[i]); + +/* Measure add/delete. */ + begin =rte_rdtsc_precise (); +for (i =0 ; i <RCU_ITERATIONS ; i++) { +/* Add all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_add (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth, + next_hop_add) !=0 ) { +printf ("Failed to add iteration %d, route# %d\n" , + i, j); + goto error; + } + +/* Delete all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_delete (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth) !=0 ) { +printf ("Failed to delete iteration %d, route# %d\n" , + i, j); + goto error; + } + } + total_cycles =rte_rdtsc_precise () - begin; + +printf ("Total LPM Adds: %d\n" ,ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %g cycles\n" , + (double )total_cycles / (NUM_LDEPTH_ROUTE_ENTRIES *ITERATIONS )); + + writer_done =1 ; +/* Wait and check return value from reader threads */ +for (i =0 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) +printf ("Warning: lcore %u not finished.\n" , + enabled_core_ids[i]); + +rte_lpm_free (lpm); + +return 0 ; + +error: + writer_done =1 ; +/* Wait until all readers have exited */ +rte_eal_mp_wait_lcore (); + +rte_lpm_free (lpm); +rte_free (rv); + +return -1 ; +} +static int test_lpm_perf (void ) { -struct rte_lpm *lpm =NULL ;struct rte_lpm_config config; config.max_rules =2000000 ;
app/test/test_lpm_perf.c test_lpm_perf(void) · line 346
Quoted 4 lines
app/test/test_lpm_perf.c +0
-1@@ -343,7 +825,7 @@ test_lpm_perf(void) lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config);TEST_LPM_ASSERT (lpm !=NULL ); -/* Measue add. */
unintentional typo?
Quoted 5 lines
app/test/test_lpm_perf.c +1
-0+/* Measure add. */ begin =rte_rdtsc ();for (i =0 ; i <NUM_ROUTE_ENTRIES ; i++) {
app/test/test_lpm_perf.c test_lpm_perf(void) · line 969
Quoted 10 lines
app/test/test_lpm_perf.c +4
-0@@ -478,6 +960,10 @@ test_lpm_perf(void)rte_lpm_delete_all (lpm);rte_lpm_free (lpm); +test_lpm_rcu_perf (); + +test_lpm_rcu_perf_multi_writer (); +return 0 ; }
Signature · 2 lines
Regards, Vladimir
Re: [dpdk-dev] [PATCH v7 3/3] test/lpm: add RCU integration performance tests
From: Medvedkin, Vladimir <[email protected]>
Sent: Wednesday, July 8, 2020 8:37 PM
To: Ruifeng Wang <[email protected]>; Bruce Richardson <[email protected]>
Cc: [email protected]; [email protected]; [email protected]; Honnappa Nagarahalli <[email protected]>; nd <[email protected]>
Subject: Re: [PATCH v7 3/3] test/lpm: add RCU integration performance tests
On 07/07/2020 16:15, Ruifeng Wang wrote:
From: Honnappa Nagarahalli <[email protected]><mailto:[email protected]>
Add performance tests for RCU integration. The performance
difference with and without RCU integration is very small
(~1% to ~2%) on both Arm and x86 platforms.
---
app/test/test_lpm_perf.c | 492 ++++++++++++++++++++++++++++++++++++++-
1 file changed, 489 insertions(+), 3 deletions(-)
app/test/test_lpm_perf.c +0 -0
index 489719c40..dfe186426 100644
--- a/app/test/test_lpm_perf.c
+++ b/app/test/test_lpm_perf.c
@@ -1,5 +1,6 @@
/* SPDX-License-Identifier: BSD-3-Clause
* Copyright(c) 2010-2014 Intel Corporation
+ * Copyright(c) 2020 Arm Limited
*/
#include <stdio.h>
@@ -10,12 +11,27 @@
#include <rte_cycles.h>
#include <rte_random.h>
#include <rte_branch_prediction.h>
+#include <rte_malloc.h>
#include <rte_ip.h>
#include <rte_lpm.h>
#include "test.h"
#include "test_xmmt_ops.h"
+struct rte_lpm *lpm;
+static struct rte_rcu_qsbr *rv;
+static volatile uint8_t writer_done;
+static volatile uint32_t thr_id;
+static uint64_t gwrite_cycles;
+static uint64_t gwrites;
+/* LPM APIs are not thread safe, use mutex to provide thread safety */
+static pthread_mutex_t lpm_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+/* Report quiescent state interval every 1024 lookups. Larger critical
+ * sections in reader will result in writer polling multiple times.
+ */
+#define QSBR_REPORTING_INTERVAL 1024
+
#define TEST_LPM_ASSERT(cond) do { \
if (!(cond)) { \
printf("Error at line %d: \n", __LINE__); \@@ -24,6 +40,7 @@
} while(0)
#define ITERATIONS (1 << 10)
+#define RCU_ITERATIONS 10
#define BATCH_SIZE (1 << 12)
#define BULK_SIZE 32
@@ -35,9 +52,13 @@ struct route_rule {
};
static struct route_rule large_route_table[MAX_RULE_NUM];
+/* Route table for routes with depth > 24 */
+struct route_rule large_ldepth_route_table[MAX_RULE_NUM];
static uint32_t num_route_entries;
+static uint32_t num_ldepth_route_entries;
#define NUM_ROUTE_ENTRIES num_route_entries
+#define NUM_LDEPTH_ROUTE_ENTRIES num_ldepth_route_entries
enum {
IP_CLASS_A,
@@ -191,7 +212,7 @@ static void generate_random_rule_prefix(uint32_t ip_class, uint8_t depth)
uint32_t ip_head_mask;
uint32_t rule_num;
uint32_t k;- struct route_rule *ptr_rule;
+ struct route_rule *ptr_rule, *ptr_ldepth_rule;
if (ip_class == IP_CLASS_A) { /* IP Address class A */
fixed_bit_num = IP_HEAD_BIT_NUM_A;@@ -236,10 +257,20 @@ static void generate_random_rule_prefix(uint32_t ip_class, uint8_t depth)
*/
start = lrand48() & mask;
ptr_rule = &large_route_table[num_route_entries];+ ptr_ldepth_rule = &large_ldepth_route_table[num_ldepth_route_entries];
for (k = 0; k < rule_num; k++) {
ptr_rule->ip = (start << (RTE_LPM_MAX_DEPTH - depth))
| ip_head_mask;
ptr_rule->depth = depth;+ /* If the depth of the route is more than 24, store it
+ * in another table as well.
+ */
+ if (depth > 24) {
+ ptr_ldepth_rule->ip = ptr_rule->ip;
+ ptr_ldepth_rule->depth = ptr_rule->depth;
+ ptr_ldepth_rule++;
+ num_ldepth_route_entries++;
+ }
ptr_rule++;
start = (start + step) & mask;
}@@ -273,6 +304,7 @@ static void generate_large_route_rule_table(void)
uint8_t depth;
num_route_entries = 0;+ num_ldepth_route_entries = 0;
memset(large_route_table, 0, sizeof(large_route_table));
for (ip_class = IP_CLASS_A; ip_class <= IP_CLASS_C; ip_class++) {@@ -316,10 +348,460 @@ print_route_distribution(const struct route_rule *table, uint32_t n)
printf("\n");}
+/* Check condition and return an error if true. */
+static uint16_t enabled_core_ids[RTE_MAX_LCORE];
+static unsigned int num_cores;
+
+/* Simple way to allocate thread ids in 0 to RTE_MAX_LCORE space */
+static inline uint32_t
+alloc_thread_id(void)
+{
+ uint32_t tmp_thr_id;
+
+ tmp_thr_id = __atomic_fetch_add(&thr_id, 1, __ATOMIC_RELAXED);
+ if (tmp_thr_id >= RTE_MAX_LCORE)
+ printf("Invalid thread id %u\n", tmp_thr_id);
+
+ return tmp_thr_id;
+}
+
+/*
+ * Reader thread using rte_lpm data structure without RCU.
+ */
+static int
+test_lpm_reader(void *arg)
+{
+ int i;
+ uint32_t ip_batch[QSBR_REPORTING_INTERVAL];
+ uint32_t next_hop_return = 0;
+
+ RTE_SET_USED(arg);
+ do {
+ for (i = 0; i < QSBR_REPORTING_INTERVAL; i++)
+ ip_batch[i] = rte_rand();
+
+ for (i = 0; i < QSBR_REPORTING_INTERVAL; i++)
+ rte_lpm_lookup(lpm, ip_batch[i], &next_hop_return);
+
+ } while (!writer_done);
+
+ return 0;
+}
+
+/*
+ * Reader thread using rte_lpm data structure with RCU.
+ */
+static int
+test_lpm_rcu_qsbr_reader(void *arg)
+{
+ int i;
+ uint32_t thread_id = alloc_thread_id();
+ uint32_t ip_batch[QSBR_REPORTING_INTERVAL];
+ uint32_t next_hop_return = 0;
+
+ RTE_SET_USED(arg);
+ /* Register this thread to report quiescent state */
+ rte_rcu_qsbr_thread_register(rv, thread_id);
+ rte_rcu_qsbr_thread_online(rv, thread_id);
+
+ do {
+ for (i = 0; i < QSBR_REPORTING_INTERVAL; i++)
+ ip_batch[i] = rte_rand();
+
+ for (i = 0; i < QSBR_REPORTING_INTERVAL; i++)
+ rte_lpm_lookup(lpm, ip_batch[i], &next_hop_return);
+
+ /* Update quiescent state */
+ rte_rcu_qsbr_quiescent(rv, thread_id);
+ } while (!writer_done);
+
+ rte_rcu_qsbr_thread_offline(rv, thread_id);
+ rte_rcu_qsbr_thread_unregister(rv, thread_id);
+
+ return 0;
+}
+
+/*
+ * Writer thread using rte_lpm data structure with RCU.
+ */
+static int
+test_lpm_rcu_qsbr_writer(void *arg)
+{
+ unsigned int i, j, si, ei;
+ uint64_t begin, total_cycles;
+ uint8_t core_id = (uint8_t)((uintptr_t)arg);
+ uint32_t next_hop_add = 0xAA;
+
+ RTE_SET_USED(arg);
+ /* 2 writer threads are used */
+ if (core_id % 2 == 0) {
+ si = 0;
+ ei = NUM_LDEPTH_ROUTE_ENTRIES / 2;
+ } else {
+ si = NUM_LDEPTH_ROUTE_ENTRIES / 2;
+ ei = NUM_LDEPTH_ROUTE_ENTRIES;
+ }
+
+ /* Measure add/delete. */
+ begin = rte_rdtsc_precise();
+ for (i = 0; i < RCU_ITERATIONS; i++) {
+ /* Add all the entries */
+ for (j = si; j < ei; j++) {
+ pthread_mutex_lock(&lpm_mutex);
+ if (rte_lpm_add(lpm, large_ldepth_route_table[j].ip,
+ large_ldepth_route_table[j].depth,
+ next_hop_add) != 0) {
+ printf("Failed to add iteration %d, route# %d\n",
+ i, j);
+ }
+ pthread_mutex_unlock(&lpm_mutex);
+ }
+
+ /* Delete all the entries */
+ for (j = si; j < ei; j++) {
+ pthread_mutex_lock(&lpm_mutex);
+ if (rte_lpm_delete(lpm, large_ldepth_route_table[j].ip,
+ large_ldepth_route_table[j].depth) != 0) {
+ printf("Failed to delete iteration %d, route# %d\n",
+ i, j);
+ }
+ pthread_mutex_unlock(&lpm_mutex);
+ }
+ }
+
+ total_cycles = rte_rdtsc_precise() - begin;
+
+ __atomic_fetch_add(&gwrite_cycles, total_cycles, __ATOMIC_RELAXED);
+ __atomic_fetch_add(&gwrites,
+ 2 * NUM_LDEPTH_ROUTE_ENTRIES * RCU_ITERATIONS,
+ __ATOMIC_RELAXED);
+
+ return 0;
+}
+
+/*
+ * Functional test:
+ * 2 writers, rest are readers
+ */
+static int
+test_lpm_rcu_perf_multi_writer(void)
+{
+ struct rte_lpm_config config;
+ size_t sz;
+ unsigned int i;
+ uint16_t core_id;
+ struct rte_lpm_rcu_config rcu_cfg = {0};
+
+ if (rte_lcore_count() < 3) {
+ printf("Not enough cores for lpm_rcu_perf_autotest, expecting at least 3\n");
+ return TEST_SKIPPED;
+ }
+
+ num_cores = 0;
+ RTE_LCORE_FOREACH_SLAVE(core_id) {
+ enabled_core_ids[num_cores] = core_id;
+ num_cores++;
+ }
+
+ printf("\nPerf test: 2 writers, %d readers, RCU integration enabled\n",
+ num_cores - 2);
+
+ /* Create LPM table */
+ config.max_rules = NUM_LDEPTH_ROUTE_ENTRIES;
+ config.number_tbl8s = NUM_LDEPTH_ROUTE_ENTRIES;
+ config.flags = 0;
+ lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
+ TEST_LPM_ASSERT(lpm != NULL);
+
+ /* Init RCU variable */
+ sz = rte_rcu_qsbr_get_memsize(num_cores);
+ rv = (struct rte_rcu_qsbr *)rte_zmalloc("rcu0", sz,
+ RTE_CACHE_LINE_SIZE);
+ rte_rcu_qsbr_init(rv, num_cores);
+
+ rcu_cfg.v = rv;
+ /* Assign the RCU variable to LPM */
+ if (rte_lpm_rcu_qsbr_add(lpm, &rcu_cfg, NULL) != 0) {
+ printf("RCU variable assignment failed\n");
+ goto error;
+ }
+
+ writer_done = 0;
+ __atomic_store_n(&gwrite_cycles, 0, __ATOMIC_RELAXED);
+ __atomic_store_n(&gwrites, 0, __ATOMIC_RELAXED);
+
+ __atomic_store_n(&thr_id, 0, __ATOMIC_SEQ_CST);
+
+ /* Launch reader threads */
+ for (i = 2; i < num_cores; i++)
+ rte_eal_remote_launch(test_lpm_rcu_qsbr_reader, NULL,
+ enabled_core_ids[i]);
+
+ /* Launch writer threads */
+ for (i = 0; i < 2; i++)
+ rte_eal_remote_launch(test_lpm_rcu_qsbr_writer,
+ (void *)(uintptr_t)i,
+ enabled_core_ids[i]);
+
+ /* Wait for writer threads */
+ for (i = 0; i < 2; i++)
+ if (rte_eal_wait_lcore(enabled_core_ids[i]) < 0)
+ goto error;
+
+ printf("Total LPM Adds: %d\n",
+ 2 * ITERATIONS * NUM_LDEPTH_ROUTE_ENTRIES);
+ printf("Total LPM Deletes: %d\n",
+ 2 * ITERATIONS * NUM_LDEPTH_ROUTE_ENTRIES);
+ printf("Average LPM Add/Del: %"PRIu64" cycles\n",
+ __atomic_load_n(&gwrite_cycles, __ATOMIC_RELAXED) /
+ __atomic_load_n(&gwrites, __ATOMIC_RELAXED)
+ );
+
+ /* Wait and check return value from reader threads */
+ writer_done = 1;
+ for (i = 2; i < num_cores; i++)
+ if (rte_eal_wait_lcore(enabled_core_ids[i]) < 0)
+ goto error;
+
+ rte_lpm_free(lpm);
+ rte_free(rv);
+ lpm = NULL;
+ rv = NULL;
+
+ /* Test without RCU integration */
+ printf("\nPerf test: 2 writers, %d readers, RCU integration disabled\n",
+ num_cores - 2);
+
+ /* Create LPM table */
+ config.max_rules = NUM_LDEPTH_ROUTE_ENTRIES;
+ config.number_tbl8s = NUM_LDEPTH_ROUTE_ENTRIES;
+ config.flags = 0;
+ lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
+ TEST_LPM_ASSERT(lpm != NULL);
+
+ writer_done = 0;
+ __atomic_store_n(&gwrite_cycles, 0, __ATOMIC_RELAXED);
+ __atomic_store_n(&gwrites, 0, __ATOMIC_RELAXED);
+ __atomic_store_n(&thr_id, 0, __ATOMIC_SEQ_CST);
+
+ /* Launch reader threads */
+ for (i = 2; i < num_cores; i++)
+ rte_eal_remote_launch(test_lpm_reader, NULL,
+ enabled_core_ids[i]);
+
+ /* Launch writer threads */
+ for (i = 0; i < 2; i++)
+ rte_eal_remote_launch(test_lpm_rcu_qsbr_writer,
+ (void *)(uintptr_t)i,
+ enabled_core_ids[i]);
+
+ /* Wait for writer threads */
+ for (i = 0; i < 2; i++)
+ if (rte_eal_wait_lcore(enabled_core_ids[i]) < 0)
+ goto error;
+
+ printf("Total LPM Adds: %d\n",
+ 2 * ITERATIONS * NUM_LDEPTH_ROUTE_ENTRIES);
+ printf("Total LPM Deletes: %d\n",
+ 2 * ITERATIONS * NUM_LDEPTH_ROUTE_ENTRIES);
+ printf("Average LPM Add/Del: %"PRIu64" cycles\n",
+ __atomic_load_n(&gwrite_cycles, __ATOMIC_RELAXED) /
+ __atomic_load_n(&gwrites, __ATOMIC_RELAXED)
+ );
+
+ writer_done = 1;
+ /* Wait and check return value from reader threads */
+ for (i = 2; i < num_cores; i++)
+ if (rte_eal_wait_lcore(enabled_core_ids[i]) < 0)
+ goto error;
+
+ rte_lpm_free(lpm);
+
+ return 0;
+
+error:
+ writer_done = 1;
+ /* Wait until all readers have exited */
+ rte_eal_mp_wait_lcore();
+
+ rte_lpm_free(lpm);
+ rte_free(rv);
+
+ return -1;
+}
+
+/*
+ * Functional test:
+ * Single writer, rest are readers
+ */
+static int
+test_lpm_rcu_perf(void)
+{
+ struct rte_lpm_config config;
+ uint64_t begin, total_cycles;
+ size_t sz;
+ unsigned int i, j;
+ uint16_t core_id;
+ uint32_t next_hop_add = 0xAA;
+ struct rte_lpm_rcu_config rcu_cfg = {0};
+
+ if (rte_lcore_count() < 2) {
+ printf("Not enough cores for lpm_rcu_perf_autotest, expecting at least 2\n");
+ return TEST_SKIPPED;
+ }
+
+ num_cores = 0;
+ RTE_LCORE_FOREACH_SLAVE(core_id) {
+ enabled_core_ids[num_cores] = core_id;
+ num_cores++;
+ }
+
+ printf("\nPerf test: 1 writer, %d readers, RCU integration enabled\n",
+ num_cores);
+
+ /* Create LPM table */
+ config.max_rules = NUM_LDEPTH_ROUTE_ENTRIES;
+ config.number_tbl8s = NUM_LDEPTH_ROUTE_ENTRIES;
+ config.flags = 0;
+ lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
+ TEST_LPM_ASSERT(lpm != NULL);
+
+ /* Init RCU variable */
+ sz = rte_rcu_qsbr_get_memsize(num_cores);
+ rv = (struct rte_rcu_qsbr *)rte_zmalloc("rcu0", sz,
+ RTE_CACHE_LINE_SIZE);
+ rte_rcu_qsbr_init(rv, num_cores);
+
+ rcu_cfg.v = rv;
+ /* Assign the RCU variable to LPM */
+ if (rte_lpm_rcu_qsbr_add(lpm, &rcu_cfg, NULL) != 0) {
+ printf("RCU variable assignment failed\n");
+ goto error;
+ }
+
+ writer_done = 0;
+ __atomic_store_n(&thr_id, 0, __ATOMIC_SEQ_CST);
+
+ /* Launch reader threads */
+ for (i = 0; i < num_cores; i++)
+ rte_eal_remote_launch(test_lpm_rcu_qsbr_reader, NULL,
+ enabled_core_ids[i]);
+
+ /* Measure add/delete. */
+ begin = rte_rdtsc_precise();
+ for (i = 0; i < RCU_ITERATIONS; i++) {
+ /* Add all the entries */
+ for (j = 0; j < NUM_LDEPTH_ROUTE_ENTRIES; j++)
+ if (rte_lpm_add(lpm, large_ldepth_route_table[j].ip,
+ large_ldepth_route_table[j].depth,
+ next_hop_add) != 0) {
+ printf("Failed to add iteration %d, route# %d\n",
+ i, j);
+ goto error;
+ }
+
+ /* Delete all the entries */
+ for (j = 0; j < NUM_LDEPTH_ROUTE_ENTRIES; j++)
+ if (rte_lpm_delete(lpm, large_ldepth_route_table[j].ip,
+ large_ldepth_route_table[j].depth) != 0) {
+ printf("Failed to delete iteration %d, route# %d\n",
+ i, j);
+ goto error;
+ }
+ }
+ total_cycles = rte_rdtsc_precise() - begin;
+
+ printf("Total LPM Adds: %d\n", ITERATIONS * NUM_LDEPTH_ROUTE_ENTRIES);
+ printf("Total LPM Deletes: %d\n",
+ ITERATIONS * NUM_LDEPTH_ROUTE_ENTRIES);
+ printf("Average LPM Add/Del: %g cycles\n",
+ (double)total_cycles / (NUM_LDEPTH_ROUTE_ENTRIES * ITERATIONS));
+
+ writer_done = 1;
+ /* Wait and check return value from reader threads */
+ for (i = 0; i < num_cores; i++)
+ if (rte_eal_wait_lcore(enabled_core_ids[i]) < 0)
+ goto error;
+
+ rte_lpm_free(lpm);
+ rte_free(rv);
+ lpm = NULL;
+ rv = NULL;
+
+ /* Test without RCU integration */
+ printf("\nPerf test: 1 writer, %d readers, RCU integration disabled\n",
+ num_cores);
+
+ /* Create LPM table */
+ config.max_rules = NUM_LDEPTH_ROUTE_ENTRIES;
+ config.number_tbl8s = NUM_LDEPTH_ROUTE_ENTRIES;
+ config.flags = 0;
+ lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
+ TEST_LPM_ASSERT(lpm != NULL);
+
+ writer_done = 0;
+ __atomic_store_n(&thr_id, 0, __ATOMIC_SEQ_CST);
+
+ /* Launch reader threads */
+ for (i = 0; i < num_cores; i++)
+ rte_eal_remote_launch(test_lpm_reader, NULL,
+ enabled_core_ids[i]);
+
+ /* Measure add/delete. */
+ begin = rte_rdtsc_precise();
+ for (i = 0; i < RCU_ITERATIONS; i++) {
+ /* Add all the entries */
+ for (j = 0; j < NUM_LDEPTH_ROUTE_ENTRIES; j++)
+ if (rte_lpm_add(lpm, large_ldepth_route_table[j].ip,
+ large_ldepth_route_table[j].depth,
+ next_hop_add) != 0) {
+ printf("Failed to add iteration %d, route# %d\n",
+ i, j);
+ goto error;
+ }
+
+ /* Delete all the entries */
+ for (j = 0; j < NUM_LDEPTH_ROUTE_ENTRIES; j++)
+ if (rte_lpm_delete(lpm, large_ldepth_route_table[j].ip,
+ large_ldepth_route_table[j].depth) != 0) {
+ printf("Failed to delete iteration %d, route# %d\n",
+ i, j);
+ goto error;
+ }
+ }
+ total_cycles = rte_rdtsc_precise() - begin;
+
+ printf("Total LPM Adds: %d\n", ITERATIONS * NUM_LDEPTH_ROUTE_ENTRIES);
+ printf("Total LPM Deletes: %d\n",
+ ITERATIONS * NUM_LDEPTH_ROUTE_ENTRIES);
+ printf("Average LPM Add/Del: %g cycles\n",
+ (double)total_cycles / (NUM_LDEPTH_ROUTE_ENTRIES * ITERATIONS));
+
+ writer_done = 1;
+ /* Wait and check return value from reader threads */
+ for (i = 0; i < num_cores; i++)
+ if (rte_eal_wait_lcore(enabled_core_ids[i]) < 0)
+ printf("Warning: lcore %u not finished.\n",
+ enabled_core_ids[i]);
+
+ rte_lpm_free(lpm);
+
+ return 0;
+
+error:
+ writer_done = 1;
+ /* Wait until all readers have exited */
+ rte_eal_mp_wait_lcore();
+
+ rte_lpm_free(lpm);
+ rte_free(rv);
+
+ return -1;
+}
+
static int
test_lpm_perf(void)
{
- struct rte_lpm *lpm = NULL;
struct rte_lpm_config config;
config.max_rules = 2000000;@@ -343,7 +825,7 @@ test_lpm_perf(void)
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);- /* Measue add. */
unintentional typo?
[Ruifeng] Yes, this is a typo fix. I assume it is OK not to be split out.
+ /* Measure add. */
begin = rte_rdtsc();
for (i = 0; i < NUM_ROUTE_ENTRIES; i++) {@@ -478,6 +960,10 @@ test_lpm_perf(void)
rte_lpm_delete_all(lpm);
rte_lpm_free(lpm);+ test_lpm_rcu_perf();
+
+ test_lpm_rcu_perf_multi_writer();
+
return 0;
}
--
Regards,
Vladimir
v8 cover RCU integration with LPM library
In reply to Ruifeng WangThis patchset integrates RCU QSBR support with LPM library.
Resource reclaimation implementation was splitted from the original series, and has already been part of RCU library. Rework the series to base LPM integration on RCU reclaimation APIs.
New API rte_lpm_rcu_qsbr_add is introduced for application to register a RCU variable that LPM library will use. This provides user the handle to enable RCU that integrated in LPM library.
Functional tests and performance tests are added to cover the integration with RCU.
---
v8:
Fixed ABI issue by adding internal LPM control structure. (David) Changed to use RFC5737 address in unit test. (Vladimir)
v7:
Fixed typos in document.
v6:
Remove ALLOW_EXPERIMENTAL_API from rte_lpm.c.
v5:
No default value for reclaim_thd. This allows reclamation triggering with every call. Pass LPM pointer instead of tbl8 as argument of reclaim callback free function. Updated group_idx check at tbl8 allocation.
Use enums instead of defines for different reclamation modes.
RCU QSBR integrated path is inside ALLOW_EXPERIMENTAL_API to avoid ABI change.
v4:
Allow user to configure defer queue: size, reclaim threshold, max entries. Return defer queue handler so user can manually trigger reclaimation. Add blocking mode support. Defer queue will not be created.
Honnappa Nagarahalli (1):
test/lpm: add RCU integration performance tests
Ruifeng Wang (2):
lib/lpm: integrate RCU QSBR
test/lpm: add LPM RCU integration functional tests
app/test/test_lpm.c | 291 ++++++++++++++++- app/test/test_lpm_perf.c | 492 ++++++++++++++++++++++++++++- doc/guides/prog_guide/lpm_lib.rst | 32 ++ lib/librte_lpm/Makefile | 2 +- lib/librte_lpm/meson.build | 1 + lib/librte_lpm/rte_lpm.c | 167 ++++++++-- lib/librte_lpm/rte_lpm.h | 53 ++++ lib/librte_lpm/rte_lpm_version.map | 6 + 8 files changed, 1016 insertions(+), 28 deletions(-)
Signature · 1 line
2.17.1
PATCH v8 1/3 lib/lpm: integrate RCU QSBR
Currently, the tbl8 group is freed even though the readers might be using the tbl8 group entries. The freed tbl8 group can be reallocated quickly. This results in incorrect lookup results.
RCU QSBR process is integrated for safe tbl8 group reclaim. Refer to RCU documentation to understand various aspects of integrating RCU library into other libraries.
To avoid ABI breakage, a struct __rte_lpm is created for lpm library internal use. This struct warps rte_lpm that has been exposed and also includes members that don't need to be exposed such as RCU related config.
--- doc/guides/prog_guide/lpm_lib.rst | 32 ++++++ lib/librte_lpm/Makefile | 2 +- lib/librte_lpm/meson.build | 1 + lib/librte_lpm/rte_lpm.c | 167 +++++++++++++++++++++++++---- lib/librte_lpm/rte_lpm.h | 53 +++++++++ lib/librte_lpm/rte_lpm_version.map | 6 ++ 6 files changed, 237 insertions(+), 24 deletions(-)
doc/guides/prog_guide/lpm_lib.rst +32 -0
@@ -145,6 +145,38 @@ depending on whether we need to move to the next table or not. Prefix expansion is one of the keys of this algorithm, since it improves the speed dramatically by adding redundancy. +Deletion +~~~~~~~~ + +When deleting a rule, a replacement rule is searched for. Replacement rule is an existing rule that has +the longest prefix match with the rule to be deleted, but has shorter prefix. + +If a replacement rule is found, target tbl24 and tbl8 entries are updated to have the same depth and next hop +value with the replacement rule. + +If no replacement rule can be found, target tbl24 and tbl8 entries will be cleared. + +Prefix expansion is performed if the rule's depth is not exactly 24 bits or 32 bits. + +After deleting a rule, a group of tbl8s that belongs to the same tbl24 entry are freed in following cases: + +* All tbl8s in the group are empty . + +* All tbl8s in the group have the same values and with depth no greater than 24. + +Free of tbl8s have different behaviors: + +* If RCU is not used, tbl8s are cleared and reclaimed immediately. + +* If RCU is used, tbl8s are reclaimed when readers are in quiescent state. + +When the LPM is not using RCU, tbl8 group can be freed immediately even though the readers might be using +the tbl8 group entries. This might result in incorrect lookup results. + +RCU QSBR process is integrated for safe tbl8 group reclamation. Application has certain responsibilities +while using this feature. Please refer to resource reclamation framework of :ref:`RCU library <RCU_Library>` +for more details. + Lookup ~~~~~~
lib/librte_lpm/Makefile +1 -1
@@ -8,7 +8,7 @@ LIB = librte_lpm.a CFLAGS += -O3 CFLAGS += $(WERROR_FLAGS) -I$(SRCDIR) -LDLIBS += -lrte_eal -lrte_hash +LDLIBS += -lrte_eal -lrte_hash -lrte_rcu EXPORT_MAP := rte_lpm_version.map
lib/librte_lpm/meson.build +1 -0
@@ -7,3 +7,4 @@ headers = files('rte_lpm.h', 'rte_lpm6.h') # without worrying about which architecture we actually need headers += files('rte_lpm_altivec.h', 'rte_lpm_neon.h', 'rte_lpm_sse.h') deps += ['hash'] +deps += ['rcu']
lib/librte_lpm/rte_lpm.c +144 -23
283 lines not on this page · raw message
lib/librte_lpm/rte_lpm.h +53 -0
82 lines not on this page · raw message
lib/librte_lpm/rte_lpm_version.map +6 -0
@@ -21,3 +21,9 @@ DPDK_20.0 { local: *; }; + +EXPERIMENTAL { + global: + + rte_lpm_rcu_qsbr_add; +};
Signature · 1 line
2.17.1
Re: [dpdk-dev] [PATCH v8 1/3] lib/lpm: integrate RCU QSBR
Hello Ruifeng,
Quoted 30 lines · Ruifeng Wang
lib/librte_lpm/rte_lpm.c +12
-0@@ -1,5 +1,6 @@/* SPDX-License-Identifier: BSD-3-Clause * Copyright(c) 2010-2014 Intel Corporation +* Copyright(c) 2020 Arm Limited */ #include <string.h> @@ -39,6 +40,17 @@ enum valid_flag { VALID }; +/** @internal LPM structure. */ +struct __rte_lpm { +/* LPM metadata. */ +struct rte_lpm lpm; + +/* RCU config. */ +struct rte_rcu_qsbr *v;/* RCU QSBR variable. */ +enum rte_lpm_qsbr_mode rcu_mode;/* Blocking, defer queue. */ +struct rte_rcu_qsbr_dq *dq;/* RCU QSBR defer queue. */ +}; +/* Macro to enable/disable run-time checks. */ #if defined(RTE_LIBRTE_LPM_DEBUG )#include <rte_debug.h>
lib/librte_lpm/rte_lpm.c rte_lpm_create(const char *name, int socket_id, · line 137
Quoted 4 lines
lib/librte_lpm/rte_lpm.c +1
-0@@ -122,6 +134,7 @@ rte_lpm_create(const char *name, int socket_id, const struct rte_lpm_config *config) {char mem_name[RTE_LPM_NAMESIZE ]; +struct __rte_lpm *internal_lpm =NULL ;
Nit: internal_lpm does not need to be initialised to NULL.
Quoted 35 lines
lib/librte_lpm/rte_lpm.c +7
-7struct rte_lpm *lpm =NULL ;struct rte_tailq_entry *te;uint32_t mem_size, rules_size, tbl8s_size;@@ -140,12 +153,6 @@ rte_lpm_create(const char *name, int socket_id,snprintf (mem_name,sizeof (mem_name),"LPM_%s" , name); -/* Determine the amount of memory to allocate. */ - mem_size =sizeof (*lpm); - rules_size =sizeof (struct rte_lpm_rule ) * config->max_rules; - tbl8s_size = (sizeof (struct rte_lpm_tbl_entry ) * -RTE_LPM_TBL8_GROUP_NUM_ENTRIES * config->number_tbl8s); -rte_mcfg_tailq_write_lock ();/* guarantee there's no existing */ @@ -161,6 +168,12 @@ rte_lpm_create(const char *name, int socket_id, goto exit; } +/* Determine the amount of memory to allocate. */ + mem_size =sizeof (*internal_lpm); + rules_size =sizeof (struct rte_lpm_rule ) * config->max_rules; + tbl8s_size = (sizeof (struct rte_lpm_tbl_entry ) * +RTE_LPM_TBL8_GROUP_NUM_ENTRIES * config->number_tbl8s); +/* allocate tailq entry */ te =rte_zmalloc ("LPM_TAILQ_ENTRY" ,sizeof (*te),0 );if (te ==NULL ) {@@ -170,22 +183,23 @@ rte_lpm_create(const char *name, int socket_id, }/* Allocate memory to store the LPM data structures. */ - lpm = rte_zmalloc_socket(mem_name, mem_size, + internal_lpm = rte_zmalloc_socket(mem_name, mem_size,
lib/librte_lpm/rte_lpm.c rte_lpm_create(const char *name, int socket_id, · line 195
Quoted 10 lines
lib/librte_lpm/rte_lpm.c +2
-1RTE_CACHE_LINE_SIZE, socket_id); -if (lpm ==NULL ) { +if (internal_lpm ==NULL ) {RTE_LOG (ERR ,LPM ,"LPM memory allocation failed\n" );rte_free (te); rte_errno =ENOMEM ; goto exit; } + lpm = &internal_lpm->lpm;
From this point...
lib/librte_lpm/rte_lpm.c rte_lpm_create(const char *name, int socket_id, · line 202
Quoted 9 lines
lib/librte_lpm/rte_lpm.c +2
-2lpm->rules_tbl =rte_zmalloc_socket (NULL , (size_t )rules_size,RTE_CACHE_LINE_SIZE , socket_id);if (lpm->rules_tbl ==NULL ) {RTE_LOG (ERR ,LPM ,"LPM rules_tbl memory allocation failed\n" ); -rte_free (lpm); - lpm =NULL ; +rte_free (internal_lpm); + internal_lpm =NULL ;
... lpm is set to &internal_lpm->lpm and will be returned by jumping to the exit label.
So freeing internal_lpm is necessary, but the lpm variable must be set to NULL too.
lib/librte_lpm/rte_lpm.c rte_lpm_create(const char *name, int socket_id, · line 215
Quoted 11 lines
lib/librte_lpm/rte_lpm.c +2
-2rte_free (te); rte_errno =ENOMEM ; goto exit;@@ -197,8 +211,8 @@ rte_lpm_create(const char *name, int socket_id,if (lpm->tbl8 ==NULL ) {RTE_LOG (ERR ,LPM ,"LPM tbl8 memory allocation failed\n" );rte_free (lpm->rules_tbl); -rte_free (lpm); - lpm =NULL ; +rte_free (internal_lpm); + internal_lpm =NULL ;
Ditto.
Quoted 3 lines
lib/librte_lpm/rte_lpm.c +0
-0rte_free (te); rte_errno =ENOMEM ; goto exit;
Signature · 1 line
David Marchand
Re: [dpdk-dev] [PATCH v8 1/3] lib/lpm: integrate RCU QSBR
Quoted 14 lines
-----Original Message-----
From: David Marchand <[email protected]>
Sent: Thursday, July 9, 2020 7:50 PM
To: Ruifeng Wang <[email protected]>
Cc: Bruce Richardson <[email protected]>; Vladimir Medvedkin <[email protected]>; John McNamara <[email protected]>; Marko Kovacevic <[email protected]>; Ray Kinsella <[email protected]>; Neil Horman <[email protected]>; dev <[email protected]>; Ananyev, Konstantin <[email protected]>; Honnappa Nagarahalli <[email protected]>; nd <[email protected]>
Subject: Re: [dpdk-dev] [PATCH v8 1/3] lib/lpm: integrate RCU QSBR
Quoted 2 lines
Hello Ruifeng,
Hi David,
Thanks for your review and suggestions.
Quoted 31 lines
Quoted 27 lines · Ruifeng Wang
lib/librte_lpm/rte_lpm.c index renamed from lib/librte_lpm/rte_lpm.c +0
-0
38ab512a4..4fbf5b6df100644lib/librte_lpm/rte_lpm.c +12
-0@@ -1,5 +1,6 @@/* SPDX-License-Identifier: BSD-3-Clause * Copyright(c) 2010-2014 Intel Corporation +* Copyright(c) 2020 Arm Limited */ #include <string.h> @@ -39,6 +40,17 @@ enum valid_flag {VALID }; +/** @internal LPM structure. */ +struct __rte_lpm { +/* LPM metadata. */ +struct rte_lpm lpm; + +/* RCU config. */ +struct rte_rcu_qsbr *v;/* RCU QSBR variable. */ +enum rte_lpm_qsbr_mode rcu_mode;/* Blocking, defer queue. */ +struct rte_rcu_qsbr_dq *dq;/* RCU QSBR defer queue. */ +}; + /* Macro to enable/disable run-time checks. */ #ifQuoted 1 line
defined(RTE_LIBRTE_LPM_DEBUG)#include <rte_debug.h> @@ -122,6+134,7
Quoted 7 lines
Quoted 4 lines
@@ rte_lpm_create(const char *name, int
socket_id,const struct rte_lpm_config *config) { char mem_name[RTE_LPM_NAMESIZE];+ struct
__rte_lpm*internal_lpm= NULL;Nit:
internal_lpmdoes not need to be initialised to NULL.
Agreed.
Quoted 62 lines
Quoted 38 lines
struct rte_lpm *lpm = NULL; struct rte_tailq_entry *te; uint32_t mem_size, rules_size, tbl8s_size; @@ -140,12 +153,6@@ rte_lpm_create(const char *name, int
socket_id,snprintf(mem_name, sizeof(mem_name), "LPM_%s", name);lib/librte_lpm/rte_lpm.c +0
-5-/* Determine the amount of memory to allocate. */ - mem_size =sizeof (*lpm); - rules_size =sizeof (struct rte_lpm_rule ) * config->max_rules; - tbl8s_size = (sizeof(struct rte_lpm_tbl_entry) * - RTE_LPM_TBL8_GROUP_NUM_ENTRIES * config-
number_tbl8s);
-rte_mcfg_tailq_write_lock(); /* guarantee there's no existing */ @@ -161,6 +168,12 @@ rte_lpm_create(const char *name, int socket_id, goto exit; }lib/librte_lpm/rte_lpm.c +8
-1+/* Determine the amount of memory to allocate. */ + mem_size =sizeof (*internal_lpm); + rules_size =sizeof (struct rte_lpm_rule ) * config->max_rules; + tbl8s_size = (sizeof (struct rte_lpm_tbl_entry ) * +RTE_LPM_TBL8_GROUP_NUM_ENTRIES * + config->number_tbl8s); +/* allocate tailq entry */ te =rte_zmalloc ("LPM_TAILQ_ENTRY" ,sizeof (*te),0 );if (te ==NULL ) {@@ -170,22 +183,23 @@ rte_lpm_create(const char *name, int socket_id, }/* Allocate memory to store the LPM data structures. */ - lpm = rte_zmalloc_socket(mem_name, mem_size, + internal_lpm = rte_zmalloc_socket(mem_name, mem_size,lib/librte_lpm/rte_lpm.c rte_lpm_create(const char *name, int socket_id, · line 195
Quoted 10 lines
lib/librte_lpm/rte_lpm.c +2
-1RTE_CACHE_LINE_SIZE, socket_id); -if (lpm ==NULL ) { +if (internal_lpm ==NULL ) {RTE_LOG (ERR ,LPM ,"LPM memory allocation failed\n" );rte_free (te); rte_errno =ENOMEM ; goto exit; } + lpm = &internal_lpm->lpm;From this point...
lib/librte_lpm/rte_lpm.c rte_lpm_create(const char *name, int socket_id, · line 202
Quoted 10 lines
lib/librte_lpm/rte_lpm.c +2
-2lpm->rules_tbl =rte_zmalloc_socket (NULL , (size_t )rules_size,RTE_CACHE_LINE_SIZE , socket_id);if (lpm->rules_tbl ==NULL ) {RTE_LOG (ERR ,LPM ,"LPM rules_tbl memory allocation failed\n" ); -rte_free (lpm); - lpm =NULL ; +rte_free (internal_lpm); + internal_lpm =NULL ;
Quoted 5 lines
... lpm is set to
&internal_lpm->lpmand will be returned by jumping to the exit label.
So freeinginternal_lpmis necessary, but the lpm variable must be set to NULL too.
Yes. lpm will be returned instead of internal_lpm. It must be set to NULL. Will add this in next version.
Quoted 15 lines
lib/librte_lpm/rte_lpm.c rte_lpm_create(const char *name, int socket_id, · line 215
Quoted 12 lines
lib/librte_lpm/rte_lpm.c +0
-0rte_free (te); rte_errno =ENOMEM ;goto exit;lib/librte_lpm/rte_lpm.c +2
-2@@ -197,8 +211,8 @@ rte_lpm_create(const char *name, int socket_id,if (lpm->tbl8 ==NULL ) {RTE_LOG (ERR ,LPM ,"LPM tbl8 memory allocation failed\n" );rte_free (lpm->rules_tbl); -rte_free (lpm); - lpm =NULL ; +rte_free (internal_lpm); + internal_lpm =NULL ;Ditto.
Will do.
Thanks.
Quoted 7 lines
lib/librte_lpm/rte_lpm.c rte_lpm_create(const char *name, int socket_id, · line 192
Quoted 4 lines
lib/librte_lpm/rte_lpm.c +0
-0rte_free (te); rte_errno =ENOMEM ; goto exit;--
David Marchand
PATCH v8 2/3 test/lpm: add LPM RCU integration functional tests
In reply to Ruifeng WangAdd positive and negative tests for API rte_lpm_rcu_qsbr_add. Also test LPM library behavior when RCU QSBR is enabled.
--- app/test/test_lpm.c | 291 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 290 insertions(+), 1 deletion(-)
app/test/test_lpm.c +290 -1
@@ -8,6 +8,7 @@#include <rte_ip.h> #include <rte_lpm.h> +#include <rte_malloc.h> #include "test.h" #include "test_xmmt_ops.h"
@@ -40,6 +41,9 @@ static int32_t test15(void);static int32_t test16 (void );static int32_t test17 (void );static int32_t test18 (void ); +static int32_t test19 (void ); +static int32_t test20 (void ); +static int32_t test21 (void );rte_lpm_test tests[] = {/* Test Cases */
@@ -61,7 +65,10 @@ rte_lpm_test tests[] = { test15, test16, test17, - test18 + test18, + test19, + test20, + test21 };#define MAX_DEPTH 32
@@ -1265,6 +1272,288 @@ test18(void)return PASS ; } +/* +* rte_lpm_rcu_qsbr_add positive and negative tests. +* - Add RCU QSBR variable to LPM +* - Add another RCU QSBR variable to LPM +* - Check returns +*/ +int32_t +test19 (void ) +{ +struct rte_lpm *lpm =NULL ; +struct rte_lpm_config config; +size_t sz; +struct rte_rcu_qsbr *qsv; +struct rte_rcu_qsbr *qsv2; +int32_t status; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + + config.max_rules =MAX_RULES ; + config.number_tbl8s =NUMBER_TBL8S ; + config.flags =0 ; + + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Create RCU QSBR variable */ + sz =rte_rcu_qsbr_get_memsize (RTE_MAX_LCORE ); + qsv = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (qsv !=NULL ); + + status =rte_rcu_qsbr_init (qsv,RTE_MAX_LCORE ); +TEST_LPM_ASSERT (status ==0 ); + + rcu_cfg.v = qsv; +/* Invalid QSBR mode */ + rcu_cfg.mode =2 ; + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status !=0 ); + + rcu_cfg.mode =RTE_LPM_QSBR_MODE_DQ ; +/* Attach RCU QSBR to LPM table */ + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status ==0 ); + +/* Create and attach another RCU QSBR to LPM table */ + qsv2 = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (qsv2 !=NULL ); + + rcu_cfg.v = qsv2; + rcu_cfg.mode =RTE_LPM_QSBR_MODE_SYNC ; + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status !=0 ); + +rte_lpm_free (lpm); +rte_free (qsv); +rte_free (qsv2); + +return PASS ; +} + +/* +* rte_lpm_rcu_qsbr_add DQ mode functional test. +* Reader and writer are in the same thread in this test. +* - Create LPM which supports 1 tbl8 group at max +* - Add RCU QSBR variable to LPM +* - Add a rule with depth=28 (> 24) +* - Register a reader thread (not a real thread) +* - Reader lookup existing rule +* - Writer delete the rule +* - Reader lookup the rule +* - Writer re-add the rule (no available tbl8 group) +* - Reader report quiescent state and unregister +* - Writer re-add the rule +* - Reader lookup the rule +*/ +int32_t +test20 (void ) +{ +struct rte_lpm *lpm =NULL ; +struct rte_lpm_config config; +size_t sz; +struct rte_rcu_qsbr *qsv; +int32_t status; +uint32_t ip, next_hop, next_hop_return; +uint8_t depth; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + + config.max_rules =MAX_RULES ; + config.number_tbl8s =1 ; + config.flags =0 ; + + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Create RCU QSBR variable */ + sz =rte_rcu_qsbr_get_memsize (1 ); + qsv = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (qsv !=NULL ); + + status =rte_rcu_qsbr_init (qsv,1 ); +TEST_LPM_ASSERT (status ==0 ); + + rcu_cfg.v = qsv; + rcu_cfg.mode =RTE_LPM_QSBR_MODE_DQ ; +/* Attach RCU QSBR to LPM table */ + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status ==0 ); + + ip =RTE_IPV4 (192 ,0 ,2 ,100 ); + depth =28 ; + next_hop =1 ; + status =rte_lpm_add (lpm, ip, depth, next_hop); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (lpm->tbl24[ip>>8 ].valid_group); + +/* Register pseudo reader */ + status =rte_rcu_qsbr_thread_register (qsv,0 ); +TEST_LPM_ASSERT (status ==0 ); +rte_rcu_qsbr_thread_online (qsv,0 ); + + status =rte_lpm_lookup (lpm, ip, &next_hop_return); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (next_hop_return == next_hop); + +/* Writer update */ + status =rte_lpm_delete (lpm, ip, depth); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (!lpm->tbl24[ip>>8 ].valid); + + status =rte_lpm_lookup (lpm, ip, &next_hop_return); +TEST_LPM_ASSERT (status !=0 ); + + status =rte_lpm_add (lpm, ip, depth, next_hop); +TEST_LPM_ASSERT (status !=0 ); + +/* Reader quiescent */ +rte_rcu_qsbr_quiescent (qsv,0 ); + + status =rte_lpm_add (lpm, ip, depth, next_hop); +TEST_LPM_ASSERT (status ==0 ); + +rte_rcu_qsbr_thread_offline (qsv,0 ); + status =rte_rcu_qsbr_thread_unregister (qsv,0 ); +TEST_LPM_ASSERT (status ==0 ); + + status =rte_lpm_lookup (lpm, ip, &next_hop_return); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (next_hop_return == next_hop); + +rte_lpm_free (lpm); +rte_free (qsv); + +return PASS ; +} + +static struct rte_lpm *g_lpm; +static struct rte_rcu_qsbr *g_v; +static uint32_t g_ip =RTE_IPV4 (192 ,0 ,2 ,100 ); +static volatile uint8_t writer_done; +/* Report quiescent state interval every 1024 lookups. Larger critical +* sections in reader will result in writer polling multiple times. +*/ +#define QSBR_REPORTING_INTERVAL 1024 +#define WRITER_ITERATIONS 512 + +/* +* Reader thread using rte_lpm data structure with RCU. +*/ +static int +test_lpm_rcu_qsbr_reader (void *arg) +{ +int i; +uint32_t next_hop_return =0 ; + +RTE_SET_USED (arg); +/* Register this thread to report quiescent state */ +rte_rcu_qsbr_thread_register (g_v,0 ); +rte_rcu_qsbr_thread_online (g_v,0 ); + +do { +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) +rte_lpm_lookup (g_lpm, g_ip, &next_hop_return); + +/* Update quiescent state */ +rte_rcu_qsbr_quiescent (g_v,0 ); + }while (!writer_done); + +rte_rcu_qsbr_thread_offline (g_v,0 ); +rte_rcu_qsbr_thread_unregister (g_v,0 ); + +return 0 ; +} + +/* +* rte_lpm_rcu_qsbr_add sync mode functional test. +* 1 Reader and 1 writer. They cannot be in the same thread in this test. +* - Create LPM which supports 1 tbl8 group at max +* - Add RCU QSBR variable with sync mode to LPM +* - Register a reader thread. Reader keeps looking up a specific rule. +* - Writer keeps adding and deleting a specific rule with depth=28 (> 24) +*/ +int32_t +test21 (void ) +{ +struct rte_lpm_config config; +size_t sz; +int32_t status; +uint32_t i, next_hop; +uint8_t depth; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + +if (rte_lcore_count () <2 ) { +printf ("Not enough cores for %s, expecting at least 2\n" , + __func__); +return TEST_SKIPPED ; + } + + config.max_rules =MAX_RULES ; + config.number_tbl8s =1 ; + config.flags =0 ; + + g_lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (g_lpm !=NULL ); + +/* Create RCU QSBR variable */ + sz =rte_rcu_qsbr_get_memsize (1 ); + g_v = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (g_v !=NULL ); + + status =rte_rcu_qsbr_init (g_v,1 ); +TEST_LPM_ASSERT (status ==0 ); + + rcu_cfg.v = g_v; + rcu_cfg.mode =RTE_LPM_QSBR_MODE_SYNC ; +/* Attach RCU QSBR to LPM table */ + status =rte_lpm_rcu_qsbr_add (g_lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status ==0 ); + + writer_done =0 ; +/* Launch reader thread */ +rte_eal_remote_launch (test_lpm_rcu_qsbr_reader,NULL , +rte_get_next_lcore (-1 ,1 ,0 )); + + depth =28 ; + next_hop =1 ; + status =rte_lpm_add (g_lpm, g_ip, depth, next_hop); +if (status !=0 ) { +printf ("%s: Failed to add rule\n" , __func__); + goto error; + } + +/* Writer update */ +for (i =0 ; i <WRITER_ITERATIONS ; i++) { + status =rte_lpm_delete (g_lpm, g_ip, depth); +if (status !=0 ) { +printf ("%s: Failed to delete rule at iteration %d\n" , + __func__, i); + goto error; + } + + status =rte_lpm_add (g_lpm, g_ip, depth, next_hop); +if (status !=0 ) { +printf ("%s: Failed to add rule at iteration %d\n" , + __func__, i); + goto error; + } + } + +error: + writer_done =1 ; +/* Wait until reader exited. */ +rte_eal_mp_wait_lcore (); + +rte_lpm_free (g_lpm); +rte_free (g_v); + +return (status ==0 ) ?PASS :-1 ; +} +/* * Do all unit tests. */
Signature · 1 line
2.17.1
PATCH v8 3/3 test/lpm: add RCU integration performance tests
In reply to Ruifeng WangFrom: Honnappa Nagarahalli <[email protected]>
Add performance tests for RCU integration. The performance difference with and without RCU integration is very small (~1% to ~2%) on both Arm and x86 platforms.
--- app/test/test_lpm_perf.c | 492 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 489 insertions(+), 3 deletions(-)
app/test/test_lpm_perf.c +489 -3
@@ -1,5 +1,6 @@/* SPDX-License-Identifier: BSD-3-Clause * Copyright(c) 2010-2014 Intel Corporation +* Copyright(c) 2020 Arm Limited */ #include <stdio.h>
@@ -10,12 +11,27 @@#include <rte_cycles.h> #include <rte_random.h> #include <rte_branch_prediction.h> +#include <rte_malloc.h> #include <rte_ip.h> #include <rte_lpm.h> #include "test.h" #include "test_xmmt_ops.h" +struct rte_lpm *lpm; +static struct rte_rcu_qsbr *rv; +static volatile uint8_t writer_done; +static volatile uint32_t thr_id; +static uint64_t gwrite_cycles; +static uint64_t gwrites; +/* LPM APIs are not thread safe, use mutex to provide thread safety */ +static pthread_mutex_t lpm_mutex =PTHREAD_MUTEX_INITIALIZER ; + +/* Report quiescent state interval every 1024 lookups. Larger critical +* sections in reader will result in writer polling multiple times. +*/ +#define QSBR_REPORTING_INTERVAL 1024 +#define TEST_LPM_ASSERT (cond) do { \ if (!(cond)) { \ printf("Error at line %d: \n", __LINE__); \
@@ -24,6 +40,7 @@ } while(0)#define ITERATIONS (1 << 10) +#define RCU_ITERATIONS 10#define BATCH_SIZE (1 << 12)#define BULK_SIZE 32
@@ -35,9 +52,13 @@ struct route_rule { };static struct route_rule large_route_table[MAX_RULE_NUM ]; +/* Route table for routes with depth > 24 */ +struct route_rule large_ldepth_route_table[MAX_RULE_NUM ];static uint32_t num_route_entries; +static uint32_t num_ldepth_route_entries;#define NUM_ROUTE_ENTRIES num_route_entries +#define NUM_LDEPTH_ROUTE_ENTRIES num_ldepth_route_entriesenum {IP_CLASS_A ,
@@ -191,7 +212,7 @@ static void generate_random_rule_prefix(uint32_t ip_class, uint8_t depth)uint32_t ip_head_mask;uint32_t rule_num;uint32_t k; -struct route_rule *ptr_rule; +struct route_rule *ptr_rule, *ptr_ldepth_rule;if (ip_class ==IP_CLASS_A ) {/* IP Address class A */ fixed_bit_num =IP_HEAD_BIT_NUM_A ;
@@ -236,10 +257,20 @@ static void generate_random_rule_prefix(uint32_t ip_class, uint8_t depth)*/ start =lrand48 () & mask; ptr_rule = &large_route_table[num_route_entries]; + ptr_ldepth_rule = &large_ldepth_route_table[num_ldepth_route_entries];for (k =0 ; k < rule_num; k++) { ptr_rule->ip = (start << (RTE_LPM_MAX_DEPTH - depth)) | ip_head_mask; ptr_rule->depth = depth; +/* If the depth of the route is more than 24, store it +* in another table as well. +*/ +if (depth >24 ) { + ptr_ldepth_rule->ip = ptr_rule->ip; + ptr_ldepth_rule->depth = ptr_rule->depth; + ptr_ldepth_rule++; + num_ldepth_route_entries++; + } ptr_rule++; start = (start + step) & mask; }
@@ -273,6 +304,7 @@ static void generate_large_route_rule_table(void)uint8_t depth; num_route_entries =0 ; + num_ldepth_route_entries =0 ;memset (large_route_table,0 ,sizeof (large_route_table));for (ip_class =IP_CLASS_A ; ip_class <=IP_CLASS_C ; ip_class++) {
@@ -316,10 +348,460 @@ print_route_distribution(const struct route_rule *table, uint32_t n)printf ("\n" ); } +/* Check condition and return an error if true. */ +static uint16_t enabled_core_ids[RTE_MAX_LCORE ]; +static unsigned int num_cores; + +/* Simple way to allocate thread ids in 0 to RTE_MAX_LCORE space */ +static inline uint32_t +alloc_thread_id (void ) +{ +uint32_t tmp_thr_id; + + tmp_thr_id =__atomic_fetch_add (&thr_id,1 , __ATOMIC_RELAXED); +if (tmp_thr_id >=RTE_MAX_LCORE ) +printf ("Invalid thread id %u\n" , tmp_thr_id); + +return tmp_thr_id; +} + +/* +* Reader thread using rte_lpm data structure without RCU. +*/ +static int +test_lpm_reader (void *arg) +{ +int i; +uint32_t ip_batch[QSBR_REPORTING_INTERVAL ]; +uint32_t next_hop_return =0 ; + +RTE_SET_USED (arg); +do { +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) + ip_batch[i] =rte_rand (); + +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) +rte_lpm_lookup (lpm, ip_batch[i], &next_hop_return); + + }while (!writer_done); + +return 0 ; +} + +/* +* Reader thread using rte_lpm data structure with RCU. +*/ +static int +test_lpm_rcu_qsbr_reader (void *arg) +{ +int i; +uint32_t thread_id =alloc_thread_id (); +uint32_t ip_batch[QSBR_REPORTING_INTERVAL ]; +uint32_t next_hop_return =0 ; + +RTE_SET_USED (arg); +/* Register this thread to report quiescent state */ +rte_rcu_qsbr_thread_register (rv, thread_id); +rte_rcu_qsbr_thread_online (rv, thread_id); + +do { +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) + ip_batch[i] =rte_rand (); + +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) +rte_lpm_lookup (lpm, ip_batch[i], &next_hop_return); + +/* Update quiescent state */ +rte_rcu_qsbr_quiescent (rv, thread_id); + }while (!writer_done); + +rte_rcu_qsbr_thread_offline (rv, thread_id); +rte_rcu_qsbr_thread_unregister (rv, thread_id); + +return 0 ; +} + +/* +* Writer thread using rte_lpm data structure with RCU. +*/ +static int +test_lpm_rcu_qsbr_writer (void *arg) +{ +unsigned int i, j, si, ei; +uint64_t begin, total_cycles; +uint8_t core_id = (uint8_t )((uintptr_t )arg); +uint32_t next_hop_add =0xAA ; + +RTE_SET_USED (arg); +/* 2 writer threads are used */ +if (core_id %2 ==0 ) { + si =0 ; + ei =NUM_LDEPTH_ROUTE_ENTRIES /2 ; + }else { + si =NUM_LDEPTH_ROUTE_ENTRIES /2 ; + ei =NUM_LDEPTH_ROUTE_ENTRIES ; + } + +/* Measure add/delete. */ + begin =rte_rdtsc_precise (); +for (i =0 ; i <RCU_ITERATIONS ; i++) { +/* Add all the entries */ +for (j = si; j < ei; j++) { +pthread_mutex_lock (&lpm_mutex); +if (rte_lpm_add (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth, + next_hop_add) !=0 ) { +printf ("Failed to add iteration %d, route# %d\n" , + i, j); + } +pthread_mutex_unlock (&lpm_mutex); + } + +/* Delete all the entries */ +for (j = si; j < ei; j++) { +pthread_mutex_lock (&lpm_mutex); +if (rte_lpm_delete (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth) !=0 ) { +printf ("Failed to delete iteration %d, route# %d\n" , + i, j); + } +pthread_mutex_unlock (&lpm_mutex); + } + } + + total_cycles =rte_rdtsc_precise () - begin; + +__atomic_fetch_add (&gwrite_cycles, total_cycles, __ATOMIC_RELAXED); +__atomic_fetch_add (&gwrites, +2 *NUM_LDEPTH_ROUTE_ENTRIES *RCU_ITERATIONS , + __ATOMIC_RELAXED); + +return 0 ; +} + +/* +* Functional test: +* 2 writers, rest are readers +*/ +static int +test_lpm_rcu_perf_multi_writer (void ) +{ +struct rte_lpm_config config; +size_t sz; +unsigned int i; +uint16_t core_id; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + +if (rte_lcore_count () <3 ) { +printf ("Not enough cores for lpm_rcu_perf_autotest, expecting at least 3\n" ); +return TEST_SKIPPED ; + } + + num_cores =0 ; +RTE_LCORE_FOREACH_SLAVE (core_id) { + enabled_core_ids[num_cores] = core_id; + num_cores++; + } + +printf ("\nPerf test: 2 writers, %d readers, RCU integration enabled\n" , + num_cores -2 ); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Init RCU variable */ + sz =rte_rcu_qsbr_get_memsize (num_cores); + rv = (struct rte_rcu_qsbr *)rte_zmalloc ("rcu0" , sz, +RTE_CACHE_LINE_SIZE ); +rte_rcu_qsbr_init (rv, num_cores); + + rcu_cfg.v = rv; +/* Assign the RCU variable to LPM */ +if (rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ) !=0 ) { +printf ("RCU variable assignment failed\n" ); + goto error; + } + + writer_done =0 ; +__atomic_store_n (&gwrite_cycles,0 , __ATOMIC_RELAXED); +__atomic_store_n (&gwrites,0 , __ATOMIC_RELAXED); + +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =2 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_reader,NULL , + enabled_core_ids[i]); + +/* Launch writer threads */ +for (i =0 ; i <2 ; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_writer, + (void *)(uintptr_t )i, + enabled_core_ids[i]); + +/* Wait for writer threads */ +for (i =0 ; i <2 ; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +printf ("Total LPM Adds: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %" PRIu64" cycles\n" , +__atomic_load_n (&gwrite_cycles, __ATOMIC_RELAXED) / +__atomic_load_n (&gwrites, __ATOMIC_RELAXED) + ); + +/* Wait and check return value from reader threads */ + writer_done =1 ; +for (i =2 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +rte_lpm_free (lpm); +rte_free (rv); + lpm =NULL ; + rv =NULL ; + +/* Test without RCU integration */ +printf ("\nPerf test: 2 writers, %d readers, RCU integration disabled\n" , + num_cores -2 ); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + + writer_done =0 ; +__atomic_store_n (&gwrite_cycles,0 , __ATOMIC_RELAXED); +__atomic_store_n (&gwrites,0 , __ATOMIC_RELAXED); +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =2 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_reader,NULL , + enabled_core_ids[i]); + +/* Launch writer threads */ +for (i =0 ; i <2 ; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_writer, + (void *)(uintptr_t )i, + enabled_core_ids[i]); + +/* Wait for writer threads */ +for (i =0 ; i <2 ; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +printf ("Total LPM Adds: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %" PRIu64" cycles\n" , +__atomic_load_n (&gwrite_cycles, __ATOMIC_RELAXED) / +__atomic_load_n (&gwrites, __ATOMIC_RELAXED) + ); + + writer_done =1 ; +/* Wait and check return value from reader threads */ +for (i =2 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +rte_lpm_free (lpm); + +return 0 ; + +error: + writer_done =1 ; +/* Wait until all readers have exited */ +rte_eal_mp_wait_lcore (); + +rte_lpm_free (lpm); +rte_free (rv); + +return -1 ; +} + +/* +* Functional test: +* Single writer, rest are readers +*/ +static int +test_lpm_rcu_perf (void ) +{ +struct rte_lpm_config config; +uint64_t begin, total_cycles; +size_t sz; +unsigned int i, j; +uint16_t core_id; +uint32_t next_hop_add =0xAA ; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + +if (rte_lcore_count () <2 ) { +printf ("Not enough cores for lpm_rcu_perf_autotest, expecting at least 2\n" ); +return TEST_SKIPPED ; + } + + num_cores =0 ; +RTE_LCORE_FOREACH_SLAVE (core_id) { + enabled_core_ids[num_cores] = core_id; + num_cores++; + } + +printf ("\nPerf test: 1 writer, %d readers, RCU integration enabled\n" , + num_cores); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Init RCU variable */ + sz =rte_rcu_qsbr_get_memsize (num_cores); + rv = (struct rte_rcu_qsbr *)rte_zmalloc ("rcu0" , sz, +RTE_CACHE_LINE_SIZE ); +rte_rcu_qsbr_init (rv, num_cores); + + rcu_cfg.v = rv; +/* Assign the RCU variable to LPM */ +if (rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ) !=0 ) { +printf ("RCU variable assignment failed\n" ); + goto error; + } + + writer_done =0 ; +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =0 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_reader,NULL , + enabled_core_ids[i]); + +/* Measure add/delete. */ + begin =rte_rdtsc_precise (); +for (i =0 ; i <RCU_ITERATIONS ; i++) { +/* Add all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_add (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth, + next_hop_add) !=0 ) { +printf ("Failed to add iteration %d, route# %d\n" , + i, j); + goto error; + } + +/* Delete all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_delete (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth) !=0 ) { +printf ("Failed to delete iteration %d, route# %d\n" , + i, j); + goto error; + } + } + total_cycles =rte_rdtsc_precise () - begin; + +printf ("Total LPM Adds: %d\n" ,ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %g cycles\n" , + (double )total_cycles / (NUM_LDEPTH_ROUTE_ENTRIES *ITERATIONS )); + + writer_done =1 ; +/* Wait and check return value from reader threads */ +for (i =0 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +rte_lpm_free (lpm); +rte_free (rv); + lpm =NULL ; + rv =NULL ; + +/* Test without RCU integration */ +printf ("\nPerf test: 1 writer, %d readers, RCU integration disabled\n" , + num_cores); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + + writer_done =0 ; +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =0 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_reader,NULL , + enabled_core_ids[i]); + +/* Measure add/delete. */ + begin =rte_rdtsc_precise (); +for (i =0 ; i <RCU_ITERATIONS ; i++) { +/* Add all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_add (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth, + next_hop_add) !=0 ) { +printf ("Failed to add iteration %d, route# %d\n" , + i, j); + goto error; + } + +/* Delete all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_delete (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth) !=0 ) { +printf ("Failed to delete iteration %d, route# %d\n" , + i, j); + goto error; + } + } + total_cycles =rte_rdtsc_precise () - begin; + +printf ("Total LPM Adds: %d\n" ,ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %g cycles\n" , + (double )total_cycles / (NUM_LDEPTH_ROUTE_ENTRIES *ITERATIONS )); + + writer_done =1 ; +/* Wait and check return value from reader threads */ +for (i =0 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) +printf ("Warning: lcore %u not finished.\n" , + enabled_core_ids[i]); + +rte_lpm_free (lpm); + +return 0 ; + +error: + writer_done =1 ; +/* Wait until all readers have exited */ +rte_eal_mp_wait_lcore (); + +rte_lpm_free (lpm); +rte_free (rv); + +return -1 ; +} +static int test_lpm_perf (void ) { -struct rte_lpm *lpm =NULL ;struct rte_lpm_config config; config.max_rules =2000000 ;
@@ -343,7 +825,7 @@ test_lpm_perf(void) lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config);TEST_LPM_ASSERT (lpm !=NULL ); -/* Measue add. */ +/* Measure add. */ begin =rte_rdtsc ();for (i =0 ; i <NUM_ROUTE_ENTRIES ; i++) {
@@ -478,6 +960,10 @@ test_lpm_perf(void)rte_lpm_delete_all (lpm);rte_lpm_free (lpm); +test_lpm_rcu_perf (); + +test_lpm_rcu_perf_multi_writer (); +return 0 ; }
Signature · 1 line
2.17.1
v9 cover RCU integration with LPM library
In reply to Ruifeng WangThis patchset integrates RCU QSBR support with LPM library.
Resource reclaimation implementation was splitted from the original series, and has already been part of RCU library. Rework the series to base LPM integration on RCU reclaimation APIs.
New API rte_lpm_rcu_qsbr_add is introduced for application to register a RCU variable that LPM library will use. This provides user the handle to enable RCU that integrated in LPM library.
Functional tests and performance tests are added to cover the integration with RCU.
---
v9:
Cleared lpm when allocation failed. (David)
v8:
Fixed ABI issue by adding internal LPM control structure. (David) Changed to use RFC5737 address in unit test. (Vladimir)
v7:
Fixed typos in document.
v6:
Remove ALLOW_EXPERIMENTAL_API from rte_lpm.c.
v5:
No default value for reclaim_thd. This allows reclamation triggering with every call. Pass LPM pointer instead of tbl8 as argument of reclaim callback free function. Updated group_idx check at tbl8 allocation.
Use enums instead of defines for different reclamation modes.
RCU QSBR integrated path is inside ALLOW_EXPERIMENTAL_API to avoid ABI change.
v4:
Allow user to configure defer queue: size, reclaim threshold, max entries. Return defer queue handler so user can manually trigger reclaimation. Add blocking mode support. Defer queue will not be created.
Honnappa Nagarahalli (1):
test/lpm: add RCU integration performance tests
Ruifeng Wang (2):
lib/lpm: integrate RCU QSBR
test/lpm: add LPM RCU integration functional tests
app/test/test_lpm.c | 291 ++++++++++++++++- app/test/test_lpm_perf.c | 492 ++++++++++++++++++++++++++++- doc/guides/prog_guide/lpm_lib.rst | 32 ++ lib/librte_lpm/Makefile | 2 +- lib/librte_lpm/meson.build | 1 + lib/librte_lpm/rte_lpm.c | 165 ++++++++-- lib/librte_lpm/rte_lpm.h | 53 ++++ lib/librte_lpm/rte_lpm_version.map | 6 + 8 files changed, 1016 insertions(+), 26 deletions(-)
Signature · 1 line
2.17.1
PATCH v9 1/3 lib/lpm: integrate RCU QSBR
Currently, the tbl8 group is freed even though the readers might be using the tbl8 group entries. The freed tbl8 group can be reallocated quickly. This results in incorrect lookup results.
RCU QSBR process is integrated for safe tbl8 group reclaim. Refer to RCU documentation to understand various aspects of integrating RCU library into other libraries.
To avoid ABI breakage, a struct __rte_lpm is created for lpm library internal use. This struct wraps rte_lpm that has been exposed and also includes members that don't need to be exposed such as RCU related config.
--- doc/guides/prog_guide/lpm_lib.rst | 32 ++++++ lib/librte_lpm/Makefile | 2 +- lib/librte_lpm/meson.build | 1 + lib/librte_lpm/rte_lpm.c | 165 +++++++++++++++++++++++++---- lib/librte_lpm/rte_lpm.h | 53 +++++++++ lib/librte_lpm/rte_lpm_version.map | 6 ++ 6 files changed, 237 insertions(+), 22 deletions(-)
doc/guides/prog_guide/lpm_lib.rst +32 -0
@@ -145,6 +145,38 @@ depending on whether we need to move to the next table or not. Prefix expansion is one of the keys of this algorithm, since it improves the speed dramatically by adding redundancy. +Deletion +~~~~~~~~ + +When deleting a rule, a replacement rule is searched for. Replacement rule is an existing rule that has +the longest prefix match with the rule to be deleted, but has shorter prefix. + +If a replacement rule is found, target tbl24 and tbl8 entries are updated to have the same depth and next hop +value with the replacement rule. + +If no replacement rule can be found, target tbl24 and tbl8 entries will be cleared. + +Prefix expansion is performed if the rule's depth is not exactly 24 bits or 32 bits. + +After deleting a rule, a group of tbl8s that belongs to the same tbl24 entry are freed in following cases: + +* All tbl8s in the group are empty . + +* All tbl8s in the group have the same values and with depth no greater than 24. + +Free of tbl8s have different behaviors: + +* If RCU is not used, tbl8s are cleared and reclaimed immediately. + +* If RCU is used, tbl8s are reclaimed when readers are in quiescent state. + +When the LPM is not using RCU, tbl8 group can be freed immediately even though the readers might be using +the tbl8 group entries. This might result in incorrect lookup results. + +RCU QSBR process is integrated for safe tbl8 group reclamation. Application has certain responsibilities +while using this feature. Please refer to resource reclamation framework of :ref:`RCU library <RCU_Library>` +for more details. + Lookup ~~~~~~
lib/librte_lpm/Makefile +1 -1
@@ -8,7 +8,7 @@ LIB = librte_lpm.a CFLAGS += -O3 CFLAGS += $(WERROR_FLAGS) -I$(SRCDIR) -LDLIBS += -lrte_eal -lrte_hash +LDLIBS += -lrte_eal -lrte_hash -lrte_rcu EXPORT_MAP := rte_lpm_version.map
lib/librte_lpm/meson.build +1 -0
@@ -7,3 +7,4 @@ headers = files('rte_lpm.h', 'rte_lpm6.h') # without worrying about which architecture we actually need headers += files('rte_lpm_altivec.h', 'rte_lpm_neon.h', 'rte_lpm_sse.h') deps += ['hash'] +deps += ['rcu']
lib/librte_lpm/rte_lpm.c +144 -21
281 lines not on this page · raw message
lib/librte_lpm/rte_lpm.h +53 -0
82 lines not on this page · raw message
lib/librte_lpm/rte_lpm_version.map +6 -0
@@ -21,3 +21,9 @@ DPDK_20.0 { local: *; }; + +EXPERIMENTAL { + global: + + rte_lpm_rcu_qsbr_add; +};
Signature · 1 line
2.17.1
PATCH v9 2/3 test/lpm: add LPM RCU integration functional tests
In reply to Ruifeng WangAdd positive and negative tests for API rte_lpm_rcu_qsbr_add. Also test LPM library behavior when RCU QSBR is enabled.
--- app/test/test_lpm.c | 291 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 290 insertions(+), 1 deletion(-)
app/test/test_lpm.c +290 -1
@@ -8,6 +8,7 @@#include <rte_ip.h> #include <rte_lpm.h> +#include <rte_malloc.h> #include "test.h" #include "test_xmmt_ops.h"
@@ -40,6 +41,9 @@ static int32_t test15(void);static int32_t test16 (void );static int32_t test17 (void );static int32_t test18 (void ); +static int32_t test19 (void ); +static int32_t test20 (void ); +static int32_t test21 (void );rte_lpm_test tests[] = {/* Test Cases */
@@ -61,7 +65,10 @@ rte_lpm_test tests[] = { test15, test16, test17, - test18 + test18, + test19, + test20, + test21 };#define MAX_DEPTH 32
@@ -1265,6 +1272,288 @@ test18(void)return PASS ; } +/* +* rte_lpm_rcu_qsbr_add positive and negative tests. +* - Add RCU QSBR variable to LPM +* - Add another RCU QSBR variable to LPM +* - Check returns +*/ +int32_t +test19 (void ) +{ +struct rte_lpm *lpm =NULL ; +struct rte_lpm_config config; +size_t sz; +struct rte_rcu_qsbr *qsv; +struct rte_rcu_qsbr *qsv2; +int32_t status; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + + config.max_rules =MAX_RULES ; + config.number_tbl8s =NUMBER_TBL8S ; + config.flags =0 ; + + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Create RCU QSBR variable */ + sz =rte_rcu_qsbr_get_memsize (RTE_MAX_LCORE ); + qsv = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (qsv !=NULL ); + + status =rte_rcu_qsbr_init (qsv,RTE_MAX_LCORE ); +TEST_LPM_ASSERT (status ==0 ); + + rcu_cfg.v = qsv; +/* Invalid QSBR mode */ + rcu_cfg.mode =2 ; + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status !=0 ); + + rcu_cfg.mode =RTE_LPM_QSBR_MODE_DQ ; +/* Attach RCU QSBR to LPM table */ + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status ==0 ); + +/* Create and attach another RCU QSBR to LPM table */ + qsv2 = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (qsv2 !=NULL ); + + rcu_cfg.v = qsv2; + rcu_cfg.mode =RTE_LPM_QSBR_MODE_SYNC ; + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status !=0 ); + +rte_lpm_free (lpm); +rte_free (qsv); +rte_free (qsv2); + +return PASS ; +} + +/* +* rte_lpm_rcu_qsbr_add DQ mode functional test. +* Reader and writer are in the same thread in this test. +* - Create LPM which supports 1 tbl8 group at max +* - Add RCU QSBR variable to LPM +* - Add a rule with depth=28 (> 24) +* - Register a reader thread (not a real thread) +* - Reader lookup existing rule +* - Writer delete the rule +* - Reader lookup the rule +* - Writer re-add the rule (no available tbl8 group) +* - Reader report quiescent state and unregister +* - Writer re-add the rule +* - Reader lookup the rule +*/ +int32_t +test20 (void ) +{ +struct rte_lpm *lpm =NULL ; +struct rte_lpm_config config; +size_t sz; +struct rte_rcu_qsbr *qsv; +int32_t status; +uint32_t ip, next_hop, next_hop_return; +uint8_t depth; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + + config.max_rules =MAX_RULES ; + config.number_tbl8s =1 ; + config.flags =0 ; + + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Create RCU QSBR variable */ + sz =rte_rcu_qsbr_get_memsize (1 ); + qsv = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (qsv !=NULL ); + + status =rte_rcu_qsbr_init (qsv,1 ); +TEST_LPM_ASSERT (status ==0 ); + + rcu_cfg.v = qsv; + rcu_cfg.mode =RTE_LPM_QSBR_MODE_DQ ; +/* Attach RCU QSBR to LPM table */ + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status ==0 ); + + ip =RTE_IPV4 (192 ,0 ,2 ,100 ); + depth =28 ; + next_hop =1 ; + status =rte_lpm_add (lpm, ip, depth, next_hop); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (lpm->tbl24[ip>>8 ].valid_group); + +/* Register pseudo reader */ + status =rte_rcu_qsbr_thread_register (qsv,0 ); +TEST_LPM_ASSERT (status ==0 ); +rte_rcu_qsbr_thread_online (qsv,0 ); + + status =rte_lpm_lookup (lpm, ip, &next_hop_return); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (next_hop_return == next_hop); + +/* Writer update */ + status =rte_lpm_delete (lpm, ip, depth); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (!lpm->tbl24[ip>>8 ].valid); + + status =rte_lpm_lookup (lpm, ip, &next_hop_return); +TEST_LPM_ASSERT (status !=0 ); + + status =rte_lpm_add (lpm, ip, depth, next_hop); +TEST_LPM_ASSERT (status !=0 ); + +/* Reader quiescent */ +rte_rcu_qsbr_quiescent (qsv,0 ); + + status =rte_lpm_add (lpm, ip, depth, next_hop); +TEST_LPM_ASSERT (status ==0 ); + +rte_rcu_qsbr_thread_offline (qsv,0 ); + status =rte_rcu_qsbr_thread_unregister (qsv,0 ); +TEST_LPM_ASSERT (status ==0 ); + + status =rte_lpm_lookup (lpm, ip, &next_hop_return); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (next_hop_return == next_hop); + +rte_lpm_free (lpm); +rte_free (qsv); + +return PASS ; +} + +static struct rte_lpm *g_lpm; +static struct rte_rcu_qsbr *g_v; +static uint32_t g_ip =RTE_IPV4 (192 ,0 ,2 ,100 ); +static volatile uint8_t writer_done; +/* Report quiescent state interval every 1024 lookups. Larger critical +* sections in reader will result in writer polling multiple times. +*/ +#define QSBR_REPORTING_INTERVAL 1024 +#define WRITER_ITERATIONS 512 + +/* +* Reader thread using rte_lpm data structure with RCU. +*/ +static int +test_lpm_rcu_qsbr_reader (void *arg) +{ +int i; +uint32_t next_hop_return =0 ; + +RTE_SET_USED (arg); +/* Register this thread to report quiescent state */ +rte_rcu_qsbr_thread_register (g_v,0 ); +rte_rcu_qsbr_thread_online (g_v,0 ); + +do { +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) +rte_lpm_lookup (g_lpm, g_ip, &next_hop_return); + +/* Update quiescent state */ +rte_rcu_qsbr_quiescent (g_v,0 ); + }while (!writer_done); + +rte_rcu_qsbr_thread_offline (g_v,0 ); +rte_rcu_qsbr_thread_unregister (g_v,0 ); + +return 0 ; +} + +/* +* rte_lpm_rcu_qsbr_add sync mode functional test. +* 1 Reader and 1 writer. They cannot be in the same thread in this test. +* - Create LPM which supports 1 tbl8 group at max +* - Add RCU QSBR variable with sync mode to LPM +* - Register a reader thread. Reader keeps looking up a specific rule. +* - Writer keeps adding and deleting a specific rule with depth=28 (> 24) +*/ +int32_t +test21 (void ) +{ +struct rte_lpm_config config; +size_t sz; +int32_t status; +uint32_t i, next_hop; +uint8_t depth; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + +if (rte_lcore_count () <2 ) { +printf ("Not enough cores for %s, expecting at least 2\n" , + __func__); +return TEST_SKIPPED ; + } + + config.max_rules =MAX_RULES ; + config.number_tbl8s =1 ; + config.flags =0 ; + + g_lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (g_lpm !=NULL ); + +/* Create RCU QSBR variable */ + sz =rte_rcu_qsbr_get_memsize (1 ); + g_v = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (g_v !=NULL ); + + status =rte_rcu_qsbr_init (g_v,1 ); +TEST_LPM_ASSERT (status ==0 ); + + rcu_cfg.v = g_v; + rcu_cfg.mode =RTE_LPM_QSBR_MODE_SYNC ; +/* Attach RCU QSBR to LPM table */ + status =rte_lpm_rcu_qsbr_add (g_lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status ==0 ); + + writer_done =0 ; +/* Launch reader thread */ +rte_eal_remote_launch (test_lpm_rcu_qsbr_reader,NULL , +rte_get_next_lcore (-1 ,1 ,0 )); + + depth =28 ; + next_hop =1 ; + status =rte_lpm_add (g_lpm, g_ip, depth, next_hop); +if (status !=0 ) { +printf ("%s: Failed to add rule\n" , __func__); + goto error; + } + +/* Writer update */ +for (i =0 ; i <WRITER_ITERATIONS ; i++) { + status =rte_lpm_delete (g_lpm, g_ip, depth); +if (status !=0 ) { +printf ("%s: Failed to delete rule at iteration %d\n" , + __func__, i); + goto error; + } + + status =rte_lpm_add (g_lpm, g_ip, depth, next_hop); +if (status !=0 ) { +printf ("%s: Failed to add rule at iteration %d\n" , + __func__, i); + goto error; + } + } + +error: + writer_done =1 ; +/* Wait until reader exited. */ +rte_eal_mp_wait_lcore (); + +rte_lpm_free (g_lpm); +rte_free (g_v); + +return (status ==0 ) ?PASS :-1 ; +} +/* * Do all unit tests. */
Signature · 1 line
2.17.1
PATCH v9 3/3 test/lpm: add RCU integration performance tests
In reply to Ruifeng WangFrom: Honnappa Nagarahalli <[email protected]>
Add performance tests for RCU integration. The performance difference with and without RCU integration is very small (~1% to ~2%) on both Arm and x86 platforms.
--- app/test/test_lpm_perf.c | 492 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 489 insertions(+), 3 deletions(-)
app/test/test_lpm_perf.c +489 -3
@@ -1,5 +1,6 @@/* SPDX-License-Identifier: BSD-3-Clause * Copyright(c) 2010-2014 Intel Corporation +* Copyright(c) 2020 Arm Limited */ #include <stdio.h>
@@ -10,12 +11,27 @@#include <rte_cycles.h> #include <rte_random.h> #include <rte_branch_prediction.h> +#include <rte_malloc.h> #include <rte_ip.h> #include <rte_lpm.h> #include "test.h" #include "test_xmmt_ops.h" +struct rte_lpm *lpm; +static struct rte_rcu_qsbr *rv; +static volatile uint8_t writer_done; +static volatile uint32_t thr_id; +static uint64_t gwrite_cycles; +static uint64_t gwrites; +/* LPM APIs are not thread safe, use mutex to provide thread safety */ +static pthread_mutex_t lpm_mutex =PTHREAD_MUTEX_INITIALIZER ; + +/* Report quiescent state interval every 1024 lookups. Larger critical +* sections in reader will result in writer polling multiple times. +*/ +#define QSBR_REPORTING_INTERVAL 1024 +#define TEST_LPM_ASSERT (cond) do { \ if (!(cond)) { \ printf("Error at line %d: \n", __LINE__); \
@@ -24,6 +40,7 @@ } while(0)#define ITERATIONS (1 << 10) +#define RCU_ITERATIONS 10#define BATCH_SIZE (1 << 12)#define BULK_SIZE 32
@@ -35,9 +52,13 @@ struct route_rule { };static struct route_rule large_route_table[MAX_RULE_NUM ]; +/* Route table for routes with depth > 24 */ +struct route_rule large_ldepth_route_table[MAX_RULE_NUM ];static uint32_t num_route_entries; +static uint32_t num_ldepth_route_entries;#define NUM_ROUTE_ENTRIES num_route_entries +#define NUM_LDEPTH_ROUTE_ENTRIES num_ldepth_route_entriesenum {IP_CLASS_A ,
@@ -191,7 +212,7 @@ static void generate_random_rule_prefix(uint32_t ip_class, uint8_t depth)uint32_t ip_head_mask;uint32_t rule_num;uint32_t k; -struct route_rule *ptr_rule; +struct route_rule *ptr_rule, *ptr_ldepth_rule;if (ip_class ==IP_CLASS_A ) {/* IP Address class A */ fixed_bit_num =IP_HEAD_BIT_NUM_A ;
@@ -236,10 +257,20 @@ static void generate_random_rule_prefix(uint32_t ip_class, uint8_t depth)*/ start =lrand48 () & mask; ptr_rule = &large_route_table[num_route_entries]; + ptr_ldepth_rule = &large_ldepth_route_table[num_ldepth_route_entries];for (k =0 ; k < rule_num; k++) { ptr_rule->ip = (start << (RTE_LPM_MAX_DEPTH - depth)) | ip_head_mask; ptr_rule->depth = depth; +/* If the depth of the route is more than 24, store it +* in another table as well. +*/ +if (depth >24 ) { + ptr_ldepth_rule->ip = ptr_rule->ip; + ptr_ldepth_rule->depth = ptr_rule->depth; + ptr_ldepth_rule++; + num_ldepth_route_entries++; + } ptr_rule++; start = (start + step) & mask; }
@@ -273,6 +304,7 @@ static void generate_large_route_rule_table(void)uint8_t depth; num_route_entries =0 ; + num_ldepth_route_entries =0 ;memset (large_route_table,0 ,sizeof (large_route_table));for (ip_class =IP_CLASS_A ; ip_class <=IP_CLASS_C ; ip_class++) {
@@ -316,10 +348,460 @@ print_route_distribution(const struct route_rule *table, uint32_t n)printf ("\n" ); } +/* Check condition and return an error if true. */ +static uint16_t enabled_core_ids[RTE_MAX_LCORE ]; +static unsigned int num_cores; + +/* Simple way to allocate thread ids in 0 to RTE_MAX_LCORE space */ +static inline uint32_t +alloc_thread_id (void ) +{ +uint32_t tmp_thr_id; + + tmp_thr_id =__atomic_fetch_add (&thr_id,1 , __ATOMIC_RELAXED); +if (tmp_thr_id >=RTE_MAX_LCORE ) +printf ("Invalid thread id %u\n" , tmp_thr_id); + +return tmp_thr_id; +} + +/* +* Reader thread using rte_lpm data structure without RCU. +*/ +static int +test_lpm_reader (void *arg) +{ +int i; +uint32_t ip_batch[QSBR_REPORTING_INTERVAL ]; +uint32_t next_hop_return =0 ; + +RTE_SET_USED (arg); +do { +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) + ip_batch[i] =rte_rand (); + +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) +rte_lpm_lookup (lpm, ip_batch[i], &next_hop_return); + + }while (!writer_done); + +return 0 ; +} + +/* +* Reader thread using rte_lpm data structure with RCU. +*/ +static int +test_lpm_rcu_qsbr_reader (void *arg) +{ +int i; +uint32_t thread_id =alloc_thread_id (); +uint32_t ip_batch[QSBR_REPORTING_INTERVAL ]; +uint32_t next_hop_return =0 ; + +RTE_SET_USED (arg); +/* Register this thread to report quiescent state */ +rte_rcu_qsbr_thread_register (rv, thread_id); +rte_rcu_qsbr_thread_online (rv, thread_id); + +do { +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) + ip_batch[i] =rte_rand (); + +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) +rte_lpm_lookup (lpm, ip_batch[i], &next_hop_return); + +/* Update quiescent state */ +rte_rcu_qsbr_quiescent (rv, thread_id); + }while (!writer_done); + +rte_rcu_qsbr_thread_offline (rv, thread_id); +rte_rcu_qsbr_thread_unregister (rv, thread_id); + +return 0 ; +} + +/* +* Writer thread using rte_lpm data structure with RCU. +*/ +static int +test_lpm_rcu_qsbr_writer (void *arg) +{ +unsigned int i, j, si, ei; +uint64_t begin, total_cycles; +uint8_t core_id = (uint8_t )((uintptr_t )arg); +uint32_t next_hop_add =0xAA ; + +RTE_SET_USED (arg); +/* 2 writer threads are used */ +if (core_id %2 ==0 ) { + si =0 ; + ei =NUM_LDEPTH_ROUTE_ENTRIES /2 ; + }else { + si =NUM_LDEPTH_ROUTE_ENTRIES /2 ; + ei =NUM_LDEPTH_ROUTE_ENTRIES ; + } + +/* Measure add/delete. */ + begin =rte_rdtsc_precise (); +for (i =0 ; i <RCU_ITERATIONS ; i++) { +/* Add all the entries */ +for (j = si; j < ei; j++) { +pthread_mutex_lock (&lpm_mutex); +if (rte_lpm_add (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth, + next_hop_add) !=0 ) { +printf ("Failed to add iteration %d, route# %d\n" , + i, j); + } +pthread_mutex_unlock (&lpm_mutex); + } + +/* Delete all the entries */ +for (j = si; j < ei; j++) { +pthread_mutex_lock (&lpm_mutex); +if (rte_lpm_delete (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth) !=0 ) { +printf ("Failed to delete iteration %d, route# %d\n" , + i, j); + } +pthread_mutex_unlock (&lpm_mutex); + } + } + + total_cycles =rte_rdtsc_precise () - begin; + +__atomic_fetch_add (&gwrite_cycles, total_cycles, __ATOMIC_RELAXED); +__atomic_fetch_add (&gwrites, +2 *NUM_LDEPTH_ROUTE_ENTRIES *RCU_ITERATIONS , + __ATOMIC_RELAXED); + +return 0 ; +} + +/* +* Functional test: +* 2 writers, rest are readers +*/ +static int +test_lpm_rcu_perf_multi_writer (void ) +{ +struct rte_lpm_config config; +size_t sz; +unsigned int i; +uint16_t core_id; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + +if (rte_lcore_count () <3 ) { +printf ("Not enough cores for lpm_rcu_perf_autotest, expecting at least 3\n" ); +return TEST_SKIPPED ; + } + + num_cores =0 ; +RTE_LCORE_FOREACH_SLAVE (core_id) { + enabled_core_ids[num_cores] = core_id; + num_cores++; + } + +printf ("\nPerf test: 2 writers, %d readers, RCU integration enabled\n" , + num_cores -2 ); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Init RCU variable */ + sz =rte_rcu_qsbr_get_memsize (num_cores); + rv = (struct rte_rcu_qsbr *)rte_zmalloc ("rcu0" , sz, +RTE_CACHE_LINE_SIZE ); +rte_rcu_qsbr_init (rv, num_cores); + + rcu_cfg.v = rv; +/* Assign the RCU variable to LPM */ +if (rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ) !=0 ) { +printf ("RCU variable assignment failed\n" ); + goto error; + } + + writer_done =0 ; +__atomic_store_n (&gwrite_cycles,0 , __ATOMIC_RELAXED); +__atomic_store_n (&gwrites,0 , __ATOMIC_RELAXED); + +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =2 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_reader,NULL , + enabled_core_ids[i]); + +/* Launch writer threads */ +for (i =0 ; i <2 ; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_writer, + (void *)(uintptr_t )i, + enabled_core_ids[i]); + +/* Wait for writer threads */ +for (i =0 ; i <2 ; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +printf ("Total LPM Adds: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %" PRIu64" cycles\n" , +__atomic_load_n (&gwrite_cycles, __ATOMIC_RELAXED) / +__atomic_load_n (&gwrites, __ATOMIC_RELAXED) + ); + +/* Wait and check return value from reader threads */ + writer_done =1 ; +for (i =2 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +rte_lpm_free (lpm); +rte_free (rv); + lpm =NULL ; + rv =NULL ; + +/* Test without RCU integration */ +printf ("\nPerf test: 2 writers, %d readers, RCU integration disabled\n" , + num_cores -2 ); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + + writer_done =0 ; +__atomic_store_n (&gwrite_cycles,0 , __ATOMIC_RELAXED); +__atomic_store_n (&gwrites,0 , __ATOMIC_RELAXED); +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =2 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_reader,NULL , + enabled_core_ids[i]); + +/* Launch writer threads */ +for (i =0 ; i <2 ; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_writer, + (void *)(uintptr_t )i, + enabled_core_ids[i]); + +/* Wait for writer threads */ +for (i =0 ; i <2 ; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +printf ("Total LPM Adds: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %" PRIu64" cycles\n" , +__atomic_load_n (&gwrite_cycles, __ATOMIC_RELAXED) / +__atomic_load_n (&gwrites, __ATOMIC_RELAXED) + ); + + writer_done =1 ; +/* Wait and check return value from reader threads */ +for (i =2 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +rte_lpm_free (lpm); + +return 0 ; + +error: + writer_done =1 ; +/* Wait until all readers have exited */ +rte_eal_mp_wait_lcore (); + +rte_lpm_free (lpm); +rte_free (rv); + +return -1 ; +} + +/* +* Functional test: +* Single writer, rest are readers +*/ +static int +test_lpm_rcu_perf (void ) +{ +struct rte_lpm_config config; +uint64_t begin, total_cycles; +size_t sz; +unsigned int i, j; +uint16_t core_id; +uint32_t next_hop_add =0xAA ; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + +if (rte_lcore_count () <2 ) { +printf ("Not enough cores for lpm_rcu_perf_autotest, expecting at least 2\n" ); +return TEST_SKIPPED ; + } + + num_cores =0 ; +RTE_LCORE_FOREACH_SLAVE (core_id) { + enabled_core_ids[num_cores] = core_id; + num_cores++; + } + +printf ("\nPerf test: 1 writer, %d readers, RCU integration enabled\n" , + num_cores); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Init RCU variable */ + sz =rte_rcu_qsbr_get_memsize (num_cores); + rv = (struct rte_rcu_qsbr *)rte_zmalloc ("rcu0" , sz, +RTE_CACHE_LINE_SIZE ); +rte_rcu_qsbr_init (rv, num_cores); + + rcu_cfg.v = rv; +/* Assign the RCU variable to LPM */ +if (rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ) !=0 ) { +printf ("RCU variable assignment failed\n" ); + goto error; + } + + writer_done =0 ; +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =0 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_reader,NULL , + enabled_core_ids[i]); + +/* Measure add/delete. */ + begin =rte_rdtsc_precise (); +for (i =0 ; i <RCU_ITERATIONS ; i++) { +/* Add all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_add (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth, + next_hop_add) !=0 ) { +printf ("Failed to add iteration %d, route# %d\n" , + i, j); + goto error; + } + +/* Delete all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_delete (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth) !=0 ) { +printf ("Failed to delete iteration %d, route# %d\n" , + i, j); + goto error; + } + } + total_cycles =rte_rdtsc_precise () - begin; + +printf ("Total LPM Adds: %d\n" ,ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %g cycles\n" , + (double )total_cycles / (NUM_LDEPTH_ROUTE_ENTRIES *ITERATIONS )); + + writer_done =1 ; +/* Wait and check return value from reader threads */ +for (i =0 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +rte_lpm_free (lpm); +rte_free (rv); + lpm =NULL ; + rv =NULL ; + +/* Test without RCU integration */ +printf ("\nPerf test: 1 writer, %d readers, RCU integration disabled\n" , + num_cores); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + + writer_done =0 ; +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =0 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_reader,NULL , + enabled_core_ids[i]); + +/* Measure add/delete. */ + begin =rte_rdtsc_precise (); +for (i =0 ; i <RCU_ITERATIONS ; i++) { +/* Add all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_add (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth, + next_hop_add) !=0 ) { +printf ("Failed to add iteration %d, route# %d\n" , + i, j); + goto error; + } + +/* Delete all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_delete (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth) !=0 ) { +printf ("Failed to delete iteration %d, route# %d\n" , + i, j); + goto error; + } + } + total_cycles =rte_rdtsc_precise () - begin; + +printf ("Total LPM Adds: %d\n" ,ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %g cycles\n" , + (double )total_cycles / (NUM_LDEPTH_ROUTE_ENTRIES *ITERATIONS )); + + writer_done =1 ; +/* Wait and check return value from reader threads */ +for (i =0 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) +printf ("Warning: lcore %u not finished.\n" , + enabled_core_ids[i]); + +rte_lpm_free (lpm); + +return 0 ; + +error: + writer_done =1 ; +/* Wait until all readers have exited */ +rte_eal_mp_wait_lcore (); + +rte_lpm_free (lpm); +rte_free (rv); + +return -1 ; +} +static int test_lpm_perf (void ) { -struct rte_lpm *lpm =NULL ;struct rte_lpm_config config; config.max_rules =2000000 ;
@@ -343,7 +825,7 @@ test_lpm_perf(void) lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config);TEST_LPM_ASSERT (lpm !=NULL ); -/* Measue add. */ +/* Measure add. */ begin =rte_rdtsc ();for (i =0 ; i <NUM_ROUTE_ENTRIES ; i++) {
@@ -478,6 +960,10 @@ test_lpm_perf(void)rte_lpm_delete_all (lpm);rte_lpm_free (lpm); +test_lpm_rcu_perf (); + +test_lpm_rcu_perf_multi_writer (); +return 0 ; }
Signature · 1 line
2.17.1
v10 cover RCU integration with LPM library
In reply to Ruifeng WangThis patchset integrates RCU QSBR support with LPM library.
Resource reclaimation implementation was splitted from the original series, and has already been part of RCU library. Rework the series to base LPM integration on RCU reclaimation APIs.
New API rte_lpm_rcu_qsbr_add is introduced for application to register a RCU variable that LPM library will use. This provides user the handle to enable RCU that integrated in LPM library.
Functional tests and performance tests are added to cover the integration with RCU.
---
v10:
Added missing Acked-by tags.
v9:
Cleared lpm when allocation failed. (David)
v8:
Fixed ABI issue by adding internal LPM control structure. (David) Changed to use RFC5737 address in unit test. (Vladimir)
v7:
Fixed typos in document.
v6:
Remove ALLOW_EXPERIMENTAL_API from rte_lpm.c.
v5:
No default value for reclaim_thd. This allows reclamation triggering with every call. Pass LPM pointer instead of tbl8 as argument of reclaim callback free function. Updated group_idx check at tbl8 allocation.
Use enums instead of defines for different reclamation modes.
RCU QSBR integrated path is inside ALLOW_EXPERIMENTAL_API to avoid ABI change.
v4:
Allow user to configure defer queue: size, reclaim threshold, max entries. Return defer queue handler so user can manually trigger reclaimation. Add blocking mode support. Defer queue will not be created.
Honnappa Nagarahalli (1):
test/lpm: add RCU integration performance tests
Ruifeng Wang (2):
lib/lpm: integrate RCU QSBR
test/lpm: add LPM RCU integration functional tests
app/test/test_lpm.c | 291 ++++++++++++++++- app/test/test_lpm_perf.c | 492 ++++++++++++++++++++++++++++- doc/guides/prog_guide/lpm_lib.rst | 32 ++ lib/librte_lpm/Makefile | 2 +- lib/librte_lpm/meson.build | 1 + lib/librte_lpm/rte_lpm.c | 165 ++++++++-- lib/librte_lpm/rte_lpm.h | 53 ++++ lib/librte_lpm/rte_lpm_version.map | 6 + 8 files changed, 1016 insertions(+), 26 deletions(-)
Signature · 1 line
2.17.1
PATCH v10 1/3 lib/lpm: integrate RCU QSBR
Currently, the tbl8 group is freed even though the readers might be using the tbl8 group entries. The freed tbl8 group can be reallocated quickly. This results in incorrect lookup results.
RCU QSBR process is integrated for safe tbl8 group reclaim. Refer to RCU documentation to understand various aspects of integrating RCU library into other libraries.
To avoid ABI breakage, a struct __rte_lpm is created for lpm library internal use. This struct wraps rte_lpm that has been exposed and also includes members that don't need to be exposed such as RCU related config.
--- doc/guides/prog_guide/lpm_lib.rst | 32 ++++++ lib/librte_lpm/Makefile | 2 +- lib/librte_lpm/meson.build | 1 + lib/librte_lpm/rte_lpm.c | 165 +++++++++++++++++++++++++---- lib/librte_lpm/rte_lpm.h | 53 +++++++++ lib/librte_lpm/rte_lpm_version.map | 6 ++ 6 files changed, 237 insertions(+), 22 deletions(-)
doc/guides/prog_guide/lpm_lib.rst +32 -0
@@ -145,6 +145,38 @@ depending on whether we need to move to the next table or not. Prefix expansion is one of the keys of this algorithm, since it improves the speed dramatically by adding redundancy. +Deletion +~~~~~~~~ + +When deleting a rule, a replacement rule is searched for. Replacement rule is an existing rule that has +the longest prefix match with the rule to be deleted, but has shorter prefix. + +If a replacement rule is found, target tbl24 and tbl8 entries are updated to have the same depth and next hop +value with the replacement rule. + +If no replacement rule can be found, target tbl24 and tbl8 entries will be cleared. + +Prefix expansion is performed if the rule's depth is not exactly 24 bits or 32 bits. + +After deleting a rule, a group of tbl8s that belongs to the same tbl24 entry are freed in following cases: + +* All tbl8s in the group are empty . + +* All tbl8s in the group have the same values and with depth no greater than 24. + +Free of tbl8s have different behaviors: + +* If RCU is not used, tbl8s are cleared and reclaimed immediately. + +* If RCU is used, tbl8s are reclaimed when readers are in quiescent state. + +When the LPM is not using RCU, tbl8 group can be freed immediately even though the readers might be using +the tbl8 group entries. This might result in incorrect lookup results. + +RCU QSBR process is integrated for safe tbl8 group reclamation. Application has certain responsibilities +while using this feature. Please refer to resource reclamation framework of :ref:`RCU library <RCU_Library>` +for more details. + Lookup ~~~~~~
lib/librte_lpm/Makefile +1 -1
@@ -8,7 +8,7 @@ LIB = librte_lpm.a CFLAGS += -O3 CFLAGS += $(WERROR_FLAGS) -I$(SRCDIR) -LDLIBS += -lrte_eal -lrte_hash +LDLIBS += -lrte_eal -lrte_hash -lrte_rcu EXPORT_MAP := rte_lpm_version.map
lib/librte_lpm/meson.build +1 -0
@@ -7,3 +7,4 @@ headers = files('rte_lpm.h', 'rte_lpm6.h') # without worrying about which architecture we actually need headers += files('rte_lpm_altivec.h', 'rte_lpm_neon.h', 'rte_lpm_sse.h') deps += ['hash'] +deps += ['rcu']
lib/librte_lpm/rte_lpm.c +144 -21
281 lines not on this page · raw message
lib/librte_lpm/rte_lpm.h +53 -0
82 lines not on this page · raw message
lib/librte_lpm/rte_lpm_version.map +6 -0
@@ -21,3 +21,9 @@ DPDK_20.0 { local: *; }; + +EXPERIMENTAL { + global: + + rte_lpm_rcu_qsbr_add; +};
Signature · 1 line
2.17.1
Re: [dpdk-dev] [PATCH v10 1/3] lib/lpm: integrate RCU QSBR
The ci/checkpatch warning is a false positive.
Quoted 38 lines
-----Original Message-----
From: Ruifeng Wang <[email protected]>
Sent: Friday, July 10, 2020 10:22 AM
To: Bruce Richardson <[email protected]>; Vladimir Medvedkin <[email protected]>; John McNamara <[email protected]>; Marko Kovacevic <[email protected]>; Ray Kinsella <[email protected]>; Neil Horman <[email protected]>
Cc: [email protected]; [email protected]; Honnappa Nagarahalli <[email protected]>; nd <[email protected]>; Ruifeng Wang <[email protected]>
Subject: [PATCH v10 1/3] lib/lpm: integrate RCU QSBRCurrently, the tbl8 group is freed even though the readers might be using the tbl8 group entries. The freed tbl8 group can be reallocated quickly. This results in incorrect lookup results.
RCU QSBR process is integrated for safe tbl8 group reclaim. Refer to RCU documentation to understand various aspects of integrating RCU library into other libraries.
To avoid ABI breakage, a struct
__rte_lpmis created for lpm library internal use. This struct wrapsrte_lpmthat has been exposed and also includes members that don't need to be exposed such as RCU related config.Signed-off-by Ruifeng Wang <[email protected]>Reviewed-by Honnappa Nagarahalli <[email protected]>Acked-by Ray Kinsella <[email protected]>--- doc/guides/prog_guide/lpm_lib.rst | 32 ++++++ lib/librte_lpm/Makefile | 2 +- lib/librte_lpm/meson.build | 1 + lib/librte_lpm/rte_lpm.c | 165 +++++++++++++++++++++++++---- lib/librte_lpm/rte_lpm.h | 53 +++++++++ lib/librte_lpm/rte_lpm_version.map | 6 ++ 6 files changed, 237 insertions(+), 22 deletions(-)
PATCH v10 2/3 test/lpm: add LPM RCU integration functional tests
In reply to Ruifeng WangAdd positive and negative tests for API rte_lpm_rcu_qsbr_add. Also test LPM library behavior when RCU QSBR is enabled.
--- app/test/test_lpm.c | 291 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 290 insertions(+), 1 deletion(-)
app/test/test_lpm.c +290 -1
@@ -8,6 +8,7 @@#include <rte_ip.h> #include <rte_lpm.h> +#include <rte_malloc.h> #include "test.h" #include "test_xmmt_ops.h"
@@ -40,6 +41,9 @@ static int32_t test15(void);static int32_t test16 (void );static int32_t test17 (void );static int32_t test18 (void ); +static int32_t test19 (void ); +static int32_t test20 (void ); +static int32_t test21 (void );rte_lpm_test tests[] = {/* Test Cases */
@@ -61,7 +65,10 @@ rte_lpm_test tests[] = { test15, test16, test17, - test18 + test18, + test19, + test20, + test21 };#define MAX_DEPTH 32
@@ -1265,6 +1272,288 @@ test18(void)return PASS ; } +/* +* rte_lpm_rcu_qsbr_add positive and negative tests. +* - Add RCU QSBR variable to LPM +* - Add another RCU QSBR variable to LPM +* - Check returns +*/ +int32_t +test19 (void ) +{ +struct rte_lpm *lpm =NULL ; +struct rte_lpm_config config; +size_t sz; +struct rte_rcu_qsbr *qsv; +struct rte_rcu_qsbr *qsv2; +int32_t status; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + + config.max_rules =MAX_RULES ; + config.number_tbl8s =NUMBER_TBL8S ; + config.flags =0 ; + + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Create RCU QSBR variable */ + sz =rte_rcu_qsbr_get_memsize (RTE_MAX_LCORE ); + qsv = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (qsv !=NULL ); + + status =rte_rcu_qsbr_init (qsv,RTE_MAX_LCORE ); +TEST_LPM_ASSERT (status ==0 ); + + rcu_cfg.v = qsv; +/* Invalid QSBR mode */ + rcu_cfg.mode =2 ; + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status !=0 ); + + rcu_cfg.mode =RTE_LPM_QSBR_MODE_DQ ; +/* Attach RCU QSBR to LPM table */ + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status ==0 ); + +/* Create and attach another RCU QSBR to LPM table */ + qsv2 = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (qsv2 !=NULL ); + + rcu_cfg.v = qsv2; + rcu_cfg.mode =RTE_LPM_QSBR_MODE_SYNC ; + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status !=0 ); + +rte_lpm_free (lpm); +rte_free (qsv); +rte_free (qsv2); + +return PASS ; +} + +/* +* rte_lpm_rcu_qsbr_add DQ mode functional test. +* Reader and writer are in the same thread in this test. +* - Create LPM which supports 1 tbl8 group at max +* - Add RCU QSBR variable to LPM +* - Add a rule with depth=28 (> 24) +* - Register a reader thread (not a real thread) +* - Reader lookup existing rule +* - Writer delete the rule +* - Reader lookup the rule +* - Writer re-add the rule (no available tbl8 group) +* - Reader report quiescent state and unregister +* - Writer re-add the rule +* - Reader lookup the rule +*/ +int32_t +test20 (void ) +{ +struct rte_lpm *lpm =NULL ; +struct rte_lpm_config config; +size_t sz; +struct rte_rcu_qsbr *qsv; +int32_t status; +uint32_t ip, next_hop, next_hop_return; +uint8_t depth; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + + config.max_rules =MAX_RULES ; + config.number_tbl8s =1 ; + config.flags =0 ; + + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Create RCU QSBR variable */ + sz =rte_rcu_qsbr_get_memsize (1 ); + qsv = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (qsv !=NULL ); + + status =rte_rcu_qsbr_init (qsv,1 ); +TEST_LPM_ASSERT (status ==0 ); + + rcu_cfg.v = qsv; + rcu_cfg.mode =RTE_LPM_QSBR_MODE_DQ ; +/* Attach RCU QSBR to LPM table */ + status =rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status ==0 ); + + ip =RTE_IPV4 (192 ,0 ,2 ,100 ); + depth =28 ; + next_hop =1 ; + status =rte_lpm_add (lpm, ip, depth, next_hop); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (lpm->tbl24[ip>>8 ].valid_group); + +/* Register pseudo reader */ + status =rte_rcu_qsbr_thread_register (qsv,0 ); +TEST_LPM_ASSERT (status ==0 ); +rte_rcu_qsbr_thread_online (qsv,0 ); + + status =rte_lpm_lookup (lpm, ip, &next_hop_return); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (next_hop_return == next_hop); + +/* Writer update */ + status =rte_lpm_delete (lpm, ip, depth); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (!lpm->tbl24[ip>>8 ].valid); + + status =rte_lpm_lookup (lpm, ip, &next_hop_return); +TEST_LPM_ASSERT (status !=0 ); + + status =rte_lpm_add (lpm, ip, depth, next_hop); +TEST_LPM_ASSERT (status !=0 ); + +/* Reader quiescent */ +rte_rcu_qsbr_quiescent (qsv,0 ); + + status =rte_lpm_add (lpm, ip, depth, next_hop); +TEST_LPM_ASSERT (status ==0 ); + +rte_rcu_qsbr_thread_offline (qsv,0 ); + status =rte_rcu_qsbr_thread_unregister (qsv,0 ); +TEST_LPM_ASSERT (status ==0 ); + + status =rte_lpm_lookup (lpm, ip, &next_hop_return); +TEST_LPM_ASSERT (status ==0 ); +TEST_LPM_ASSERT (next_hop_return == next_hop); + +rte_lpm_free (lpm); +rte_free (qsv); + +return PASS ; +} + +static struct rte_lpm *g_lpm; +static struct rte_rcu_qsbr *g_v; +static uint32_t g_ip =RTE_IPV4 (192 ,0 ,2 ,100 ); +static volatile uint8_t writer_done; +/* Report quiescent state interval every 1024 lookups. Larger critical +* sections in reader will result in writer polling multiple times. +*/ +#define QSBR_REPORTING_INTERVAL 1024 +#define WRITER_ITERATIONS 512 + +/* +* Reader thread using rte_lpm data structure with RCU. +*/ +static int +test_lpm_rcu_qsbr_reader (void *arg) +{ +int i; +uint32_t next_hop_return =0 ; + +RTE_SET_USED (arg); +/* Register this thread to report quiescent state */ +rte_rcu_qsbr_thread_register (g_v,0 ); +rte_rcu_qsbr_thread_online (g_v,0 ); + +do { +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) +rte_lpm_lookup (g_lpm, g_ip, &next_hop_return); + +/* Update quiescent state */ +rte_rcu_qsbr_quiescent (g_v,0 ); + }while (!writer_done); + +rte_rcu_qsbr_thread_offline (g_v,0 ); +rte_rcu_qsbr_thread_unregister (g_v,0 ); + +return 0 ; +} + +/* +* rte_lpm_rcu_qsbr_add sync mode functional test. +* 1 Reader and 1 writer. They cannot be in the same thread in this test. +* - Create LPM which supports 1 tbl8 group at max +* - Add RCU QSBR variable with sync mode to LPM +* - Register a reader thread. Reader keeps looking up a specific rule. +* - Writer keeps adding and deleting a specific rule with depth=28 (> 24) +*/ +int32_t +test21 (void ) +{ +struct rte_lpm_config config; +size_t sz; +int32_t status; +uint32_t i, next_hop; +uint8_t depth; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + +if (rte_lcore_count () <2 ) { +printf ("Not enough cores for %s, expecting at least 2\n" , + __func__); +return TEST_SKIPPED ; + } + + config.max_rules =MAX_RULES ; + config.number_tbl8s =1 ; + config.flags =0 ; + + g_lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (g_lpm !=NULL ); + +/* Create RCU QSBR variable */ + sz =rte_rcu_qsbr_get_memsize (1 ); + g_v = (struct rte_rcu_qsbr *)rte_zmalloc_socket (NULL , sz, +RTE_CACHE_LINE_SIZE ,SOCKET_ID_ANY ); +TEST_LPM_ASSERT (g_v !=NULL ); + + status =rte_rcu_qsbr_init (g_v,1 ); +TEST_LPM_ASSERT (status ==0 ); + + rcu_cfg.v = g_v; + rcu_cfg.mode =RTE_LPM_QSBR_MODE_SYNC ; +/* Attach RCU QSBR to LPM table */ + status =rte_lpm_rcu_qsbr_add (g_lpm, &rcu_cfg,NULL ); +TEST_LPM_ASSERT (status ==0 ); + + writer_done =0 ; +/* Launch reader thread */ +rte_eal_remote_launch (test_lpm_rcu_qsbr_reader,NULL , +rte_get_next_lcore (-1 ,1 ,0 )); + + depth =28 ; + next_hop =1 ; + status =rte_lpm_add (g_lpm, g_ip, depth, next_hop); +if (status !=0 ) { +printf ("%s: Failed to add rule\n" , __func__); + goto error; + } + +/* Writer update */ +for (i =0 ; i <WRITER_ITERATIONS ; i++) { + status =rte_lpm_delete (g_lpm, g_ip, depth); +if (status !=0 ) { +printf ("%s: Failed to delete rule at iteration %d\n" , + __func__, i); + goto error; + } + + status =rte_lpm_add (g_lpm, g_ip, depth, next_hop); +if (status !=0 ) { +printf ("%s: Failed to add rule at iteration %d\n" , + __func__, i); + goto error; + } + } + +error: + writer_done =1 ; +/* Wait until reader exited. */ +rte_eal_mp_wait_lcore (); + +rte_lpm_free (g_lpm); +rte_free (g_v); + +return (status ==0 ) ?PASS :-1 ; +} +/* * Do all unit tests. */
Signature · 1 line
2.17.1
PATCH v10 3/3 test/lpm: add RCU integration performance tests
In reply to Ruifeng WangFrom: Honnappa Nagarahalli <[email protected]>
Add performance tests for RCU integration. The performance difference with and without RCU integration is very small (~1% to ~2%) on both Arm and x86 platforms.
--- app/test/test_lpm_perf.c | 492 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 489 insertions(+), 3 deletions(-)
app/test/test_lpm_perf.c +489 -3
@@ -1,5 +1,6 @@/* SPDX-License-Identifier: BSD-3-Clause * Copyright(c) 2010-2014 Intel Corporation +* Copyright(c) 2020 Arm Limited */ #include <stdio.h>
@@ -10,12 +11,27 @@#include <rte_cycles.h> #include <rte_random.h> #include <rte_branch_prediction.h> +#include <rte_malloc.h> #include <rte_ip.h> #include <rte_lpm.h> #include "test.h" #include "test_xmmt_ops.h" +struct rte_lpm *lpm; +static struct rte_rcu_qsbr *rv; +static volatile uint8_t writer_done; +static volatile uint32_t thr_id; +static uint64_t gwrite_cycles; +static uint64_t gwrites; +/* LPM APIs are not thread safe, use mutex to provide thread safety */ +static pthread_mutex_t lpm_mutex =PTHREAD_MUTEX_INITIALIZER ; + +/* Report quiescent state interval every 1024 lookups. Larger critical +* sections in reader will result in writer polling multiple times. +*/ +#define QSBR_REPORTING_INTERVAL 1024 +#define TEST_LPM_ASSERT (cond) do { \ if (!(cond)) { \ printf("Error at line %d: \n", __LINE__); \
@@ -24,6 +40,7 @@ } while(0)#define ITERATIONS (1 << 10) +#define RCU_ITERATIONS 10#define BATCH_SIZE (1 << 12)#define BULK_SIZE 32
@@ -35,9 +52,13 @@ struct route_rule { };static struct route_rule large_route_table[MAX_RULE_NUM ]; +/* Route table for routes with depth > 24 */ +struct route_rule large_ldepth_route_table[MAX_RULE_NUM ];static uint32_t num_route_entries; +static uint32_t num_ldepth_route_entries;#define NUM_ROUTE_ENTRIES num_route_entries +#define NUM_LDEPTH_ROUTE_ENTRIES num_ldepth_route_entriesenum {IP_CLASS_A ,
@@ -191,7 +212,7 @@ static void generate_random_rule_prefix(uint32_t ip_class, uint8_t depth)uint32_t ip_head_mask;uint32_t rule_num;uint32_t k; -struct route_rule *ptr_rule; +struct route_rule *ptr_rule, *ptr_ldepth_rule;if (ip_class ==IP_CLASS_A ) {/* IP Address class A */ fixed_bit_num =IP_HEAD_BIT_NUM_A ;
@@ -236,10 +257,20 @@ static void generate_random_rule_prefix(uint32_t ip_class, uint8_t depth)*/ start =lrand48 () & mask; ptr_rule = &large_route_table[num_route_entries]; + ptr_ldepth_rule = &large_ldepth_route_table[num_ldepth_route_entries];for (k =0 ; k < rule_num; k++) { ptr_rule->ip = (start << (RTE_LPM_MAX_DEPTH - depth)) | ip_head_mask; ptr_rule->depth = depth; +/* If the depth of the route is more than 24, store it +* in another table as well. +*/ +if (depth >24 ) { + ptr_ldepth_rule->ip = ptr_rule->ip; + ptr_ldepth_rule->depth = ptr_rule->depth; + ptr_ldepth_rule++; + num_ldepth_route_entries++; + } ptr_rule++; start = (start + step) & mask; }
@@ -273,6 +304,7 @@ static void generate_large_route_rule_table(void)uint8_t depth; num_route_entries =0 ; + num_ldepth_route_entries =0 ;memset (large_route_table,0 ,sizeof (large_route_table));for (ip_class =IP_CLASS_A ; ip_class <=IP_CLASS_C ; ip_class++) {
@@ -316,10 +348,460 @@ print_route_distribution(const struct route_rule *table, uint32_t n)printf ("\n" ); } +/* Check condition and return an error if true. */ +static uint16_t enabled_core_ids[RTE_MAX_LCORE ]; +static unsigned int num_cores; + +/* Simple way to allocate thread ids in 0 to RTE_MAX_LCORE space */ +static inline uint32_t +alloc_thread_id (void ) +{ +uint32_t tmp_thr_id; + + tmp_thr_id =__atomic_fetch_add (&thr_id,1 , __ATOMIC_RELAXED); +if (tmp_thr_id >=RTE_MAX_LCORE ) +printf ("Invalid thread id %u\n" , tmp_thr_id); + +return tmp_thr_id; +} + +/* +* Reader thread using rte_lpm data structure without RCU. +*/ +static int +test_lpm_reader (void *arg) +{ +int i; +uint32_t ip_batch[QSBR_REPORTING_INTERVAL ]; +uint32_t next_hop_return =0 ; + +RTE_SET_USED (arg); +do { +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) + ip_batch[i] =rte_rand (); + +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) +rte_lpm_lookup (lpm, ip_batch[i], &next_hop_return); + + }while (!writer_done); + +return 0 ; +} + +/* +* Reader thread using rte_lpm data structure with RCU. +*/ +static int +test_lpm_rcu_qsbr_reader (void *arg) +{ +int i; +uint32_t thread_id =alloc_thread_id (); +uint32_t ip_batch[QSBR_REPORTING_INTERVAL ]; +uint32_t next_hop_return =0 ; + +RTE_SET_USED (arg); +/* Register this thread to report quiescent state */ +rte_rcu_qsbr_thread_register (rv, thread_id); +rte_rcu_qsbr_thread_online (rv, thread_id); + +do { +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) + ip_batch[i] =rte_rand (); + +for (i =0 ; i <QSBR_REPORTING_INTERVAL ; i++) +rte_lpm_lookup (lpm, ip_batch[i], &next_hop_return); + +/* Update quiescent state */ +rte_rcu_qsbr_quiescent (rv, thread_id); + }while (!writer_done); + +rte_rcu_qsbr_thread_offline (rv, thread_id); +rte_rcu_qsbr_thread_unregister (rv, thread_id); + +return 0 ; +} + +/* +* Writer thread using rte_lpm data structure with RCU. +*/ +static int +test_lpm_rcu_qsbr_writer (void *arg) +{ +unsigned int i, j, si, ei; +uint64_t begin, total_cycles; +uint8_t core_id = (uint8_t )((uintptr_t )arg); +uint32_t next_hop_add =0xAA ; + +RTE_SET_USED (arg); +/* 2 writer threads are used */ +if (core_id %2 ==0 ) { + si =0 ; + ei =NUM_LDEPTH_ROUTE_ENTRIES /2 ; + }else { + si =NUM_LDEPTH_ROUTE_ENTRIES /2 ; + ei =NUM_LDEPTH_ROUTE_ENTRIES ; + } + +/* Measure add/delete. */ + begin =rte_rdtsc_precise (); +for (i =0 ; i <RCU_ITERATIONS ; i++) { +/* Add all the entries */ +for (j = si; j < ei; j++) { +pthread_mutex_lock (&lpm_mutex); +if (rte_lpm_add (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth, + next_hop_add) !=0 ) { +printf ("Failed to add iteration %d, route# %d\n" , + i, j); + } +pthread_mutex_unlock (&lpm_mutex); + } + +/* Delete all the entries */ +for (j = si; j < ei; j++) { +pthread_mutex_lock (&lpm_mutex); +if (rte_lpm_delete (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth) !=0 ) { +printf ("Failed to delete iteration %d, route# %d\n" , + i, j); + } +pthread_mutex_unlock (&lpm_mutex); + } + } + + total_cycles =rte_rdtsc_precise () - begin; + +__atomic_fetch_add (&gwrite_cycles, total_cycles, __ATOMIC_RELAXED); +__atomic_fetch_add (&gwrites, +2 *NUM_LDEPTH_ROUTE_ENTRIES *RCU_ITERATIONS , + __ATOMIC_RELAXED); + +return 0 ; +} + +/* +* Functional test: +* 2 writers, rest are readers +*/ +static int +test_lpm_rcu_perf_multi_writer (void ) +{ +struct rte_lpm_config config; +size_t sz; +unsigned int i; +uint16_t core_id; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + +if (rte_lcore_count () <3 ) { +printf ("Not enough cores for lpm_rcu_perf_autotest, expecting at least 3\n" ); +return TEST_SKIPPED ; + } + + num_cores =0 ; +RTE_LCORE_FOREACH_SLAVE (core_id) { + enabled_core_ids[num_cores] = core_id; + num_cores++; + } + +printf ("\nPerf test: 2 writers, %d readers, RCU integration enabled\n" , + num_cores -2 ); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Init RCU variable */ + sz =rte_rcu_qsbr_get_memsize (num_cores); + rv = (struct rte_rcu_qsbr *)rte_zmalloc ("rcu0" , sz, +RTE_CACHE_LINE_SIZE ); +rte_rcu_qsbr_init (rv, num_cores); + + rcu_cfg.v = rv; +/* Assign the RCU variable to LPM */ +if (rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ) !=0 ) { +printf ("RCU variable assignment failed\n" ); + goto error; + } + + writer_done =0 ; +__atomic_store_n (&gwrite_cycles,0 , __ATOMIC_RELAXED); +__atomic_store_n (&gwrites,0 , __ATOMIC_RELAXED); + +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =2 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_reader,NULL , + enabled_core_ids[i]); + +/* Launch writer threads */ +for (i =0 ; i <2 ; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_writer, + (void *)(uintptr_t )i, + enabled_core_ids[i]); + +/* Wait for writer threads */ +for (i =0 ; i <2 ; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +printf ("Total LPM Adds: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %" PRIu64" cycles\n" , +__atomic_load_n (&gwrite_cycles, __ATOMIC_RELAXED) / +__atomic_load_n (&gwrites, __ATOMIC_RELAXED) + ); + +/* Wait and check return value from reader threads */ + writer_done =1 ; +for (i =2 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +rte_lpm_free (lpm); +rte_free (rv); + lpm =NULL ; + rv =NULL ; + +/* Test without RCU integration */ +printf ("\nPerf test: 2 writers, %d readers, RCU integration disabled\n" , + num_cores -2 ); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + + writer_done =0 ; +__atomic_store_n (&gwrite_cycles,0 , __ATOMIC_RELAXED); +__atomic_store_n (&gwrites,0 , __ATOMIC_RELAXED); +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =2 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_reader,NULL , + enabled_core_ids[i]); + +/* Launch writer threads */ +for (i =0 ; i <2 ; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_writer, + (void *)(uintptr_t )i, + enabled_core_ids[i]); + +/* Wait for writer threads */ +for (i =0 ; i <2 ; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +printf ("Total LPM Adds: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +2 *ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %" PRIu64" cycles\n" , +__atomic_load_n (&gwrite_cycles, __ATOMIC_RELAXED) / +__atomic_load_n (&gwrites, __ATOMIC_RELAXED) + ); + + writer_done =1 ; +/* Wait and check return value from reader threads */ +for (i =2 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +rte_lpm_free (lpm); + +return 0 ; + +error: + writer_done =1 ; +/* Wait until all readers have exited */ +rte_eal_mp_wait_lcore (); + +rte_lpm_free (lpm); +rte_free (rv); + +return -1 ; +} + +/* +* Functional test: +* Single writer, rest are readers +*/ +static int +test_lpm_rcu_perf (void ) +{ +struct rte_lpm_config config; +uint64_t begin, total_cycles; +size_t sz; +unsigned int i, j; +uint16_t core_id; +uint32_t next_hop_add =0xAA ; +struct rte_lpm_rcu_config rcu_cfg = {0 }; + +if (rte_lcore_count () <2 ) { +printf ("Not enough cores for lpm_rcu_perf_autotest, expecting at least 2\n" ); +return TEST_SKIPPED ; + } + + num_cores =0 ; +RTE_LCORE_FOREACH_SLAVE (core_id) { + enabled_core_ids[num_cores] = core_id; + num_cores++; + } + +printf ("\nPerf test: 1 writer, %d readers, RCU integration enabled\n" , + num_cores); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + +/* Init RCU variable */ + sz =rte_rcu_qsbr_get_memsize (num_cores); + rv = (struct rte_rcu_qsbr *)rte_zmalloc ("rcu0" , sz, +RTE_CACHE_LINE_SIZE ); +rte_rcu_qsbr_init (rv, num_cores); + + rcu_cfg.v = rv; +/* Assign the RCU variable to LPM */ +if (rte_lpm_rcu_qsbr_add (lpm, &rcu_cfg,NULL ) !=0 ) { +printf ("RCU variable assignment failed\n" ); + goto error; + } + + writer_done =0 ; +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =0 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_rcu_qsbr_reader,NULL , + enabled_core_ids[i]); + +/* Measure add/delete. */ + begin =rte_rdtsc_precise (); +for (i =0 ; i <RCU_ITERATIONS ; i++) { +/* Add all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_add (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth, + next_hop_add) !=0 ) { +printf ("Failed to add iteration %d, route# %d\n" , + i, j); + goto error; + } + +/* Delete all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_delete (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth) !=0 ) { +printf ("Failed to delete iteration %d, route# %d\n" , + i, j); + goto error; + } + } + total_cycles =rte_rdtsc_precise () - begin; + +printf ("Total LPM Adds: %d\n" ,ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %g cycles\n" , + (double )total_cycles / (NUM_LDEPTH_ROUTE_ENTRIES *ITERATIONS )); + + writer_done =1 ; +/* Wait and check return value from reader threads */ +for (i =0 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) + goto error; + +rte_lpm_free (lpm); +rte_free (rv); + lpm =NULL ; + rv =NULL ; + +/* Test without RCU integration */ +printf ("\nPerf test: 1 writer, %d readers, RCU integration disabled\n" , + num_cores); + +/* Create LPM table */ + config.max_rules =NUM_LDEPTH_ROUTE_ENTRIES ; + config.number_tbl8s =NUM_LDEPTH_ROUTE_ENTRIES ; + config.flags =0 ; + lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config); +TEST_LPM_ASSERT (lpm !=NULL ); + + writer_done =0 ; +__atomic_store_n (&thr_id,0 , __ATOMIC_SEQ_CST); + +/* Launch reader threads */ +for (i =0 ; i < num_cores; i++) +rte_eal_remote_launch (test_lpm_reader,NULL , + enabled_core_ids[i]); + +/* Measure add/delete. */ + begin =rte_rdtsc_precise (); +for (i =0 ; i <RCU_ITERATIONS ; i++) { +/* Add all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_add (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth, + next_hop_add) !=0 ) { +printf ("Failed to add iteration %d, route# %d\n" , + i, j); + goto error; + } + +/* Delete all the entries */ +for (j =0 ; j <NUM_LDEPTH_ROUTE_ENTRIES ; j++) +if (rte_lpm_delete (lpm, large_ldepth_route_table[j].ip, + large_ldepth_route_table[j].depth) !=0 ) { +printf ("Failed to delete iteration %d, route# %d\n" , + i, j); + goto error; + } + } + total_cycles =rte_rdtsc_precise () - begin; + +printf ("Total LPM Adds: %d\n" ,ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Total LPM Deletes: %d\n" , +ITERATIONS *NUM_LDEPTH_ROUTE_ENTRIES ); +printf ("Average LPM Add/Del: %g cycles\n" , + (double )total_cycles / (NUM_LDEPTH_ROUTE_ENTRIES *ITERATIONS )); + + writer_done =1 ; +/* Wait and check return value from reader threads */ +for (i =0 ; i < num_cores; i++) +if (rte_eal_wait_lcore (enabled_core_ids[i]) <0 ) +printf ("Warning: lcore %u not finished.\n" , + enabled_core_ids[i]); + +rte_lpm_free (lpm); + +return 0 ; + +error: + writer_done =1 ; +/* Wait until all readers have exited */ +rte_eal_mp_wait_lcore (); + +rte_lpm_free (lpm); +rte_free (rv); + +return -1 ; +} +static int test_lpm_perf (void ) { -struct rte_lpm *lpm =NULL ;struct rte_lpm_config config; config.max_rules =2000000 ;
@@ -343,7 +825,7 @@ test_lpm_perf(void) lpm =rte_lpm_create (__func__,SOCKET_ID_ANY , &config);TEST_LPM_ASSERT (lpm !=NULL ); -/* Measue add. */ +/* Measure add. */ begin =rte_rdtsc ();for (i =0 ; i <NUM_ROUTE_ENTRIES ; i++) {
@@ -478,6 +960,10 @@ test_lpm_perf(void)rte_lpm_delete_all (lpm);rte_lpm_free (lpm); +test_lpm_rcu_perf (); + +test_lpm_rcu_perf_multi_writer (); +return 0 ; }
Signature · 1 line
2.17.1
Re: [dpdk-dev] [PATCH v10 3/3] test/lpm: add RCU integration performance tests
The ci/checkpatch warning is a false positive.
Quoted 25 lines
-----Original Message-----
From: dev <[email protected]> On Behalf Of Ruifeng Wang
Sent: Friday, July 10, 2020 10:22 AM
To: Bruce Richardson <[email protected]>; Vladimir Medvedkin <[email protected]>
Cc: [email protected]; [email protected]; [email protected]; Honnappa Nagarahalli <[email protected]>; nd <[email protected]>
Subject: [dpdk-dev] [PATCH v10 3/3] test/lpm: add RCU integration performance testsFrom: Honnappa Nagarahalli <[email protected]>
Add performance tests for RCU integration. The performance difference with and without RCU integration is very small (~1% to ~2%) on both Arm and x86 platforms.
Signed-off-by Honnappa Nagarahalli <[email protected]>Reviewed-by Gavin Hu <[email protected]>Reviewed-by Ruifeng Wang <[email protected]>--- app/test/test_lpm_perf.c | 492 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 489 insertions(+), 3 deletions(-)
Quoted 7 lines · Ruifeng Wang
This patchset integrates RCU QSBR support with LPM library.
Resource reclaimation implementation was splitted from the original series, and has already been part of RCU library. Rework the series to base LPM integration on RCU reclaimation APIs.
Quoted 6 lines
New API
rte_lpm_rcu_qsbr_addis introduced for application to register a RCU variable that LPM library will use. This provides user the handle to enable RCU that integrated in LPM library.Functional tests and performance tests are added to cover the integration with RCU.
Series applied.
A comment though.
I am surprised to see the defer queue is still exposed out of lpm.
+int rte_lpm_rcu_qsbr_add(struct rte_lpm *lpm, struct rte_lpm_rcu_config *cfg,
+ struct rte_rcu_qsbr_dq **dq);
If this is intended, we will need unit tests for this parameter as I could see none.
Else, it can be removed.
Please send a followup patch for rc2.
Thanks.
Signature · 1 line
David Marchand
Quoted 33 lines
-----Original Message-----
From: David Marchand <[email protected]>
Sent: Friday, July 10, 2020 8:21 PM
To: Ruifeng Wang <[email protected]>
Cc: dev <[email protected]>; Ray Kinsella <[email protected]>; Ananyev, Konstantin <[email protected]>; Honnappa Nagarahalli <[email protected]>; nd <[email protected]>; Vladimir Medvedkin <[email protected]>
Subject: Re: [dpdk-dev] [PATCH v10 0/3] RCU integration with LPM libraryQuoted 7 lines · Ruifeng Wang
This patchset integrates RCU QSBR support with LPM library.
Resource reclaimation implementation was splitted from the original series, and has already been part of RCU library. Rework the series to base LPM integration on RCU reclaimation APIs.
Quoted 6 lines
New API
rte_lpm_rcu_qsbr_addis introduced for application to register a RCU variable that LPM library will use. This provides user the handle to enable RCU that integrated in LPM library.Functional tests and performance tests are added to cover the integration with RCU.
Series applied.
A comment though.
I am surprised to see the defer queue is still exposed out of lpm.
Quoted 8 lines
+int rte_lpm_rcu_qsbr_add(struct
rte_lpm*lpm, structrte_lpm_rcu_config*cfg,
+ structrte_rcu_qsbr_dq**dq);If this is intended, we will need unit tests for this parameter as I could see none.
Else, it can be removed.
Looking at comments in v4, there was consensus that exposure of defer queue is not needed. Enough flexibility has been provided to configure defer queue. I should have removed this prarameter.
Quoted 1 line
Please send a followup patch for rc2.
Will send out followup patch.
Thanks.
/Ruifeng
Quoted 5 lines
Thanks.
--
David Marchand