/* * Creates two different LPM tables. Tries to create a third one with the same * name as the first one and expects the create function to return the same * pointer. */ int32_t test1(void) { struct rte_lpm6 *lpm1 = NULL, *lpm2 = NULL, *lpm3 = NULL; struct rte_lpm6_config config; config.max_rules = MAX_RULES; config.number_tbl8s = NUMBER_TBL8S; config.flags = 0; /* rte_lpm6_create: lpm name == LPM1 */ lpm1 = rte_lpm6_create("LPM1", SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm1 != NULL); /* rte_lpm6_create: lpm name == LPM2 */ lpm2 = rte_lpm6_create("LPM2", SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm2 != NULL); /* rte_lpm6_create: lpm name == LPM2 */ lpm3 = rte_lpm6_create("LPM1", SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm3 == lpm1); rte_lpm6_free(lpm1); rte_lpm6_free(lpm2); return PASS; }
/* * Check that rte_lpm6_lookup fails gracefully for incorrect user input * arguments */ int32_t test6(void) { struct rte_lpm6 *lpm = NULL; struct rte_lpm6_config config; uint8_t ip[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; uint8_t next_hop_return = 0; int32_t status = 0; config.max_rules = MAX_RULES; config.number_tbl8s = NUMBER_TBL8S; config.flags = 0; /* rte_lpm6_lookup: lpm == NULL */ status = rte_lpm6_lookup(NULL, ip, &next_hop_return); TEST_LPM_ASSERT(status < 0); /*Create vaild lpm to use in rest of test. */ lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); /* rte_lpm6_lookup: ip = NULL */ status = rte_lpm6_lookup(lpm, NULL, &next_hop_return); TEST_LPM_ASSERT(status < 0); /* rte_lpm6_lookup: next_hop = NULL */ status = rte_lpm6_lookup(lpm, ip, NULL); TEST_LPM_ASSERT(status < 0); rte_lpm6_free(lpm); return PASS; }
/* * Checks that rte_lpm6_delete_bulk_func fails gracefully for incorrect user * input arguments */ int32_t test8(void) { struct rte_lpm6 *lpm = NULL; struct rte_lpm6_config config; uint8_t ip[10][16]; uint8_t depth[10]; int32_t status = 0; config.max_rules = MAX_RULES; config.number_tbl8s = NUMBER_TBL8S; config.flags = 0; /* rte_lpm6_delete: lpm == NULL */ status = rte_lpm6_delete_bulk_func(NULL, ip, depth, 10); TEST_LPM_ASSERT(status < 0); /*Create vaild lpm to use in rest of test. */ lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); /* rte_lpm6_delete: ip = NULL */ status = rte_lpm6_delete_bulk_func(lpm, NULL, depth, 10); TEST_LPM_ASSERT(status < 0); /* rte_lpm6_delete: next_hop = NULL */ status = rte_lpm6_delete_bulk_func(lpm, ip, NULL, 10); TEST_LPM_ASSERT(status < 0); rte_lpm6_free(lpm); return PASS; }
/* * Creates an LPM table with a small number of tbl8s and exhaust them in the * middle of the process of adding a rule when there is already an existing rule * in that position and needs to be extended. */ int32_t test12(void) { struct rte_lpm6 *lpm = NULL; struct rte_lpm6_config config; uint8_t ip[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; uint8_t depth, next_hop_add = 100; int32_t status = 0; config.max_rules = MAX_RULES; config.number_tbl8s = 16; config.flags = 0; lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); depth = 128; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); ip[0] = 1; depth = 41; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); depth = 49; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == -ENOSPC); rte_lpm6_free(lpm); return PASS; }
/* * Call add, lookup and delete for a single rule with depth > 24 */ int32_t test16(void) { struct rte_lpm6 *lpm = NULL; struct rte_lpm6_config config; uint8_t ip[] = {12,12,1,0,0,0,0,0,0,0,0,0,0,0,0,0}; uint8_t depth = 128, next_hop_add = 100, next_hop_return = 0; int32_t status = 0; config.max_rules = MAX_RULES; config.number_tbl8s = NUMBER_TBL8S; config.flags = 0; lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); status = rte_lpm6_delete(lpm, ip, depth); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT(status == -ENOENT); rte_lpm6_free(lpm); return PASS; }
/* * Sequence of operations for find existing lpm table * * - create table * - find existing table: hit * - find non-existing table: miss */ int32_t test24(void) { struct rte_lpm6 *lpm = NULL, *result = NULL; struct rte_lpm6_config config; config.max_rules = 256 * 32; config.number_tbl8s = NUMBER_TBL8S; config.flags = 0; /* Create lpm */ lpm = rte_lpm6_create("lpm_find_existing", SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); /* Try to find existing lpm */ result = rte_lpm6_find_existing("lpm_find_existing"); TEST_LPM_ASSERT(result == lpm); /* Try to find non-existing lpm */ result = rte_lpm6_find_existing("lpm_find_non_existing"); TEST_LPM_ASSERT(result == NULL); /* Cleanup. */ rte_lpm6_delete_all(lpm); rte_lpm6_free(lpm); return PASS; }
/* * Use rte_lpm6_add to add rules which effect only the second half of the lpm * table. Use all possible depths ranging from 1..32. Set the next hop = to the * depth. Check lookup hit for on every add and check for lookup miss on the * first half of the lpm table after each add. Finally delete all rules going * backwards (i.e. from depth = 32 ..1) and carry out a lookup after each * delete. The lookup should return the next_hop_add value related to the * previous depth value (i.e. depth -1). */ int32_t test17(void) { struct rte_lpm6 *lpm = NULL; struct rte_lpm6_config config; uint8_t ip1[] = {127,255,255,255,255,255,255,255,255, 255,255,255,255,255,255,255}; uint8_t ip2[] = {128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; uint8_t depth, next_hop_add, next_hop_return; int32_t status = 0; config.max_rules = MAX_RULES; config.number_tbl8s = NUMBER_TBL8S; config.flags = 0; lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); /* Loop with rte_lpm6_add. */ for (depth = 1; depth <= 128; depth++) { /* Let the next_hop_add value = depth. Just for change. */ next_hop_add = depth; status = rte_lpm6_add(lpm, ip2, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); /* Check IP in first half of tbl24 which should be empty. */ status = rte_lpm6_lookup(lpm, ip1, &next_hop_return); TEST_LPM_ASSERT(status == -ENOENT); status = rte_lpm6_lookup(lpm, ip2, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); } /* Loop with rte_lpm6_delete. */ for (depth = 128; depth >= 1; depth--) { next_hop_add = (uint8_t) (depth - 1); status = rte_lpm6_delete(lpm, ip2, depth); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip2, &next_hop_return); if (depth != 1) { TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); } else { TEST_LPM_ASSERT(status == -ENOENT); } status = rte_lpm6_lookup(lpm, ip1, &next_hop_return); TEST_LPM_ASSERT(status == -ENOENT); } rte_lpm6_free(lpm); return PASS; }
/* * Check that rte_lpm6_delete fails gracefully for incorrect user input * arguments */ int32_t test5(void) { struct rte_lpm6 *lpm = NULL; struct rte_lpm6_config config; uint8_t ip[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; uint8_t depth = 24; int32_t status = 0; config.max_rules = MAX_RULES; config.number_tbl8s = NUMBER_TBL8S; config.flags = 0; /* rte_lpm_delete: lpm == NULL */ status = rte_lpm6_delete(NULL, ip, depth); TEST_LPM_ASSERT(status < 0); /*Create vaild lpm to use in rest of test. */ lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); /* rte_lpm_delete: depth < 1 */ status = rte_lpm6_delete(lpm, ip, 0); TEST_LPM_ASSERT(status < 0); /* rte_lpm_delete: depth > MAX_DEPTH */ status = rte_lpm6_delete(lpm, ip, (MAX_DEPTH + 1)); TEST_LPM_ASSERT(status < 0); rte_lpm6_free(lpm); return PASS; }
int ss_conf_ioc_file_parse() { int is_ok = 1; int rv = 0; json_object* items = NULL; json_object* item = NULL; struct rte_lpm6_config lpm6_info = { .max_rules = SS_LPM_RULE_MAX, .number_tbl8s = SS_LPM_TBL8S_MAX, .flags = 0, }; ss_conf->cidr4 = rte_lpm_create("cidr4", 0, SS_LPM_RULE_MAX, 0); ss_conf->cidr6 = rte_lpm6_create("cidr6", 0, &lpm6_info); if (ss_conf->cidr4 == NULL) { fprintf(stderr, "could not allocate cidr4\n"); return -1; } if (ss_conf->cidr6 == NULL) { fprintf(stderr, "could not allocate cidr6\n"); return -1; } items = ss_json_object_get(ss_conf->json, "ioc_files"); if (!items) return 0; is_ok = json_object_is_type(items, json_type_array); if (!is_ok) { fprintf(stderr, "ioc_files is not an array\n"); return -1; } int length = json_object_array_length(items); if (length > SS_IOC_FILE_MAX) { fprintf(stderr, "ioc_file_count %d greater than %d, only parsing files below limit\n", length, SS_IOC_FILE_MAX); length = SS_IOC_FILE_MAX; } for (int i = 0; i < length; ++i) { item = json_object_array_get_idx(items, i); rv = ss_ioc_file_load(item); if (rv) { fprintf(stderr, "ioc_file index %d could not be loaded\n", i); is_ok = 0; return -1; } } ss_ioc_chain_dump(20); ss_ioc_chain_optimize(); ss_ioc_tables_dump(5); return 0; }
/* * Adds 3 rules and look them up through the lookup_bulk function. * Includes in the lookup a fourth IP address that won't match * and checks that the result is as expected. */ int32_t test21(void) { struct rte_lpm6 *lpm = NULL; struct rte_lpm6_config config; uint8_t ip_batch[4][16]; uint8_t depth, next_hop_add; int16_t next_hop_return[4]; int32_t status = 0; config.max_rules = MAX_RULES; config.number_tbl8s = NUMBER_TBL8S; config.flags = 0; lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); IPv6(ip_batch[0], 128, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth = 48; next_hop_add = 100; status = rte_lpm6_add(lpm, ip_batch[0], depth, next_hop_add); TEST_LPM_ASSERT(status == 0); IPv6(ip_batch[1], 128, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth = 48; next_hop_add = 101; status = rte_lpm6_add(lpm, ip_batch[1], depth, next_hop_add); TEST_LPM_ASSERT(status == 0); IPv6(ip_batch[2], 128, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth = 48; next_hop_add = 102; status = rte_lpm6_add(lpm, ip_batch[2], depth, next_hop_add); TEST_LPM_ASSERT(status == 0); IPv6(ip_batch[3], 128, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); status = rte_lpm6_lookup_bulk_func(lpm, ip_batch, next_hop_return, 4); TEST_LPM_ASSERT(status == 0 && next_hop_return[0] == 100 && next_hop_return[1] == 101 && next_hop_return[2] == 102 && next_hop_return[3] == -1); rte_lpm6_free(lpm); return PASS; }
/* * Check that rte_lpm6_create fails gracefully for incorrect user input * arguments */ int32_t test0(void) { struct rte_lpm6 *lpm = NULL; struct rte_lpm6_config config; config.max_rules = MAX_RULES; config.number_tbl8s = NUMBER_TBL8S; config.flags = 0; /* rte_lpm6_create: lpm name == NULL */ lpm = rte_lpm6_create(NULL, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm == NULL); /* rte_lpm6_create: max_rules = 0 */ /* Note: __func__ inserts the function name, in this case "test0". */ config.max_rules = 0; lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm == NULL); /* socket_id < -1 is invalid */ config.max_rules = MAX_RULES; lpm = rte_lpm6_create(__func__, -2, &config); TEST_LPM_ASSERT(lpm == NULL); /* rte_lpm6_create: number_tbl8s is bigger than the maximum */ config.number_tbl8s = MAX_NUM_TBL8S + 1; lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm == NULL); /* rte_lpm6_create: config = NULL */ lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, NULL); TEST_LPM_ASSERT(lpm == NULL); return PASS; }
/* * Add 2^16 routes with different first 16 bits and depth 25. * Add one more route with the same depth and check that results in a failure. * After that delete the last rule and create the one that was attempted to be * created. This checks tbl8 exhaustion. */ int32_t test14(void) { struct rte_lpm6 *lpm = NULL; struct rte_lpm6_config config; uint8_t ip[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; uint8_t depth = 25, next_hop_add = 100; int32_t status = 0; int i, j; config.max_rules = MAX_RULES; config.number_tbl8s = NUMBER_TBL8S; config.flags = 0; lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); for (i = 0; i < 256; i++) { ip[0] = (uint8_t)i; for (j = 0; j < 256; j++) { ip[1] = (uint8_t)j; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); } } ip[0] = 255; ip[1] = 255; ip[2] = 1; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == -ENOSPC); ip[0] = 255; ip[1] = 255; ip[2] = 0; status = rte_lpm6_delete(lpm, ip, depth); TEST_LPM_ASSERT(status == 0); ip[0] = 255; ip[1] = 255; ip[2] = 1; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); rte_lpm6_free(lpm); return PASS; }
/* * Call rte_lpm6_free for NULL pointer user input. Note: free has no return and * therefore it is impossible to check for failure but this test is added to * increase function coverage metrics and to validate that freeing null does * not crash. */ int32_t test3(void) { struct rte_lpm6 *lpm = NULL; struct rte_lpm6_config config; config.max_rules = MAX_RULES; config.number_tbl8s = NUMBER_TBL8S; config.flags = 0; lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); rte_lpm6_free(lpm); rte_lpm6_free(NULL); return PASS; }
/* * Add a rule that reaches the end of the tree. * Add a rule that is more generic than the first one. * Check every possible combination that produces a match for the second rule. * This tests tbl expansion. */ int32_t test27(void) { struct rte_lpm6 *lpm = NULL; struct rte_lpm6_config config; uint8_t ip[] = {128,128,128,128,128,128,128,128,128,128,128,128,128,128,0,0}; uint8_t depth = 128, next_hop_add = 100, next_hop_return; int32_t status = 0; int i, j; config.max_rules = MAX_RULES; config.number_tbl8s = NUMBER_TBL8S; config.flags = 0; lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); depth = 128; next_hop_add = 128; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); depth = 112; next_hop_add = 112; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); for (i = 0; i < 256; i++) { ip[14] = (uint8_t)i; for (j = 0; j < 256; j++) { ip[15] = (uint8_t)j; status = rte_lpm6_lookup(lpm, ip, &next_hop_return); if (i == 0 && j == 0) TEST_LPM_ASSERT(status == 0 && next_hop_return == 128); else TEST_LPM_ASSERT(status == 0 && next_hop_return == 112); } } rte_lpm6_free(lpm); return PASS; }
/* * Creates an LPM table with max_rules = 2 and tries to add 3 rules. * Delete one of the rules and tries to add the third one again. */ int32_t test13(void) { struct rte_lpm6 *lpm = NULL; struct rte_lpm6_config config; uint8_t ip[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; uint8_t depth, next_hop_add = 100; int32_t status = 0; config.max_rules = 2; config.number_tbl8s = NUMBER_TBL8S; config.flags = 0; lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); depth = 1; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); depth = 2; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); depth = 3; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == -ENOSPC); depth = 2; status = rte_lpm6_delete(lpm, ip, depth); TEST_LPM_ASSERT(status == 0); depth = 3; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); rte_lpm6_free(lpm); return PASS; }
/* * Create lpm table then delete lpm table 100 times * Use a slightly different rules size each time */ int32_t test2(void) { struct rte_lpm6 *lpm = NULL; struct rte_lpm6_config config; int32_t i; config.number_tbl8s = NUMBER_TBL8S; config.flags = 0; /* rte_lpm6_free: Free NULL */ for (i = 0; i < 100; i++) { config.max_rules = MAX_RULES - i; lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); rte_lpm6_free(lpm); } /* Can not test free so return success */ return PASS; }
/* * Add a set of random routes with random depths. * Lookup different IP addresses that match the routes previously added. * Checks that the next hop is the expected one. * The routes, IP addresses and expected result for every case have been * precalculated by using a python script and stored in a .h file. */ int32_t test25(void) { struct rte_lpm6 *lpm = NULL; struct rte_lpm6_config config; uint8_t ip[16]; uint32_t i; uint8_t depth, next_hop_add, next_hop_return, next_hop_expected; int32_t status = 0; config.max_rules = MAX_RULES; config.number_tbl8s = NUMBER_TBL8S; config.flags = 0; lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); for (i = 0; i < 1000; i++) { memcpy(ip, large_route_table[i].ip, 16); depth = large_route_table[i].depth; next_hop_add = large_route_table[i].next_hop; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); } for (i = 0; i < 100000; i++) { memcpy(ip, large_ips_table[i].ip, 16); next_hop_expected = large_ips_table[i].next_hop; status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_expected)); } rte_lpm6_free(lpm); return PASS; }
/* * - Add rule that covers a TBL24 range previously invalid & lookup (& delete & * lookup) * - Add rule that extends a TBL24 invalid entry & lookup (& delete & lookup) * - Add rule that extends a TBL24 valid entry & lookup for both rules (& * delete & lookup) * - Add rule that updates the next hop in TBL24 & lookup (& delete & lookup) * - Add rule that updates the next hop in TBL8 & lookup (& delete & lookup) * - Delete a rule that is not present in the TBL24 & lookup * - Delete a rule that is not present in the TBL8 & lookup */ int32_t test19(void) { struct rte_lpm6 *lpm = NULL; struct rte_lpm6_config config; uint8_t ip[16]; uint8_t depth, next_hop_add, next_hop_return; int32_t status = 0; config.max_rules = MAX_RULES; config.number_tbl8s = NUMBER_TBL8S; config.flags = 0; /* Add rule that covers a TBL24 range previously invalid & lookup * (& delete & lookup) */ lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth = 16; next_hop_add = 100; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); status = rte_lpm6_delete(lpm, ip, depth); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT(status == -ENOENT); rte_lpm6_delete_all(lpm); IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth = 25; next_hop_add = 100; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); status = rte_lpm6_delete(lpm, ip, depth); TEST_LPM_ASSERT(status == 0); rte_lpm6_delete_all(lpm); /* * Add rule that extends a TBL24 valid entry & lookup for both rules * (& delete & lookup) */ IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth = 24; next_hop_add = 100; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); IPv6(ip, 128, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth = 32; next_hop_add = 101; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); next_hop_add = 100; status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth = 24; status = rte_lpm6_delete(lpm, ip, depth); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT(status == -ENOENT); IPv6(ip, 128, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth = 32; status = rte_lpm6_delete(lpm, ip, depth); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT(status == -ENOENT); rte_lpm6_delete_all(lpm); /* * Add rule that updates the next hop in TBL24 & lookup * (& delete & lookup) */ IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth = 24; next_hop_add = 100; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); next_hop_add = 101; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); status = rte_lpm6_delete(lpm, ip, depth); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT(status == -ENOENT); rte_lpm6_delete_all(lpm); /* * Add rule that updates the next hop in TBL8 & lookup * (& delete & lookup) */ IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth = 32; next_hop_add = 100; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); next_hop_add = 101; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); status = rte_lpm6_delete(lpm, ip, depth); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT(status == -ENOENT); rte_lpm6_delete_all(lpm); /* Delete a rule that is not present in the TBL24 & lookup */ IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth = 24; next_hop_add = 100; status = rte_lpm6_delete(lpm, ip, depth); TEST_LPM_ASSERT(status < 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT(status == -ENOENT); rte_lpm6_delete_all(lpm); /* Delete a rule that is not present in the TBL8 & lookup */ IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth = 32; next_hop_add = 100; status = rte_lpm6_delete(lpm, ip, depth); TEST_LPM_ASSERT(status < 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT(status == -ENOENT); rte_lpm6_free(lpm); return PASS; }
/**< Usage: ./exe <use_random_prefixes> */ int main(int argc, char **argv) { int i, j; assert(argc == 2); int use_random_prefixes = atoi(argv[1]); assert(use_random_prefixes == 1 || use_random_prefixes == 0); /**< Create the lmp6 struct */ struct rte_lpm6_config ipv6_config; ipv6_config.max_rules = 1000000; ipv6_config.number_tbl8s = 1024 * 1024; struct rte_lpm6 *lpm = rte_lpm6_create(0, &ipv6_config); /**< Read the prefixes from a prefixes file */ struct ipv6_prefix *prefix_arr; int num_prefixes; if(use_random_prefixes == 0) { /**< Generate prefixes at random: Real prefixes have great cache * behavior. */ prefix_arr = ipv6_read_prefixes(PREFIX_FILE, &num_prefixes); printf("main: Read %d prefixes. Amplifying by %d.\n", num_prefixes, AMP_FACTOR); prefix_arr = ipv6_amp_prefixes(prefix_arr, num_prefixes, AMP_FACTOR); num_prefixes *= AMP_FACTOR; } else { num_prefixes = NUM_RAND_PREFIXES; prefix_arr = ipv6_gen_rand_prefixes(num_prefixes); } assert(num_prefixes < ipv6_config.max_rules); for(i = 0; i < num_prefixes; i ++) { int add_status = rte_lpm6_add(lpm, prefix_arr[i].bytes, prefix_arr[i].depth, prefix_arr[i].dst_port); if(add_status < 0) { printf("main: Failed to add IPv6 prefix %d. Status = %d\n", i, add_status); exit(-1); } if(i % 1000 == 0) { printf("main: Added prefixes = %d, total = %d\n", i, num_prefixes); } } printf("\tmain: Done inserting prefixes\n"); /**< Generate probe IPv6 addresses from inserted prefixes */ printf("main: Generating %d IPv6 addresses\n", NUM_IPS); struct ipv6_addr *addr_arr = ipv6_gen_addrs(NUM_IPS, prefix_arr, num_prefixes); printf("main: Starting lookups\n"); /**< Variables for PAPI */ float real_time, proc_time, ipc; long long ins; int retval; /**< Init PAPI_TOT_INS and PAPI_TOT_CYC counters */ if((retval = PAPI_ipc(&real_time, &proc_time, &ins, &ipc)) < PAPI_OK) { printf("PAPI error: retval: %d\n", retval); exit(1); } int16_t dst_port[BATCH_SIZE]; int dst_port_sum = 0; for(i = 0; i < NUM_IPS; i += BATCH_SIZE) { rte_lpm6_lookup_handopt(lpm, (void *) addr_arr[i].bytes, dst_port, BATCH_SIZE); for(j = 0; j < BATCH_SIZE; j ++) { dst_port_sum += dst_port[j]; } } if((retval = PAPI_ipc(&real_time, &proc_time, &ins, &ipc)) < PAPI_OK) { printf("PAPI error: retval: %d\n", retval); exit(1); } printf("Time = %.4f s, Lookup rate = %.2f M/s | dst_port_sum = %d\n" "Instructions = %lld, IPC = %f\n", real_time, NUM_IPS / (real_time * 1000000), dst_port_sum, ins, ipc); return 0; }
static void * rte_table_lpm_ipv6_create(void *params, int socket_id, uint32_t entry_size) { struct rte_table_lpm_ipv6_params *p = (struct rte_table_lpm_ipv6_params *) params; struct rte_table_lpm_ipv6 *lpm; struct rte_lpm6_config lpm6_config; uint32_t total_size, nht_size; /* Check input parameters */ if (p == NULL) { RTE_LOG(ERR, TABLE, "%s: NULL input parameters\n", __func__); return NULL; } if (p->n_rules == 0) { RTE_LOG(ERR, TABLE, "%s: Invalid n_rules\n", __func__); return NULL; } if (p->number_tbl8s == 0) { RTE_LOG(ERR, TABLE, "%s: Invalid n_rules\n", __func__); return NULL; } if (p->entry_unique_size == 0) { RTE_LOG(ERR, TABLE, "%s: Invalid entry_unique_size\n", __func__); return NULL; } if (p->entry_unique_size > entry_size) { RTE_LOG(ERR, TABLE, "%s: Invalid entry_unique_size\n", __func__); return NULL; } entry_size = RTE_ALIGN(entry_size, sizeof(uint64_t)); /* Memory allocation */ nht_size = RTE_TABLE_LPM_MAX_NEXT_HOPS * entry_size; total_size = sizeof(struct rte_table_lpm_ipv6) + nht_size; lpm = rte_zmalloc_socket("TABLE", total_size, RTE_CACHE_LINE_SIZE, socket_id); if (lpm == NULL) { RTE_LOG(ERR, TABLE, "%s: Cannot allocate %u bytes for LPM IPv6 table\n", __func__, total_size); return NULL; } /* LPM low-level table creation */ lpm6_config.max_rules = p->n_rules; lpm6_config.number_tbl8s = p->number_tbl8s; lpm6_config.flags = 0; lpm->lpm = rte_lpm6_create("LPM IPv6", socket_id, &lpm6_config); if (lpm->lpm == NULL) { rte_free(lpm); RTE_LOG(ERR, TABLE, "Unable to create low-level LPM IPv6 table\n"); return NULL; } /* Memory initialization */ lpm->entry_size = entry_size; lpm->entry_unique_size = p->entry_unique_size; lpm->n_rules = p->n_rules; lpm->offset = p->offset; return lpm; }
/* * - Add & lookup to hit invalid TBL24 entry * - Add & lookup to hit valid TBL24 entry not extended * - Add & lookup to hit valid extended TBL24 entry with invalid TBL8 entry * - Add & lookup to hit valid extended TBL24 entry with valid TBL8 entry */ int32_t test18(void) { struct rte_lpm6 *lpm = NULL; struct rte_lpm6_config config; uint8_t ip[16], ip_1[16], ip_2[16]; uint8_t depth, depth_1, depth_2, next_hop_add, next_hop_add_1, next_hop_add_2, next_hop_return; int32_t status = 0; config.max_rules = MAX_RULES; config.number_tbl8s = NUMBER_TBL8S; config.flags = 0; /* Add & lookup to hit invalid TBL24 entry */ IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth = 24; next_hop_add = 100; lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); status = rte_lpm6_delete(lpm, ip, depth); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT(status == -ENOENT); rte_lpm6_delete_all(lpm); /* Add & lookup to hit valid TBL24 entry not extended */ IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth = 23; next_hop_add = 100; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); depth = 24; next_hop_add = 101; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); depth = 24; status = rte_lpm6_delete(lpm, ip, depth); TEST_LPM_ASSERT(status == 0); depth = 23; status = rte_lpm6_delete(lpm, ip, depth); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT(status == -ENOENT); rte_lpm6_delete_all(lpm); /* Add & lookup to hit valid extended TBL24 entry with invalid TBL8 * entry. */ IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth = 32; next_hop_add = 100; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); IPv6(ip, 128, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth = 32; next_hop_add = 101; status = rte_lpm6_add(lpm, ip, depth, next_hop_add); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth = 32; next_hop_add = 100; status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add)); status = rte_lpm6_delete(lpm, ip, depth); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip, &next_hop_return); TEST_LPM_ASSERT(status == -ENOENT); rte_lpm6_delete_all(lpm); /* Add & lookup to hit valid extended TBL24 entry with valid TBL8 * entry */ IPv6(ip_1, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth_1 = 25; next_hop_add_1 = 101; IPv6(ip_2, 128, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth_2 = 32; next_hop_add_2 = 102; next_hop_return = 0; status = rte_lpm6_add(lpm, ip_1, depth_1, next_hop_add_1); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip_1, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add_1)); status = rte_lpm6_add(lpm, ip_2, depth_2, next_hop_add_2); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip_2, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add_2)); status = rte_lpm6_delete(lpm, ip_2, depth_2); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip_2, &next_hop_return); TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add_1)); status = rte_lpm6_delete(lpm, ip_1, depth_1); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup(lpm, ip_1, &next_hop_return); TEST_LPM_ASSERT(status == -ENOENT); rte_lpm6_free(lpm); return PASS; }
/* * Adds 5 rules and look them up. * Use the delete_bulk function to delete two of them. Lookup again. * Use the delete_bulk function to delete one more. Lookup again. * Use the delete_bulk function to delete two more, one invalid. Lookup again. * Use the delete_bulk function to delete the remaining one. Lookup again. */ int32_t test22(void) { struct rte_lpm6 *lpm = NULL; struct rte_lpm6_config config; uint8_t ip_batch[5][16]; uint8_t depth[5], next_hop_add; int16_t next_hop_return[5]; int32_t status = 0; config.max_rules = MAX_RULES; config.number_tbl8s = NUMBER_TBL8S; config.flags = 0; lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); /* Adds 5 rules and look them up */ IPv6(ip_batch[0], 128, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth[0] = 48; next_hop_add = 101; status = rte_lpm6_add(lpm, ip_batch[0], depth[0], next_hop_add); TEST_LPM_ASSERT(status == 0); IPv6(ip_batch[1], 128, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth[1] = 48; next_hop_add = 102; status = rte_lpm6_add(lpm, ip_batch[1], depth[1], next_hop_add); TEST_LPM_ASSERT(status == 0); IPv6(ip_batch[2], 128, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth[2] = 48; next_hop_add = 103; status = rte_lpm6_add(lpm, ip_batch[2], depth[2], next_hop_add); TEST_LPM_ASSERT(status == 0); IPv6(ip_batch[3], 128, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth[3] = 48; next_hop_add = 104; status = rte_lpm6_add(lpm, ip_batch[3], depth[3], next_hop_add); TEST_LPM_ASSERT(status == 0); IPv6(ip_batch[4], 128, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); depth[4] = 48; next_hop_add = 105; status = rte_lpm6_add(lpm, ip_batch[4], depth[4], next_hop_add); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup_bulk_func(lpm, ip_batch, next_hop_return, 5); TEST_LPM_ASSERT(status == 0 && next_hop_return[0] == 101 && next_hop_return[1] == 102 && next_hop_return[2] == 103 && next_hop_return[3] == 104 && next_hop_return[4] == 105); /* Use the delete_bulk function to delete two of them. Lookup again */ status = rte_lpm6_delete_bulk_func(lpm, &ip_batch[0], depth, 2); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup_bulk_func(lpm, ip_batch, next_hop_return, 5); TEST_LPM_ASSERT(status == 0 && next_hop_return[0] == -1 && next_hop_return[1] == -1 && next_hop_return[2] == 103 && next_hop_return[3] == 104 && next_hop_return[4] == 105); /* Use the delete_bulk function to delete one more. Lookup again */ status = rte_lpm6_delete_bulk_func(lpm, &ip_batch[2], depth, 1); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup_bulk_func(lpm, ip_batch, next_hop_return, 5); TEST_LPM_ASSERT(status == 0 && next_hop_return[0] == -1 && next_hop_return[1] == -1 && next_hop_return[2] == -1 && next_hop_return[3] == 104 && next_hop_return[4] == 105); /* Use the delete_bulk function to delete two, one invalid. Lookup again */ IPv6(ip_batch[4], 128, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); status = rte_lpm6_delete_bulk_func(lpm, &ip_batch[3], depth, 2); TEST_LPM_ASSERT(status == 0); IPv6(ip_batch[4], 128, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); status = rte_lpm6_lookup_bulk_func(lpm, ip_batch, next_hop_return, 5); TEST_LPM_ASSERT(status == 0 && next_hop_return[0] == -1 && next_hop_return[1] == -1 && next_hop_return[2] == -1 && next_hop_return[3] == -1 && next_hop_return[4] == 105); /* Use the delete_bulk function to delete the remaining one. Lookup again */ status = rte_lpm6_delete_bulk_func(lpm, &ip_batch[4], depth, 1); TEST_LPM_ASSERT(status == 0); status = rte_lpm6_lookup_bulk_func(lpm, ip_batch, next_hop_return, 5); TEST_LPM_ASSERT(status == 0 && next_hop_return[0] == -1 && next_hop_return[1] == -1 && next_hop_return[2] == -1 && next_hop_return[3] == -1 && next_hop_return[4] == -1); rte_lpm6_free(lpm); return PASS; }
/* * Test for overwriting of tbl8: * - add rule /32 and lookup * - add new rule /24 and lookup * - add third rule /25 and lookup * - lookup /32 and /24 rule to ensure the table has not been overwritten. */ int32_t test26(void) { struct rte_lpm6 *lpm = NULL; struct rte_lpm6_config config; uint8_t ip_10_32[] = {10, 10, 10, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; uint8_t ip_10_24[] = {10, 10, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; uint8_t ip_20_25[] = {10, 10, 20, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; uint8_t d_ip_10_32 = 32; uint8_t d_ip_10_24 = 24; uint8_t d_ip_20_25 = 25; uint8_t next_hop_ip_10_32 = 100; uint8_t next_hop_ip_10_24 = 105; uint8_t next_hop_ip_20_25 = 111; uint8_t next_hop_return = 0; int32_t status = 0; config.max_rules = MAX_RULES; config.number_tbl8s = NUMBER_TBL8S; config.flags = 0; lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); if ((status = rte_lpm6_add(lpm, ip_10_32, d_ip_10_32, next_hop_ip_10_32)) < 0) return -1; status = rte_lpm6_lookup(lpm, ip_10_32, &next_hop_return); uint8_t test_hop_10_32 = next_hop_return; TEST_LPM_ASSERT(status == 0); TEST_LPM_ASSERT(next_hop_return == next_hop_ip_10_32); if ((status = rte_lpm6_add(lpm, ip_10_24, d_ip_10_24, next_hop_ip_10_24)) < 0) return -1; status = rte_lpm6_lookup(lpm, ip_10_24, &next_hop_return); uint8_t test_hop_10_24 = next_hop_return; TEST_LPM_ASSERT(status == 0); TEST_LPM_ASSERT(next_hop_return == next_hop_ip_10_24); if ((status = rte_lpm6_add(lpm, ip_20_25, d_ip_20_25, next_hop_ip_20_25)) < 0) return -1; status = rte_lpm6_lookup(lpm, ip_20_25, &next_hop_return); uint8_t test_hop_20_25 = next_hop_return; TEST_LPM_ASSERT(status == 0); TEST_LPM_ASSERT(next_hop_return == next_hop_ip_20_25); if (test_hop_10_32 == test_hop_10_24) { printf("Next hop return equal\n"); return -1; } if (test_hop_10_24 == test_hop_20_25){ printf("Next hop return equal\n"); return -1; } status = rte_lpm6_lookup(lpm, ip_10_32, &next_hop_return); TEST_LPM_ASSERT(status == 0); TEST_LPM_ASSERT(next_hop_return == next_hop_ip_10_32); status = rte_lpm6_lookup(lpm, ip_10_24, &next_hop_return); TEST_LPM_ASSERT(status == 0); TEST_LPM_ASSERT(next_hop_return == next_hop_ip_10_24); rte_lpm6_free(lpm); return PASS; }
int32_t perf_test(void) { struct rte_lpm6 *lpm = NULL; struct rte_lpm6_config config; uint64_t begin, total_time; unsigned i, j; uint8_t next_hop_add = 0xAA, next_hop_return = 0; int status = 0; int64_t count = 0; config.max_rules = 1000000; config.number_tbl8s = NUMBER_TBL8S; config.flags = 0; rte_srand(rte_rdtsc()); printf("No. routes = %u\n", (unsigned) NUM_ROUTE_ENTRIES); print_route_distribution(large_route_table, (uint32_t) NUM_ROUTE_ENTRIES); lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config); TEST_LPM_ASSERT(lpm != NULL); /* Measure add. */ begin = rte_rdtsc(); for (i = 0; i < NUM_ROUTE_ENTRIES; i++) { if (rte_lpm6_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); printf("Average LPM Add: %g cycles\n", (double)total_time / NUM_ROUTE_ENTRIES); /* Measure single Lookup */ total_time = 0; count = 0; for (i = 0; i < ITERATIONS; i ++) { begin = rte_rdtsc(); for (j = 0; j < NUM_IPS_ENTRIES; j ++) { if (rte_lpm6_lookup(lpm, large_ips_table[j].ip, &next_hop_return) != 0) count++; } total_time += rte_rdtsc() - begin; } 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; uint8_t ip_batch[NUM_IPS_ENTRIES][16]; int16_t next_hops[NUM_IPS_ENTRIES]; for (i = 0; i < NUM_IPS_ENTRIES; i++) memcpy(ip_batch[i], large_ips_table[i].ip, 16); for (i = 0; i < ITERATIONS; i ++) { /* Lookup per batch */ begin = rte_rdtsc(); rte_lpm6_lookup_bulk_func(lpm, ip_batch, next_hops, NUM_IPS_ENTRIES); total_time += rte_rdtsc() - begin; for (j = 0; j < NUM_IPS_ENTRIES; j++) if (next_hops[j] < 0) count++; } 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_lpm6_delete(lpm, large_route_table[i].ip, large_route_table[i].depth); } total_time += rte_rdtsc() - begin; printf("Average LPM Delete: %g cycles\n", (double)total_time / NUM_ROUTE_ENTRIES); rte_lpm6_delete_all(lpm); rte_lpm6_free(lpm); return PASS; }