X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest%2Ftest_lpm.c;h=258b2f67c7f28718ac543455659855ed587028b6;hb=32440cdf2af9ad38fd32a533f51a32da92345007;hp=ffed766401422aba4739df026044a59edef6c0e0;hpb=21a7f4e2646e1cb6b0dbd6643e5d64f72355af58;p=dpdk.git diff --git a/app/test/test_lpm.c b/app/test/test_lpm.c index ffed766401..258b2f67c7 100644 --- a/app/test/test_lpm.c +++ b/app/test/test_lpm.c @@ -1,56 +1,17 @@ -/*- - * BSD LICENSE - * - * Copyright(c) 2010-2014 Intel Corporation. All rights reserved. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in - * the documentation and/or other materials provided with the - * distribution. - * * Neither the name of Intel Corporation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2010-2014 Intel Corporation */ #include #include #include -#include -#include - -#include -#include -#include -#include -#include + #include -#include +#include +#include #include "test.h" - -#ifdef RTE_LIBRTE_LPM - -#include "rte_lpm.h" -#include "test_lpm_routes.h" +#include "test_xmmt_ops.h" #define TEST_LPM_ASSERT(cond) do { \ if (!(cond)) { \ @@ -59,7 +20,7 @@ } \ } while(0) -typedef int32_t (* rte_lpm_test)(void); +typedef int32_t (*rte_lpm_test)(void); static int32_t test0(void); static int32_t test1(void); @@ -79,7 +40,10 @@ static int32_t test14(void); static int32_t test15(void); static int32_t test16(void); static int32_t test17(void); -static int32_t perf_test(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 */ @@ -101,12 +65,15 @@ rte_lpm_test tests[] = { test15, test16, test17, - perf_test, + test18, + test19, + test20, + test21 }; -#define NUM_LPM_TESTS (sizeof(tests)/sizeof(tests[0])) #define MAX_DEPTH 32 #define MAX_RULES 256 +#define NUMBER_TBL8S 256 #define PASS 0 /* @@ -117,18 +84,25 @@ int32_t test0(void) { struct rte_lpm *lpm = NULL; + struct rte_lpm_config config; + + config.max_rules = MAX_RULES; + config.number_tbl8s = NUMBER_TBL8S; + config.flags = 0; /* rte_lpm_create: lpm name == NULL */ - lpm = rte_lpm_create(NULL, SOCKET_ID_ANY, MAX_RULES, 0); + lpm = rte_lpm_create(NULL, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm == NULL); /* rte_lpm_create: max_rules = 0 */ /* Note: __func__ inserts the function name, in this case "test0". */ - lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, 0, 0); + config.max_rules = 0; + lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm == NULL); /* socket_id < -1 is invalid */ - lpm = rte_lpm_create(__func__, -2, MAX_RULES, 0); + config.max_rules = MAX_RULES; + lpm = rte_lpm_create(__func__, -2, &config); TEST_LPM_ASSERT(lpm == NULL); return PASS; @@ -142,11 +116,16 @@ int32_t test1(void) { struct rte_lpm *lpm = NULL; + struct rte_lpm_config config; + + config.number_tbl8s = NUMBER_TBL8S; + config.flags = 0; int32_t i; /* rte_lpm_free: Free NULL */ for (i = 0; i < 100; i++) { - lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES - i, 0); + config.max_rules = MAX_RULES - i; + lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); rte_lpm_free(lpm); @@ -166,8 +145,13 @@ int32_t test2(void) { struct rte_lpm *lpm = NULL; + struct rte_lpm_config config; - lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES, RTE_LPM_HEAP); + 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); rte_lpm_free(lpm); @@ -182,8 +166,13 @@ int32_t test3(void) { struct rte_lpm *lpm = NULL; - uint32_t ip = IPv4(0, 0, 0, 0); - uint8_t depth = 24, next_hop = 100; + struct rte_lpm_config config; + + config.max_rules = MAX_RULES; + config.number_tbl8s = NUMBER_TBL8S; + config.flags = 0; + uint32_t ip = RTE_IPV4(0, 0, 0, 0), next_hop = 100; + uint8_t depth = 24; int32_t status = 0; /* rte_lpm_add: lpm == NULL */ @@ -191,7 +180,7 @@ test3(void) TEST_LPM_ASSERT(status < 0); /*Create vaild lpm to use in rest of test. */ - lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES, 0); + lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); /* rte_lpm_add: depth < 1 */ @@ -215,7 +204,12 @@ int32_t test4(void) { struct rte_lpm *lpm = NULL; - uint32_t ip = IPv4(0, 0, 0, 0); + struct rte_lpm_config config; + + config.max_rules = MAX_RULES; + config.number_tbl8s = NUMBER_TBL8S; + config.flags = 0; + uint32_t ip = RTE_IPV4(0, 0, 0, 0); uint8_t depth = 24; int32_t status = 0; @@ -224,7 +218,7 @@ test4(void) TEST_LPM_ASSERT(status < 0); /*Create vaild lpm to use in rest of test. */ - lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES, 0); + lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); /* rte_lpm_delete: depth < 1 */ @@ -249,8 +243,12 @@ test5(void) { #if defined(RTE_LIBRTE_LPM_DEBUG) struct rte_lpm *lpm = NULL; - uint32_t ip = IPv4(0, 0, 0, 0); - uint8_t next_hop_return = 0; + struct rte_lpm_config config; + + config.max_rules = MAX_RULES; + config.number_tbl8s = NUMBER_TBL8S; + config.flags = 0; + uint32_t ip = RTE_IPV4(0, 0, 0, 0), next_hop_return = 0; int32_t status = 0; /* rte_lpm_lookup: lpm == NULL */ @@ -258,7 +256,7 @@ test5(void) TEST_LPM_ASSERT(status < 0); /*Create vaild lpm to use in rest of test. */ - lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES, 0); + lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); /* rte_lpm_lookup: depth < 1 */ @@ -279,11 +277,16 @@ int32_t test6(void) { struct rte_lpm *lpm = NULL; - uint32_t ip = IPv4(0, 0, 0, 0); - uint8_t depth = 24, next_hop_add = 100, next_hop_return = 0; + struct rte_lpm_config config; + + config.max_rules = MAX_RULES; + config.number_tbl8s = NUMBER_TBL8S; + config.flags = 0; + uint32_t ip = RTE_IPV4(0, 0, 0, 0), next_hop_add = 100, next_hop_return = 0; + uint8_t depth = 24; int32_t status = 0; - lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES, 0); + lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); status = rte_lpm_add(lpm, ip, depth, next_hop_add); @@ -310,12 +313,19 @@ test6(void) int32_t test7(void) { + xmm_t ipx4; + uint32_t hop[4]; struct rte_lpm *lpm = NULL; - uint32_t ip = IPv4(0, 0, 0, 0); - uint8_t depth = 32, next_hop_add = 100, next_hop_return = 0; + struct rte_lpm_config config; + + config.max_rules = MAX_RULES; + config.number_tbl8s = NUMBER_TBL8S; + config.flags = 0; + uint32_t ip = RTE_IPV4(0, 0, 0, 0), next_hop_add = 100, next_hop_return = 0; + uint8_t depth = 32; int32_t status = 0; - lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES, 0); + lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); status = rte_lpm_add(lpm, ip, depth, next_hop_add); @@ -324,6 +334,13 @@ test7(void) status = rte_lpm_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); + ipx4 = vect_set_epi32(ip, ip + 0x100, ip - 0x100, ip); + rte_lpm_lookupx4(lpm, ipx4, hop, UINT32_MAX); + TEST_LPM_ASSERT(hop[0] == next_hop_add); + TEST_LPM_ASSERT(hop[1] == UINT32_MAX); + TEST_LPM_ASSERT(hop[2] == UINT32_MAX); + TEST_LPM_ASSERT(hop[3] == next_hop_add); + status = rte_lpm_delete(lpm, ip, depth); TEST_LPM_ASSERT(status == 0); @@ -347,12 +364,20 @@ test7(void) int32_t test8(void) { + xmm_t ipx4; + uint32_t hop[4]; struct rte_lpm *lpm = NULL; - uint32_t ip1 = IPv4(127, 255, 255, 255), ip2 = IPv4(128, 0, 0, 0); - uint8_t depth, next_hop_add, next_hop_return; + struct rte_lpm_config config; + + config.max_rules = MAX_RULES; + config.number_tbl8s = NUMBER_TBL8S; + config.flags = 0; + uint32_t ip1 = RTE_IPV4(127, 255, 255, 255), ip2 = RTE_IPV4(128, 0, 0, 0); + uint32_t next_hop_add, next_hop_return; + uint8_t depth; int32_t status = 0; - lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES, 0); + lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); /* Loop with rte_lpm_add. */ @@ -370,6 +395,13 @@ test8(void) status = rte_lpm_lookup(lpm, ip2, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); + + ipx4 = vect_set_epi32(ip2, ip1, ip2, ip1); + rte_lpm_lookupx4(lpm, ipx4, hop, UINT32_MAX); + TEST_LPM_ASSERT(hop[0] == UINT32_MAX); + TEST_LPM_ASSERT(hop[1] == next_hop_add); + TEST_LPM_ASSERT(hop[2] == UINT32_MAX); + TEST_LPM_ASSERT(hop[3] == next_hop_add); } /* Loop with rte_lpm_delete. */ @@ -384,13 +416,24 @@ test8(void) if (depth != 1) { TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); - } - else { + } else { TEST_LPM_ASSERT(status == -ENOENT); } status = rte_lpm_lookup(lpm, ip1, &next_hop_return); TEST_LPM_ASSERT(status == -ENOENT); + + ipx4 = vect_set_epi32(ip1, ip1, ip2, ip2); + rte_lpm_lookupx4(lpm, ipx4, hop, UINT32_MAX); + if (depth != 1) { + TEST_LPM_ASSERT(hop[0] == next_hop_add); + TEST_LPM_ASSERT(hop[1] == next_hop_add); + } else { + TEST_LPM_ASSERT(hop[0] == UINT32_MAX); + TEST_LPM_ASSERT(hop[1] == UINT32_MAX); + } + TEST_LPM_ASSERT(hop[2] == UINT32_MAX); + TEST_LPM_ASSERT(hop[3] == UINT32_MAX); } rte_lpm_free(lpm); @@ -409,17 +452,22 @@ int32_t test9(void) { struct rte_lpm *lpm = NULL; + struct rte_lpm_config config; + + config.max_rules = MAX_RULES; + config.number_tbl8s = NUMBER_TBL8S; + config.flags = 0; uint32_t ip, ip_1, ip_2; - uint8_t depth, depth_1, depth_2, next_hop_add, next_hop_add_1, - next_hop_add_2, next_hop_return; + uint8_t depth, depth_1, depth_2; + uint32_t next_hop_add, next_hop_add_1, next_hop_add_2, next_hop_return; int32_t status = 0; /* Add & lookup to hit invalid TBL24 entry */ - ip = IPv4(128, 0, 0, 0); + ip = RTE_IPV4(128, 0, 0, 0); depth = 24; next_hop_add = 100; - lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES, 0); + lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); status = rte_lpm_add(lpm, ip, depth, next_hop_add); @@ -437,7 +485,7 @@ test9(void) rte_lpm_delete_all(lpm); /* Add & lookup to hit valid TBL24 entry not extended */ - ip = IPv4(128, 0, 0, 0); + ip = RTE_IPV4(128, 0, 0, 0); depth = 23; next_hop_add = 100; @@ -473,7 +521,7 @@ test9(void) /* Add & lookup to hit valid extended TBL24 entry with invalid TBL8 * entry */ - ip = IPv4(128, 0, 0, 0); + ip = RTE_IPV4(128, 0, 0, 0); depth = 32; next_hop_add = 100; @@ -483,7 +531,7 @@ test9(void) status = rte_lpm_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); - ip = IPv4(128, 0, 0, 5); + ip = RTE_IPV4(128, 0, 0, 5); depth = 32; next_hop_add = 101; @@ -499,7 +547,7 @@ test9(void) status = rte_lpm_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT(status == -ENOENT); - ip = IPv4(128, 0, 0, 0); + ip = RTE_IPV4(128, 0, 0, 0); depth = 32; next_hop_add = 100; @@ -516,11 +564,11 @@ test9(void) /* Add & lookup to hit valid extended TBL24 entry with valid TBL8 * entry */ - ip_1 = IPv4(128, 0, 0, 0); + ip_1 = RTE_IPV4(128, 0, 0, 0); depth_1 = 25; next_hop_add_1 = 101; - ip_2 = IPv4(128, 0, 0, 5); + ip_2 = RTE_IPV4(128, 0, 0, 5); depth_2 = 32; next_hop_add_2 = 102; @@ -573,16 +621,21 @@ test10(void) { struct rte_lpm *lpm = NULL; - uint32_t ip; - uint8_t depth, next_hop_add, next_hop_return; + struct rte_lpm_config config; + + config.max_rules = MAX_RULES; + config.number_tbl8s = NUMBER_TBL8S; + config.flags = 0; + uint32_t ip, next_hop_add, next_hop_return; + uint8_t depth; int32_t status = 0; /* Add rule that covers a TBL24 range previously invalid & lookup * (& delete & lookup) */ - lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES, RTE_LPM_HEAP); + lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); - ip = IPv4(128, 0, 0, 0); + ip = RTE_IPV4(128, 0, 0, 0); depth = 16; next_hop_add = 100; @@ -600,7 +653,7 @@ test10(void) rte_lpm_delete_all(lpm); - ip = IPv4(128, 0, 0, 0); + ip = RTE_IPV4(128, 0, 0, 0); depth = 25; next_hop_add = 100; @@ -618,14 +671,14 @@ test10(void) /* Add rule that extends a TBL24 valid entry & lookup for both rules * (& delete & lookup) */ - ip = IPv4(128, 0, 0, 0); + ip = RTE_IPV4(128, 0, 0, 0); depth = 24; next_hop_add = 100; status = rte_lpm_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); - ip = IPv4(128, 0, 0, 10); + ip = RTE_IPV4(128, 0, 0, 10); depth = 32; next_hop_add = 101; @@ -635,13 +688,13 @@ test10(void) status = rte_lpm_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); - ip = IPv4(128, 0, 0, 0); + ip = RTE_IPV4(128, 0, 0, 0); next_hop_add = 100; status = rte_lpm_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); - ip = IPv4(128, 0, 0, 0); + ip = RTE_IPV4(128, 0, 0, 0); depth = 24; status = rte_lpm_delete(lpm, ip, depth); @@ -650,7 +703,7 @@ test10(void) status = rte_lpm_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT(status == -ENOENT); - ip = IPv4(128, 0, 0, 10); + ip = RTE_IPV4(128, 0, 0, 10); depth = 32; status = rte_lpm_delete(lpm, ip, depth); @@ -664,7 +717,7 @@ test10(void) /* Add rule that updates the next hop in TBL24 & lookup * (& delete & lookup) */ - ip = IPv4(128, 0, 0, 0); + ip = RTE_IPV4(128, 0, 0, 0); depth = 24; next_hop_add = 100; @@ -693,7 +746,7 @@ test10(void) /* Add rule that updates the next hop in TBL8 & lookup * (& delete & lookup) */ - ip = IPv4(128, 0, 0, 0); + ip = RTE_IPV4(128, 0, 0, 0); depth = 32; next_hop_add = 100; @@ -721,7 +774,7 @@ test10(void) /* Delete a rule that is not present in the TBL24 & lookup */ - ip = IPv4(128, 0, 0, 0); + ip = RTE_IPV4(128, 0, 0, 0); depth = 24; status = rte_lpm_delete(lpm, ip, depth); @@ -734,7 +787,7 @@ test10(void) /* Delete a rule that is not present in the TBL8 & lookup */ - ip = IPv4(128, 0, 0, 0); + ip = RTE_IPV4(128, 0, 0, 0); depth = 32; status = rte_lpm_delete(lpm, ip, depth); @@ -759,21 +812,26 @@ test11(void) { struct rte_lpm *lpm = NULL; - uint32_t ip; - uint8_t depth, next_hop_add, next_hop_return; + struct rte_lpm_config config; + + config.max_rules = MAX_RULES; + config.number_tbl8s = NUMBER_TBL8S; + config.flags = 0; + uint32_t ip, next_hop_add, next_hop_return; + uint8_t depth; int32_t status = 0; - lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES, 0); + lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); - ip = IPv4(128, 0, 0, 0); + ip = RTE_IPV4(128, 0, 0, 0); depth = 24; next_hop_add = 100; status = rte_lpm_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); - ip = IPv4(128, 0, 0, 10); + ip = RTE_IPV4(128, 0, 0, 10); depth = 32; next_hop_add = 101; @@ -783,13 +841,13 @@ test11(void) status = rte_lpm_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); - ip = IPv4(128, 0, 0, 0); + ip = RTE_IPV4(128, 0, 0, 0); next_hop_add = 100; status = rte_lpm_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); - ip = IPv4(128, 0, 0, 0); + ip = RTE_IPV4(128, 0, 0, 0); depth = 24; status = rte_lpm_delete(lpm, ip, depth); @@ -798,7 +856,7 @@ test11(void) status = rte_lpm_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT(status == -ENOENT); - ip = IPv4(128, 0, 0, 10); + ip = RTE_IPV4(128, 0, 0, 10); depth = 32; status = rte_lpm_delete(lpm, ip, depth); @@ -822,15 +880,22 @@ test11(void) int32_t test12(void) { + xmm_t ipx4; + uint32_t hop[4]; struct rte_lpm *lpm = NULL; - uint32_t ip, i; - uint8_t depth, next_hop_add, next_hop_return; + struct rte_lpm_config config; + + config.max_rules = MAX_RULES; + config.number_tbl8s = NUMBER_TBL8S; + config.flags = 0; + uint32_t ip, i, next_hop_add, next_hop_return; + uint8_t depth; int32_t status = 0; - lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES, 0); + lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); - ip = IPv4(128, 0, 0, 0); + ip = RTE_IPV4(128, 0, 0, 0); depth = 32; next_hop_add = 100; @@ -842,6 +907,13 @@ test12(void) TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); + ipx4 = vect_set_epi32(ip, ip + 1, ip, ip - 1); + rte_lpm_lookupx4(lpm, ipx4, hop, UINT32_MAX); + TEST_LPM_ASSERT(hop[0] == UINT32_MAX); + TEST_LPM_ASSERT(hop[1] == next_hop_add); + TEST_LPM_ASSERT(hop[2] == UINT32_MAX); + TEST_LPM_ASSERT(hop[3] == next_hop_add); + status = rte_lpm_delete(lpm, ip, depth); TEST_LPM_ASSERT(status == 0); @@ -866,14 +938,19 @@ int32_t test13(void) { struct rte_lpm *lpm = NULL; - uint32_t ip, i; - uint8_t depth, next_hop_add_1, next_hop_add_2, next_hop_return; + struct rte_lpm_config config; + + config.max_rules = MAX_RULES; + config.number_tbl8s = NUMBER_TBL8S; + config.flags = 0; + uint32_t ip, i, next_hop_add_1, next_hop_add_2, next_hop_return; + uint8_t depth; int32_t status = 0; - lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES, 0); + lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); - ip = IPv4(128, 0, 0, 0); + ip = RTE_IPV4(128, 0, 0, 0); depth = 24; next_hop_add_1 = 100; @@ -928,20 +1005,25 @@ test14(void) * that we have enough storage for all rules at that depth*/ struct rte_lpm *lpm = NULL; - uint32_t ip; - uint8_t depth, next_hop_add, next_hop_return; + struct rte_lpm_config config; + + config.max_rules = 256 * 32; + config.number_tbl8s = NUMBER_TBL8S; + config.flags = 0; + uint32_t ip, next_hop_add, next_hop_return; + uint8_t depth; int32_t status = 0; /* Add enough space for 256 rules for every depth */ - lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, 256 * 32, 0); + lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); depth = 32; next_hop_add = 100; - ip = IPv4(0, 0, 0, 0); + ip = RTE_IPV4(0, 0, 0, 0); /* Add 256 rules that require a tbl8 extension */ - for (; ip <= IPv4(0, 0, 255, 0); ip += 256) { + for (; ip <= RTE_IPV4(0, 0, 255, 0); ip += 256) { status = rte_lpm_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); @@ -952,7 +1034,7 @@ test14(void) /* All tbl8 extensions have been used above. Try to add one more and * we get a fail */ - ip = IPv4(1, 0, 0, 0); + ip = RTE_IPV4(1, 0, 0, 0); depth = 32; status = rte_lpm_add(lpm, ip, depth, next_hop_add); @@ -975,9 +1057,14 @@ int32_t test15(void) { struct rte_lpm *lpm = NULL, *result = NULL; + struct rte_lpm_config config; + + config.max_rules = 256 * 32; + config.number_tbl8s = NUMBER_TBL8S; + config.flags = 0; /* Create lpm */ - lpm = rte_lpm_create("lpm_find_existing", SOCKET_ID_ANY, 256 * 32, 0); + lpm = rte_lpm_create("lpm_find_existing", SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); /* Try to find existing lpm */ @@ -1003,21 +1090,25 @@ int32_t test16(void) { uint32_t ip; - struct rte_lpm *lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, - 256 * 32, 0); + struct rte_lpm_config config; + + config.max_rules = 256 * 32; + config.number_tbl8s = NUMBER_TBL8S; + config.flags = 0; + struct rte_lpm *lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config); /* ip loops through all possibilities for top 24 bits of address */ - for (ip = 0; ip < 0xFFFFFF; ip++){ + for (ip = 0; ip < 0xFFFFFF; ip++) { /* add an entry within a different tbl8 each time, since * depth >24 and the top 24 bits are different */ if (rte_lpm_add(lpm, (ip << 8) + 0xF0, 30, 0) < 0) break; } - if (ip != RTE_LPM_TBL8_NUM_GROUPS) { + if (ip != NUMBER_TBL8S) { printf("Error, unexpected failure with filling tbl8 groups\n"); printf("Failed after %u additions, expected after %u\n", - (unsigned)ip, (unsigned)RTE_LPM_TBL8_NUM_GROUPS); + (unsigned)ip, (unsigned)NUMBER_TBL8S); } rte_lpm_free(lpm); @@ -1035,19 +1126,24 @@ int32_t test17(void) { struct rte_lpm *lpm = NULL; - const uint32_t ip_10_32 = IPv4(10, 10, 10, 2); - const uint32_t ip_10_24 = IPv4(10, 10, 10, 0); - const uint32_t ip_20_25 = IPv4(10, 10, 20, 2); + struct rte_lpm_config config; + + config.max_rules = MAX_RULES; + config.number_tbl8s = NUMBER_TBL8S; + config.flags = 0; + const uint32_t ip_10_32 = RTE_IPV4(10, 10, 10, 2); + const uint32_t ip_10_24 = RTE_IPV4(10, 10, 10, 0); + const uint32_t ip_20_25 = RTE_IPV4(10, 10, 20, 2); const uint8_t d_ip_10_32 = 32, d_ip_10_24 = 24, d_ip_20_25 = 25; - const uint8_t next_hop_ip_10_32 = 100, + const uint32_t next_hop_ip_10_32 = 100, next_hop_ip_10_24 = 105, next_hop_ip_20_25 = 111; - uint8_t next_hop_return = 0; + uint32_t next_hop_return = 0; int32_t status = 0; - lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES, 0); + lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); if ((status = rte_lpm_add(lpm, ip_10_32, d_ip_10_32, @@ -1055,7 +1151,7 @@ test17(void) return -1; status = rte_lpm_lookup(lpm, ip_10_32, &next_hop_return); - uint8_t test_hop_10_32 = next_hop_return; + uint32_t test_hop_10_32 = next_hop_return; TEST_LPM_ASSERT(status == 0); TEST_LPM_ASSERT(next_hop_return == next_hop_ip_10_32); @@ -1064,7 +1160,7 @@ test17(void) return -1; status = rte_lpm_lookup(lpm, ip_10_24, &next_hop_return); - uint8_t test_hop_10_24 = next_hop_return; + uint32_t test_hop_10_24 = next_hop_return; TEST_LPM_ASSERT(status == 0); TEST_LPM_ASSERT(next_hop_return == next_hop_ip_10_24); @@ -1073,7 +1169,7 @@ test17(void) return -1; status = rte_lpm_lookup(lpm, ip_20_25, &next_hop_return); - uint8_t test_hop_20_25 = next_hop_return; + uint32_t test_hop_20_25 = next_hop_return; TEST_LPM_ASSERT(status == 0); TEST_LPM_ASSERT(next_hop_return == next_hop_ip_20_25); @@ -1082,7 +1178,7 @@ test17(void) return -1; } - if (test_hop_10_24 == test_hop_20_25){ + if (test_hop_10_24 == test_hop_20_25) { printf("Next hop return equal\n"); return -1; } @@ -1101,177 +1197,377 @@ test17(void) } /* - * Lookup performance test + * Test for recycle of tbl8 + * - step 1: add a rule with depth=28 (> 24) + * - step 2: add a rule with same 24-bit prefix and depth=23 (< 24) + * - step 3: delete the first rule + * - step 4: check tbl8 is freed + * - step 5: add a rule same as the first one (depth=28) + * - step 6: check same tbl8 is allocated + * - step 7: add a rule with same 24-bit prefix and depth=24 + * - step 8: delete the rule (depth=28) added in step 5 + * - step 9: check tbl8 is freed + * - step 10: add a rule with same 24-bit prefix and depth = 28 + * - setp 11: check same tbl8 is allocated again */ +int32_t +test18(void) +{ +#define group_idx next_hop + struct rte_lpm *lpm = NULL; + struct rte_lpm_config config; + uint32_t ip, next_hop; + uint8_t depth; + uint32_t tbl8_group_index; -#define ITERATIONS (1 << 10) -#define BATCH_SIZE (1 << 12) -#define BULK_SIZE 32 + config.max_rules = MAX_RULES; + config.number_tbl8s = NUMBER_TBL8S; + config.flags = 0; -static void -print_route_distribution(const struct route_rule *table, uint32_t n) -{ - unsigned i, j; + lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config); + TEST_LPM_ASSERT(lpm != NULL); - printf("Route distribution per prefix width: \n"); - printf("DEPTH QUANTITY (PERCENT)\n"); - printf("--------------------------- \n"); + ip = RTE_IPV4(192, 168, 100, 100); + depth = 28; + next_hop = 1; + rte_lpm_add(lpm, ip, depth, next_hop); - /* Count depths. */ - for(i = 1; i <= 32; i++) { - unsigned depth_counter = 0; - double percent_hits; + TEST_LPM_ASSERT(lpm->tbl24[ip>>8].valid_group); + tbl8_group_index = lpm->tbl24[ip>>8].group_idx; - for (j = 0; j < n; j++) - if (table[j].depth == (uint8_t) i) - depth_counter++; + depth = 23; + next_hop = 2; + rte_lpm_add(lpm, ip, depth, next_hop); + TEST_LPM_ASSERT(lpm->tbl24[ip>>8].valid_group); - percent_hits = ((double)depth_counter)/((double)n) * 100; - printf("%.2u%15u (%.2f)\n", i, depth_counter, percent_hits); - } - printf("\n"); + depth = 28; + rte_lpm_delete(lpm, ip, depth); + + TEST_LPM_ASSERT(!lpm->tbl24[ip>>8].valid_group); + + next_hop = 3; + rte_lpm_add(lpm, ip, depth, next_hop); + + TEST_LPM_ASSERT(lpm->tbl24[ip>>8].valid_group); + TEST_LPM_ASSERT(tbl8_group_index == lpm->tbl24[ip>>8].group_idx); + + depth = 24; + next_hop = 4; + rte_lpm_add(lpm, ip, depth, next_hop); + TEST_LPM_ASSERT(lpm->tbl24[ip>>8].valid_group); + + depth = 28; + rte_lpm_delete(lpm, ip, depth); + + TEST_LPM_ASSERT(!lpm->tbl24[ip>>8].valid_group); + + next_hop = 5; + rte_lpm_add(lpm, ip, depth, next_hop); + + TEST_LPM_ASSERT(lpm->tbl24[ip>>8].valid_group); + TEST_LPM_ASSERT(tbl8_group_index == lpm->tbl24[ip>>8].group_idx); + + rte_lpm_free(lpm); +#undef group_idx + 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 -perf_test(void) +test19(void) { struct rte_lpm *lpm = NULL; - uint64_t begin, total_time, lpm_used_entries = 0; - unsigned i, j; - uint8_t next_hop_add = 0xAA, next_hop_return = 0; - int status = 0; - uint64_t cache_line_counter = 0; - int64_t count = 0; + 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); + 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); + 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); - rte_srand(rte_rdtsc()); + rcu_cfg.v = qsv2; + rcu_cfg.mode = RTE_LPM_QSBR_MODE_SYNC; + status = rte_lpm_rcu_qsbr_add(lpm, &rcu_cfg); + TEST_LPM_ASSERT(status != 0); - printf("No. routes = %u\n", (unsigned) NUM_ROUTE_ENTRIES); + rte_lpm_free(lpm); + rte_free(qsv); + rte_free(qsv2); - print_route_distribution(large_route_table, (uint32_t) NUM_ROUTE_ENTRIES); + return PASS; +} - lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, 1000000, 0); +/* + * 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); - /* Measue add. */ - begin = rte_rdtsc(); + /* 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); - for (i = 0; i < NUM_ROUTE_ENTRIES; i++) { - if (rte_lpm_add(lpm, large_route_table[i].ip, - large_route_table[i].depth, next_hop_add) == 0) - status++; - } - /* End Timer. */ - total_time = rte_rdtsc() - begin; - - printf("Unique added entries = %d\n", status); - /* Obtain add statistics. */ - for (i = 0; i < RTE_LPM_TBL24_NUM_ENTRIES; i++) { - if (lpm->tbl24[i].valid) - lpm_used_entries++; - - if (i % 32 == 0){ - if ((uint64_t)count < lpm_used_entries) { - cache_line_counter++; - count = lpm_used_entries; - } - } - } + status = rte_rcu_qsbr_init(qsv, 1); + TEST_LPM_ASSERT(status == 0); - printf("Used table 24 entries = %u (%g%%)\n", - (unsigned) lpm_used_entries, - (lpm_used_entries * 100.0) / RTE_LPM_TBL24_NUM_ENTRIES); - printf("64 byte Cache entries used = %u (%u bytes)\n", - (unsigned) cache_line_counter, (unsigned) cache_line_counter * 64); + 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); + TEST_LPM_ASSERT(status == 0); - printf("Average LPM Add: %g cycles\n", (double)total_time / NUM_ROUTE_ENTRIES); + 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); - /* Measure single Lookup */ - total_time = 0; - count = 0; + /* Register pseudo reader */ + status = rte_rcu_qsbr_thread_register(qsv, 0); + TEST_LPM_ASSERT(status == 0); + rte_rcu_qsbr_thread_online(qsv, 0); - for (i = 0; i < ITERATIONS; i ++) { - static uint32_t ip_batch[BATCH_SIZE]; + status = rte_lpm_lookup(lpm, ip, &next_hop_return); + TEST_LPM_ASSERT(status == 0); + TEST_LPM_ASSERT(next_hop_return == next_hop); - for (j = 0; j < BATCH_SIZE; j ++) - ip_batch[j] = rte_rand(); + /* Writer update */ + status = rte_lpm_delete(lpm, ip, depth); + TEST_LPM_ASSERT(status == 0); + TEST_LPM_ASSERT(!lpm->tbl24[ip>>8].valid); - /* Lookup per batch */ - begin = rte_rdtsc(); + status = rte_lpm_lookup(lpm, ip, &next_hop_return); + TEST_LPM_ASSERT(status != 0); - for (j = 0; j < BATCH_SIZE; j ++) { - if (rte_lpm_lookup(lpm, ip_batch[j], &next_hop_return) != 0) - count++; - } + status = rte_lpm_add(lpm, ip, depth, next_hop); + TEST_LPM_ASSERT(status != 0); - total_time += rte_rdtsc() - begin; + /* Reader quiescent */ + rte_rcu_qsbr_quiescent(qsv, 0); - } - printf("Average LPM Lookup: %.1f cycles (fails = %.1f%%)\n", - (double)total_time / ((double)ITERATIONS * BATCH_SIZE), - (count * 100.0) / (double)(ITERATIONS * BATCH_SIZE)); - - /* Measure bulk Lookup */ - total_time = 0; - count = 0; - for (i = 0; i < ITERATIONS; i ++) { - static uint32_t ip_batch[BATCH_SIZE]; - uint16_t next_hops[BULK_SIZE]; - - /* Create array of random IP addresses */ - for (j = 0; j < BATCH_SIZE; j ++) - ip_batch[j] = rte_rand(); - - /* Lookup per batch */ - begin = rte_rdtsc(); - for (j = 0; j < BATCH_SIZE; j += BULK_SIZE) { - unsigned k; - rte_lpm_lookup_bulk(lpm, &ip_batch[j], next_hops, BULK_SIZE); - for (k = 0; k < BULK_SIZE; k++) - if (unlikely(!(next_hops[k] & RTE_LPM_LOOKUP_SUCCESS))) - count++; - } + 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); - total_time += rte_rdtsc() - begin; + 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; } - printf("BULK LPM Lookup: %.1f cycles (fails = %.1f%%)\n", - (double)total_time / ((double)ITERATIONS * BATCH_SIZE), - (count * 100.0) / (double)(ITERATIONS * BATCH_SIZE)); - - /* Delete */ - status = 0; - begin = rte_rdtsc(); - - for (i = 0; i < NUM_ROUTE_ENTRIES; i++) { - /* rte_lpm_delete(lpm, ip, depth) */ - status += rte_lpm_delete(lpm, large_route_table[i].ip, - large_route_table[i].depth); + + 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); + 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; } - total_time += rte_rdtsc() - begin; + /* 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; + } - printf("Average LPM Delete: %g cycles\n", - (double)total_time / NUM_ROUTE_ENTRIES); + 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; + } + } - rte_lpm_delete_all(lpm); - rte_lpm_free(lpm); +error: + writer_done = 1; + /* Wait until reader exited. */ + rte_eal_mp_wait_lcore(); - return PASS; + rte_lpm_free(g_lpm); + rte_free(g_v); + + return (status == 0) ? PASS : -1; } /* - * Do all unit and performance tests. + * Do all unit tests. */ -int +static int test_lpm(void) { unsigned i; int status, global_status = 0; - for (i = 0; i < NUM_LPM_TESTS; i++) { + for (i = 0; i < RTE_DIM(tests); i++) { status = tests[i](); if (status < 0) { - printf("ERROR: LPM Test %s: FAIL\n", RTE_STR(tests[i])); + printf("ERROR: LPM Test %u: FAIL\n", i); global_status = status; } } @@ -1279,13 +1575,4 @@ test_lpm(void) return global_status; } -#else /* RTE_LIBRTE_LPM */ - -int -test_lpm(void) -{ - printf("The LPM library is not included in this build\n"); - return 0; -} - -#endif /* RTE_LIBRTE_LPM */ +REGISTER_TEST_COMMAND(lpm_autotest, test_lpm);