app: use common macro RTE_DIM

Use RTE_DIM macro to calculate array size.

Suggested-by: David Marchand <david.marchand@redhat.com>
Signed-off-by: Pavan Nikhilesh <pbhagavatula@marvell.com>
Acked-by: David Marchand <david.marchand@redhat.com>

diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c
index dab22bc..ff9c7b9 100644 (file)
--- a/app/test-pmd/cmdline.c
+++ b/app/test-pmd/cmdline.c
@@ -5565,7 +5565,7 @@ cmd_show_bypass_config_parsed(void *parsed_result,
        uint32_t event_mode;
        uint32_t bypass_mode;
        uint32_t timeout = bypass_timeout;
-       int i;
+       unsigned int i;
 
        static const char * const timeouts[RTE_PMD_IXGBE_BYPASS_TMT_NUM] =
                {"off", "1.5", "2", "3", "4", "8", "16", "32"};
@@ -5578,7 +5578,6 @@ cmd_show_bypass_config_parsed(void *parsed_result,
                "OS/board off",
                "power supply off",
                "timeout"};
-       int num_events = (sizeof events) / (sizeof events[0]);
 
        /* Display the bypass mode.*/
        if (rte_pmd_ixgbe_bypass_state_show(port_id, &bypass_mode) != 0) {
@@ -5599,7 +5598,7 @@ cmd_show_bypass_config_parsed(void *parsed_result,
        printf("\tbypass timeout = %s\n", timeouts[timeout]);
 
        /* Display the bypass events and associated modes. */
-       for (i = RTE_PMD_IXGBE_BYPASS_EVENT_START; i < num_events; i++) {
+       for (i = RTE_PMD_IXGBE_BYPASS_EVENT_START; i < RTE_DIM(events); i++) {
 
                if (rte_pmd_ixgbe_bypass_event_show(port_id, i, &event_mode)) {
                        printf("\tFailed to get bypass mode for event = %s\n",

diff --git a/app/test-pmd/icmpecho.c b/app/test-pmd/icmpecho.c
index 2d359c9..65aece1 100644 (file)
--- a/app/test-pmd/icmpecho.c
+++ b/app/test-pmd/icmpecho.c
@@ -188,7 +188,7 @@ ip_proto_name(uint16_t ip_proto)
                "PIM",        /**< Protocol Independent Mcast */
        };
 
-       if (ip_proto < sizeof(ip_proto_names) / sizeof(ip_proto_names[0]))
+       if (ip_proto < RTE_DIM(ip_proto_names))
                return ip_proto_names[ip_proto];
        switch (ip_proto) {
 #ifdef IPPROTO_PGM

diff --git a/app/test-pmd/testpmd.c b/app/test-pmd/testpmd.c
index f9f4cd1..a1dd404 100644 (file)
--- a/app/test-pmd/testpmd.c
+++ b/app/test-pmd/testpmd.c
@@ -2796,8 +2796,6 @@ struct pmd_test_command {
        cmd_func_t cmd_func;
 };
 
-#define PMD_TEST_CMD_NB (sizeof(pmd_test_menu) / sizeof(pmd_test_menu[0]))
-
 /* Check the link status of all ports in up to 9s, and print them finally */
 static void
 check_all_ports_link_status(uint32_t port_mask)

diff --git a/app/test/test.c b/app/test/test.c
index cd7aaf6..7845350 100644 (file)
--- a/app/test/test.c
+++ b/app/test/test.c
@@ -74,7 +74,7 @@ do_recursive_call(void)
 
        if (recursive_call == NULL)
                return -1;
-       for (i = 0; i < sizeof(actions)/sizeof(actions[0]); i++) {
+       for (i = 0; i < RTE_DIM(actions); i++) {
                if (strcmp(actions[i].env_var, recursive_call) == 0)
                        return (actions[i].action_fn)();
        }

diff --git a/app/test/test_cmdline_etheraddr.c b/app/test/test_cmdline_etheraddr.c
index 9a32fd7..9691c32 100644 (file)
--- a/app/test/test_cmdline_etheraddr.c
+++ b/app/test/test_cmdline_etheraddr.c
@@ -72,15 +72,6 @@ const char * ether_addr_invalid_strs[] = {
                " ",
 };
 
-#define ETHERADDR_VALID_STRS_SIZE \
-       (sizeof(ether_addr_valid_strs) / sizeof(ether_addr_valid_strs[0]))
-#define ETHERADDR_GARBAGE_STRS_SIZE \
-       (sizeof(ether_addr_garbage_strs) / sizeof(ether_addr_garbage_strs[0]))
-#define ETHERADDR_INVALID_STRS_SIZE \
-       (sizeof(ether_addr_invalid_strs) / sizeof(ether_addr_invalid_strs[0]))
-
-
-
 static int
 is_addr_different(const struct rte_ether_addr addr, uint64_t num)
 {
@@ -151,7 +142,7 @@ test_parse_etheraddr_invalid_data(void)
        struct rte_ether_addr result;
 
        /* test full strings */
-       for (i = 0; i < ETHERADDR_INVALID_STRS_SIZE; i++) {
+       for (i = 0; i < RTE_DIM(ether_addr_invalid_strs); i++) {
 
                memset(&result, 0, sizeof(struct rte_ether_addr));
 
@@ -176,7 +167,7 @@ test_parse_etheraddr_valid(void)
        struct rte_ether_addr result;
 
        /* test full strings */
-       for (i = 0; i < ETHERADDR_VALID_STRS_SIZE; i++) {
+       for (i = 0; i < RTE_DIM(ether_addr_valid_strs); i++) {
 
                memset(&result, 0, sizeof(struct rte_ether_addr));
 
@@ -195,7 +186,7 @@ test_parse_etheraddr_valid(void)
        }
 
        /* test garbage strings */
-       for (i = 0; i < ETHERADDR_GARBAGE_STRS_SIZE; i++) {
+       for (i = 0; i < RTE_DIM(ether_addr_garbage_strs); i++) {
 
                memset(&result, 0, sizeof(struct rte_ether_addr));
 

diff --git a/app/test/test_cmdline_ipaddr.c b/app/test/test_cmdline_ipaddr.c
index 088cd5a..b3f50d8 100644 (file)
--- a/app/test/test_cmdline_ipaddr.c
+++ b/app/test/test_cmdline_ipaddr.c
@@ -262,19 +262,6 @@ const char * ipaddr_invalid_strs[] = {
                " ",
 };
 
-#define IPADDR_VALID_STRS_SIZE \
-       (sizeof(ipaddr_valid_strs) / sizeof(ipaddr_valid_strs[0]))
-#define IPADDR_GARBAGE_ADDR4_STRS_SIZE \
-       (sizeof(ipaddr_garbage_addr4_strs) / sizeof(ipaddr_garbage_addr4_strs[0]))
-#define IPADDR_GARBAGE_ADDR6_STRS_SIZE \
-       (sizeof(ipaddr_garbage_addr6_strs) / sizeof(ipaddr_garbage_addr6_strs[0]))
-#define IPADDR_GARBAGE_NETWORK4_STRS_SIZE \
-       (sizeof(ipaddr_garbage_network4_strs) / sizeof(ipaddr_garbage_network4_strs[0]))
-#define IPADDR_GARBAGE_NETWORK6_STRS_SIZE \
-       (sizeof(ipaddr_garbage_network6_strs) / sizeof(ipaddr_garbage_network6_strs[0]))
-#define IPADDR_INVALID_STRS_SIZE \
-       (sizeof(ipaddr_invalid_strs) / sizeof(ipaddr_invalid_strs[0]))
-
 static void
 dump_addr(cmdline_ipaddr_t addr)
 {
@@ -367,7 +354,7 @@ test_parse_ipaddr_valid(void)
        }
 
        /* test valid strings */
-       for (i = 0; i < IPADDR_VALID_STRS_SIZE; i++) {
+       for (i = 0; i < RTE_DIM(ipaddr_valid_strs); i++) {
 
                /* test each valid string against different flags */
                for (flags = 1; flags < 0x8; flags++) {
@@ -415,7 +402,7 @@ test_parse_ipaddr_valid(void)
        }
 
        /* test garbage ipv4 address strings */
-       for (i = 0; i < IPADDR_GARBAGE_ADDR4_STRS_SIZE; i++) {
+       for (i = 0; i < RTE_DIM(ipaddr_garbage_addr4_strs); i++) {
 
                struct in_addr tmp = IPv4_GARBAGE_ADDR;
 
@@ -457,7 +444,7 @@ test_parse_ipaddr_valid(void)
        }
 
        /* test garbage ipv6 address strings */
-       for (i = 0; i < IPADDR_GARBAGE_ADDR6_STRS_SIZE; i++) {
+       for (i = 0; i < RTE_DIM(ipaddr_garbage_addr6_strs); i++) {
 
                cmdline_ipaddr_t tmp = {.addr = IPv6_GARBAGE_ADDR};
 
@@ -500,7 +487,7 @@ test_parse_ipaddr_valid(void)
 
 
        /* test garbage ipv4 network strings */
-       for (i = 0; i < IPADDR_GARBAGE_NETWORK4_STRS_SIZE; i++) {
+       for (i = 0; i < RTE_DIM(ipaddr_garbage_network4_strs); i++) {
 
                struct in_addr tmp = IPv4_GARBAGE_ADDR;
 
@@ -542,7 +529,7 @@ test_parse_ipaddr_valid(void)
        }
 
        /* test garbage ipv6 address strings */
-       for (i = 0; i < IPADDR_GARBAGE_NETWORK6_STRS_SIZE; i++) {
+       for (i = 0; i < RTE_DIM(ipaddr_garbage_network6_strs); i++) {
 
                cmdline_ipaddr_t tmp = {.addr = IPv6_GARBAGE_ADDR};
 
@@ -599,7 +586,7 @@ test_parse_ipaddr_invalid_data(void)
        memset(&result, 0, sizeof(result));
 
        /* test invalid strings */
-       for (i = 0; i < IPADDR_INVALID_STRS_SIZE; i++) {
+       for (i = 0; i < RTE_DIM(ipaddr_invalid_strs); i++) {
 
                /* test each valid string against different flags */
                for (flags = 1; flags < 0x8; flags++) {

diff --git a/app/test/test_cmdline_num.c b/app/test/test_cmdline_num.c
index 4c97caf..a6ad955 100644 (file)
--- a/app/test/test_cmdline_num.c
+++ b/app/test/test_cmdline_num.c
@@ -216,19 +216,6 @@ const char * num_invalid_strs[] = {
                "\0",
 };
 
-#define NUM_POSITIVE_STRS_SIZE \
-       (sizeof(num_valid_positive_strs) / sizeof(num_valid_positive_strs[0]))
-#define NUM_NEGATIVE_STRS_SIZE \
-       (sizeof(num_valid_negative_strs) / sizeof(num_valid_negative_strs[0]))
-#define NUM_POSITIVE_GARBAGE_STRS_SIZE \
-       (sizeof(num_garbage_positive_strs) / sizeof(num_garbage_positive_strs[0]))
-#define NUM_NEGATIVE_GARBAGE_STRS_SIZE \
-       (sizeof(num_garbage_negative_strs) / sizeof(num_garbage_negative_strs[0]))
-#define NUM_INVALID_STRS_SIZE \
-       (sizeof(num_invalid_strs) / sizeof(num_invalid_strs[0]))
-
-
-
 static int
 can_parse_unsigned(uint64_t expected_result, enum cmdline_numtype type)
 {
@@ -392,7 +379,7 @@ test_parse_num_invalid_data(void)
                token.num_data.type = type;
 
                /* test full strings */
-               for (i = 0; i < NUM_INVALID_STRS_SIZE; i++) {
+               for (i = 0; i < RTE_DIM(num_invalid_strs); i++) {
 
                        memset(&result, 0, sizeof(uint64_t));
                        memset(&buf, 0, sizeof(buf));
@@ -431,7 +418,7 @@ test_parse_num_valid(void)
                token.num_data.type = type;
 
                /* test positive strings */
-               for (i = 0; i < NUM_POSITIVE_STRS_SIZE; i++) {
+               for (i = 0; i < RTE_DIM(num_valid_positive_strs); i++) {
                        result = 0;
                        memset(&buf, 0, sizeof(buf));
 
@@ -459,7 +446,7 @@ test_parse_num_valid(void)
                }
 
                /* test negative strings */
-               for (i = 0; i < NUM_NEGATIVE_STRS_SIZE; i++) {
+               for (i = 0; i < RTE_DIM(num_valid_negative_strs); i++) {
                        result = 0;
                        memset(&buf, 0, sizeof(buf));
 
@@ -509,7 +496,7 @@ test_parse_num_valid(void)
                token.num_data.type = type;
 
                /* test positive garbage strings */
-               for (i = 0; i < NUM_POSITIVE_GARBAGE_STRS_SIZE; i++) {
+               for (i = 0; i < RTE_DIM(num_garbage_positive_strs); i++) {
                        result = 0;
                        memset(&buf, 0, sizeof(buf));
 
@@ -537,7 +524,7 @@ test_parse_num_valid(void)
                }
 
                /* test negative strings */
-               for (i = 0; i < NUM_NEGATIVE_GARBAGE_STRS_SIZE; i++) {
+               for (i = 0; i < RTE_DIM(num_garbage_negative_strs); i++) {
                        result = 0;
                        memset(&buf, 0, sizeof(buf));
 

diff --git a/app/test/test_cmdline_portlist.c b/app/test/test_cmdline_portlist.c
index 0dc6d00..fd35421 100644 (file)
--- a/app/test/test_cmdline_portlist.c
+++ b/app/test/test_cmdline_portlist.c
@@ -6,6 +6,8 @@
 #include <string.h>
 #include <inttypes.h>
 
+#include <rte_common.h>
+
 #include <cmdline_parse.h>
 #include <cmdline_parse_portlist.h>
 
@@ -88,16 +90,6 @@ const char * portlist_invalid_strs[] = {
                "0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,2",
 };
 
-#define PORTLIST_VALID_STRS_SIZE \
-       (sizeof(portlist_valid_strs) / sizeof(portlist_valid_strs[0]))
-#define PORTLIST_GARBAGE_STRS_SIZE \
-       (sizeof(portlist_garbage_strs) / sizeof(portlist_garbage_strs[0]))
-#define PORTLIST_INVALID_STRS_SIZE \
-       (sizeof(portlist_invalid_strs) / sizeof(portlist_invalid_strs[0]))
-
-
-
-
 /* test invalid parameters */
 int
 test_parse_portlist_invalid_param(void)
@@ -155,7 +147,7 @@ test_parse_portlist_invalid_data(void)
        cmdline_portlist_t result;
 
        /* test invalid strings */
-       for (i = 0; i < PORTLIST_INVALID_STRS_SIZE; i++) {
+       for (i = 0; i < RTE_DIM(portlist_invalid_strs); i++) {
 
                memset(&result, 0, sizeof(cmdline_portlist_t));
 
@@ -180,7 +172,7 @@ test_parse_portlist_valid(void)
        cmdline_portlist_t result;
 
        /* test full strings */
-       for (i = 0; i < PORTLIST_VALID_STRS_SIZE; i++) {
+       for (i = 0; i < RTE_DIM(portlist_valid_strs); i++) {
 
                memset(&result, 0, sizeof(cmdline_portlist_t));
 
@@ -199,7 +191,7 @@ test_parse_portlist_valid(void)
        }
 
        /* test garbage strings */
-       for (i = 0; i < PORTLIST_GARBAGE_STRS_SIZE; i++) {
+       for (i = 0; i < RTE_DIM(portlist_garbage_strs); i++) {
 
                memset(&result, 0, sizeof(cmdline_portlist_t));
 

diff --git a/app/test/test_cmdline_string.c b/app/test/test_cmdline_string.c
index 0461a85..97516c9 100644 (file)
--- a/app/test/test_cmdline_string.c
+++ b/app/test/test_cmdline_string.c
@@ -113,19 +113,6 @@ const char * string_help_strs[] = {
                "multi#str",
 };
 
-
-
-#define STRING_PARSE_STRS_SIZE \
-       (sizeof(string_parse_strs) / sizeof(string_parse_strs[0]))
-#define STRING_HELP_STRS_SIZE \
-       (sizeof(string_help_strs) / sizeof(string_help_strs[0]))
-#define STRING_ELT_STRS_SIZE \
-       (sizeof(string_elt_strs) / sizeof(string_elt_strs[0]))
-#define STRING_NB_STRS_SIZE \
-       (sizeof(string_nb_strs) / sizeof(string_nb_strs[0]))
-#define STRING_INVALID_STRS_SIZE \
-       (sizeof(string_invalid_strs) / sizeof(string_invalid_strs[0]))
-
 #define SMALL_BUF 8
 
 /* test invalid parameters */
@@ -203,7 +190,7 @@ test_parse_string_invalid_data(void)
        unsigned i;
 
        /* test parsing invalid strings */
-       for (i = 0; i < STRING_INVALID_STRS_SIZE; i++) {
+       for (i = 0; i < RTE_DIM(string_invalid_strs); i++) {
                memset(&token, 0, sizeof(token));
                memset(buf, 0, sizeof(buf));
 
@@ -302,7 +289,7 @@ test_parse_string_valid(void)
        unsigned i;
 
        /* test parsing strings */
-       for (i = 0; i < STRING_PARSE_STRS_SIZE; i++) {
+       for (i = 0; i < RTE_DIM(string_parse_strs); i++) {
                memset(&token, 0, sizeof(token));
                memset(buf, 0, sizeof(buf));
 
@@ -334,7 +321,7 @@ test_parse_string_valid(void)
        }
 
        /* get number of string tokens and verify it's correct */
-       for (i = 0; i < STRING_NB_STRS_SIZE; i++) {
+       for (i = 0; i < RTE_DIM(string_nb_strs); i++) {
                memset(&token, 0, sizeof(token));
 
                token.string_data.str = string_nb_strs[i].str;
@@ -348,7 +335,7 @@ test_parse_string_valid(void)
        }
 
        /* get token at specified position and verify it's correct */
-       for (i = 0; i < STRING_ELT_STRS_SIZE; i++) {
+       for (i = 0; i < RTE_DIM(string_elt_strs); i++) {
                memset(&token, 0, sizeof(token));
                memset(buf, 0, sizeof(buf));
 
@@ -368,7 +355,7 @@ test_parse_string_valid(void)
        }
 
        /* cover all cases with help strings */
-       for (i = 0; i < STRING_HELP_STRS_SIZE; i++) {
+       for (i = 0; i < RTE_DIM(string_help_strs); i++) {
                memset(&help_token, 0, sizeof(help_token));
                memset(help_str, 0, sizeof(help_str));
                help_token.string_data.str = string_help_strs[i];

diff --git a/app/test/test_debug.c b/app/test/test_debug.c
index faf2cf5..25eab97 100644 (file)
--- a/app/test/test_debug.c
+++ b/app/test/test_debug.c
@@ -81,7 +81,7 @@ test_exit(void)
 {
        int test_vals[] = { 0, 1, 2, 255, -1 };
        unsigned i;
-       for (i = 0; i < sizeof(test_vals) / sizeof(test_vals[0]); i++){
+       for (i = 0; i < RTE_DIM(test_vals); i++) {
                if (test_exit_val(test_vals[i]) < 0)
                        return -1;
        }

diff --git a/app/test/test_eal_flags.c b/app/test/test_eal_flags.c
index 5b2c0f5..4ee809e 100644 (file)
--- a/app/test/test_eal_flags.c
+++ b/app/test/test_eal_flags.c
@@ -36,8 +36,7 @@
 #define memtest1 "memtest1"
 #define memtest2 "memtest2"
 #define SOCKET_MEM_STRLEN (RTE_MAX_NUMA_NODES * 20)
-#define launch_proc(ARGV) process_dup(ARGV, \
-               sizeof(ARGV)/(sizeof(ARGV[0])), __func__)
+#define launch_proc(ARGV) process_dup(ARGV, RTE_DIM(ARGV), __func__)
 
 enum hugepage_action {
        HUGEPAGE_CHECK_EXISTS = 0,
@@ -268,7 +267,7 @@ test_whitelist_flag(void)
                        pci_whitelist, "08:00.1,type=normal",
        };
 
-       for (i = 0; i < sizeof(wlinval) / sizeof(wlinval[0]); i++) {
+       for (i = 0; i < RTE_DIM(wlinval); i++) {
                if (launch_proc(wlinval[i]) == 0) {
                        printf("Error - process did run ok with invalid "
                            "whitelist parameter\n");
@@ -324,7 +323,7 @@ test_invalid_b_flag(void)
 
        int i;
 
-       for (i = 0; i != sizeof (blinval) / sizeof (blinval[0]); i++) {
+       for (i = 0; i != RTE_DIM(blinval); i++) {
                if (launch_proc(blinval[i]) == 0) {
                        printf("Error - process did run ok with invalid "
                            "blacklist parameter\n");
@@ -425,7 +424,7 @@ test_invalid_r_flag(void)
 
        int i;
 
-       for (i = 0; i != sizeof (rinval) / sizeof (rinval[0]); i++) {
+       for (i = 0; i != RTE_DIM(rinval); i++) {
                if (launch_proc(rinval[i]) == 0) {
                        printf("Error - process did run ok with invalid "
                            "-r (rank) parameter\n");

diff --git a/app/test/test_errno.c b/app/test/test_errno.c
index 7df8192..3ff0456 100644 (file)
--- a/app/test/test_errno.c
+++ b/app/test/test_errno.c
@@ -36,7 +36,7 @@ test_errno(void)
        if (rte_errno != 0)
                return -1;
        /* check for standard errors we return the same as libc */
-       for (i = 0; i < sizeof(std_errs)/sizeof(std_errs[0]); i++){
+       for (i = 0; i < RTE_DIM(std_errs); i++) {
                rte_retval = rte_strerror(std_errs[i]);
                libc_retval = strerror(std_errs[i]);
                printf("rte_strerror: '%s', strerror: '%s'\n",
@@ -47,7 +47,7 @@ test_errno(void)
        /* for rte-specific errors ensure we return a different string
         * and that the string for libc is for an unknown error
         */
-       for (i = 0; i < sizeof(rte_errs)/sizeof(rte_errs[0]); i++){
+       for (i = 0; i < RTE_DIM(rte_errs); i++) {
                rte_retval = rte_strerror(rte_errs[i]);
                libc_retval = strerror(rte_errs[i]);
                printf("rte_strerror: '%s', strerror: '%s'\n",

diff --git a/app/test/test_func_reentrancy.c b/app/test/test_func_reentrancy.c
index 99ad902..596d395 100644 (file)
--- a/app/test/test_func_reentrancy.c
+++ b/app/test/test_func_reentrancy.c
@@ -480,7 +480,7 @@ test_func_reentrancy(void)
        else if (rte_lcore_count() > MAX_LCORES)
                printf("Too many lcores, some cores will be disabled\n");
 
-       for (case_id = 0; case_id < sizeof(test_cases)/sizeof(struct test_case); case_id ++) {
+       for (case_id = 0; case_id < RTE_DIM(test_cases); case_id++) {
                pt_case = &test_cases[case_id];
                if (pt_case->func == NULL)
                        continue;

diff --git a/app/test/test_hash.c b/app/test/test_hash.c
index 0052dce..fbd5725 100644 (file)
--- a/app/test/test_hash.c
+++ b/app/test/test_hash.c
@@ -235,15 +235,9 @@ static void run_hash_func_tests(void)
 {
        unsigned i, j, k;
 
-       for (i = 0;
-            i < sizeof(hashtest_funcs) / sizeof(rte_hash_function);
-            i++) {
-               for (j = 0;
-                    j < sizeof(hashtest_initvals) / sizeof(uint32_t);
-                    j++) {
-                       for (k = 0;
-                            k < sizeof(hashtest_key_lens) / sizeof(uint32_t);
-                            k++) {
+       for (i = 0; i < RTE_DIM(hashtest_funcs); i++) {
+               for (j = 0; j < RTE_DIM(hashtest_initvals); j++) {
+                       for (k = 0; k < RTE_DIM(hashtest_key_lens); k++) {
                                run_hash_func_test(hashtest_funcs[i],
                                                hashtest_initvals[j],
                                                hashtest_key_lens[k]);

diff --git a/app/test/test_hash_functions.c b/app/test/test_hash_functions.c
index c1fc949..76d51b6 100644 (file)
--- a/app/test/test_hash_functions.c
+++ b/app/test/test_hash_functions.c
@@ -152,10 +152,10 @@ verify_precalculated_hash_func_tests(void)
        for (i = 0; i < 64; i++)
                key[i] = (uint8_t) i;
 
-       for (i = 0; i < sizeof(hashtest_key_lens) / sizeof(uint32_t); i++) {
-               for (j = 0; j < sizeof(hashtest_initvals) / sizeof(uint32_t); j++) {
+       for (i = 0; i < RTE_DIM(hashtest_key_lens); i++) {
+               for (j = 0; j < RTE_DIM(hashtest_initvals); j++) {
                        hash = rte_jhash(key, hashtest_key_lens[i],
-                                       hashtest_initvals[j]);
+                                        hashtest_initvals[j]);
                        if (hash != hash_values_jhash[j][i]) {
                                printf("jhash for %u bytes with initial value 0x%x."
                                       "Expected 0x%x, but got 0x%x\n",
@@ -192,8 +192,8 @@ verify_jhash_32bits(void)
        for (i = 0; i < 64; i++)
                key[i] = rand() & 0xff;
 
-       for (i = 0; i < sizeof(hashtest_key_lens) / sizeof(uint32_t); i++) {
-               for (j = 0; j < sizeof(hashtest_initvals) / sizeof(uint32_t); j++) {
+       for (i = 0; i < RTE_DIM(hashtest_key_lens); i++) {
+               for (j = 0; j < RTE_DIM(hashtest_initvals); j++) {
                        /* Key size must be multiple of 4 (32 bits) */
                        if ((hashtest_key_lens[i] & 0x3) == 0) {
                                hash = rte_jhash(key, hashtest_key_lens[i],

diff --git a/app/test/test_lpm.c b/app/test/test_lpm.c
index e969fe0..3a3fd09 100644 (file)
--- a/app/test/test_lpm.c
+++ b/app/test/test_lpm.c
@@ -64,7 +64,6 @@ rte_lpm_test tests[] = {
        test18
 };
 
-#define NUM_LPM_TESTS (sizeof(tests)/sizeof(tests[0]))
 #define MAX_DEPTH 32
 #define MAX_RULES 256
 #define NUMBER_TBL8S 256
@@ -1276,7 +1275,7 @@ 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 %u: FAIL\n", i);

diff --git a/app/test/test_lpm6.c b/app/test/test_lpm6.c
index 670aadb..0d66454 100644 (file)
--- a/app/test/test_lpm6.c
+++ b/app/test/test_lpm6.c
@@ -85,7 +85,6 @@ rte_lpm6_test tests6[] = {
        test28,
 };
 
-#define NUM_LPM6_TESTS                (sizeof(tests6)/sizeof(tests6[0]))
 #define MAX_DEPTH                                                    128
 #define MAX_RULES                                                1000000
 #define NUMBER_TBL8S                                           (1 << 16)
@@ -1780,7 +1779,7 @@ test_lpm6(void)
        unsigned i;
        int status = -1, global_status = 0;
 
-       for (i = 0; i < NUM_LPM6_TESTS; i++) {
+       for (i = 0; i < RTE_DIM(tests6); i++) {
                printf("# test %02d\n", i);
                status = tests6[i]();
 

diff --git a/app/test/test_lpm6_data.h b/app/test/test_lpm6_data.h
index 565138a..c3894f7 100644 (file)
--- a/app/test/test_lpm6_data.h
+++ b/app/test/test_lpm6_data.h
@@ -1029,8 +1029,7 @@ static struct rules_tbl_entry large_route_table[] = {
        {{234, 149, 220, 106, 0, 144, 214, 128, 35, 102, 0, 0, 0, 0, 0, 0}, 79, 106},
 };
 
-#define  NUM_ROUTE_ENTRIES \
-       (sizeof(large_route_table) / sizeof(large_route_table[0]))
+#define  NUM_ROUTE_ENTRIES RTE_DIM(large_route_table)
 
 #define  NUM_IPS_ENTRIES (NUM_ROUTE_ENTRIES * 100)
 

diff --git a/app/test/test_malloc.c b/app/test/test_malloc.c
index a16e28c..67a48ba 100644 (file)
--- a/app/test/test_malloc.c
+++ b/app/test/test_malloc.c
@@ -255,7 +255,7 @@ test_str_to_size(void)
                        {"18446744073709551616", 0} /* ULLONG_MAX + 1 == out of range*/
        };
        unsigned i;
-       for (i = 0; i < sizeof(test_values)/sizeof(test_values[0]); i++)
+       for (i = 0; i < RTE_DIM(test_values); i++)
                if (rte_str_to_size(test_values[i].str) != test_values[i].value)
                        return -1;
        return 0;

diff --git a/app/test/test_memcpy.c b/app/test/test_memcpy.c
index 2c69ad9..1ab86f4 100644 (file)
--- a/app/test/test_memcpy.c
+++ b/app/test/test_memcpy.c
@@ -103,12 +103,11 @@ static int
 func_test(void)
 {
        unsigned int off_src, off_dst, i;
-       unsigned int num_buf_sizes = sizeof(buf_sizes) / sizeof(buf_sizes[0]);
        int ret;
 
        for (off_src = 0; off_src < ALIGNMENT_UNIT; off_src++) {
                for (off_dst = 0; off_dst < ALIGNMENT_UNIT; off_dst++) {
-                       for (i = 0; i < num_buf_sizes; i++) {
+                       for (i = 0; i < RTE_DIM(buf_sizes); i++) {
                                ret = test_single_memcpy(off_src, off_dst,
                                                         buf_sizes[i]);
                                if (ret != 0)

diff --git a/app/test/test_memcpy_perf.c b/app/test/test_memcpy_perf.c
index 6f436f3..00a2092 100644 (file)
--- a/app/test/test_memcpy_perf.c
+++ b/app/test/test_memcpy_perf.c
@@ -250,9 +250,8 @@ perf_test_constant_unaligned(void)
 static inline void
 perf_test_variable_aligned(void)
 {
-       unsigned n = sizeof(buf_sizes) / sizeof(buf_sizes[0]);
        unsigned i;
-       for (i = 0; i < n; i++) {
+       for (i = 0; i < RTE_DIM(buf_sizes); i++) {
                ALL_PERF_TESTS_FOR_SIZE((size_t)buf_sizes[i]);
        }
 }
@@ -261,9 +260,8 @@ perf_test_variable_aligned(void)
 static inline void
 perf_test_variable_unaligned(void)
 {
-       unsigned n = sizeof(buf_sizes) / sizeof(buf_sizes[0]);
        unsigned i;
-       for (i = 0; i < n; i++) {
+       for (i = 0; i < RTE_DIM(buf_sizes); i++) {
                ALL_PERF_TESTS_FOR_SIZE_UNALIGNED((size_t)buf_sizes[i]);
        }
 }

diff --git a/app/test/test_mp_secondary.c b/app/test/test_mp_secondary.c
index 2ac33f7..ac15ddb 100644 (file)
--- a/app/test/test_mp_secondary.c
+++ b/app/test/test_mp_secondary.c
@@ -47,8 +47,7 @@
 
 #include "process.h"
 
-#define launch_proc(ARGV) process_dup(ARGV, \
-               sizeof(ARGV)/(sizeof(ARGV[0])), __func__)
+#define launch_proc(ARGV) process_dup(ARGV, RTE_DIM(ARGV), __func__)
 
 /*
  * This function is called in the primary i.e. main test, to spawn off secondary

diff --git a/app/test/test_pdump.c b/app/test/test_pdump.c
index af20696..ad18318 100644 (file)
--- a/app/test/test_pdump.c
+++ b/app/test/test_pdump.c
@@ -18,8 +18,7 @@
 #include "process.h"
 #include "test_pdump.h"
 
-#define launch_p(ARGV) process_dup(ARGV, \
-               sizeof(ARGV)/(sizeof(ARGV[0])), __func__)
+#define launch_p(ARGV) process_dup(ARGV, RTE_DIM(ARGV), __func__)
 
 struct rte_ring *ring_server;
 uint16_t portid;

diff --git a/app/test/test_pmd_ring_perf.c b/app/test/test_pmd_ring_perf.c
index 6318da1..3b2ff9c 100644 (file)
--- a/app/test/test_pmd_ring_perf.c
+++ b/app/test/test_pmd_ring_perf.c
@@ -100,7 +100,7 @@ test_bulk_enqueue_dequeue(void)
        unsigned sz, i = 0;
        struct rte_mbuf *burst[MAX_BURST] = {0};
 
-       for (sz = 0; sz < sizeof(bulk_sizes)/sizeof(bulk_sizes[0]); sz++) {
+       for (sz = 0; sz < RTE_DIM(bulk_sizes); sz++) {
                const uint64_t sc_start = rte_rdtsc();
                for (i = 0; i < iterations; i++) {
                        rte_ring_sp_enqueue_bulk(r, (void *)burst,

diff --git a/app/test/test_power.c b/app/test/test_power.c
index 0ff2aa0..0c597c3 100644 (file)
--- a/app/test/test_power.c
+++ b/app/test/test_power.c
@@ -135,10 +135,8 @@ test_power(void)
                        PM_ENV_KVM_VM,
                        PM_ENV_PSTATE_CPUFREQ};
 
-       const int envs_size = sizeof(envs)/sizeof(enum power_management_env);
-
-       int i;
-       for (i = 0; i < envs_size; ++i) {
+       unsigned int i;
+       for (i = 0; i < RTE_DIM(envs); ++i) {
 
                /* Test setting a valid environment */
                ret = rte_power_set_env(envs[i]);

diff --git a/app/test/test_ring_perf.c b/app/test/test_ring_perf.c
index ce23ee7..ee21faf 100644 (file)
--- a/app/test/test_ring_perf.c
+++ b/app/test/test_ring_perf.c
@@ -293,7 +293,7 @@ run_on_core_pair(struct lcore_pair *cores, struct rte_ring *r, const int esize)
                f2 = dequeue_bulk_16B;
        }
 
-       for (i = 0; i < sizeof(bulk_sizes)/sizeof(bulk_sizes[0]); i++) {
+       for (i = 0; i < RTE_DIM(bulk_sizes); i++) {
                lcore_count = 0;
                param1.size = param2.size = bulk_sizes[i];
                param1.r = param2.r = r;

diff --git a/app/test/test_timer_secondary.c b/app/test/test_timer_secondary.c
index 790f180..7a3bc87 100644 (file)
--- a/app/test/test_timer_secondary.c
+++ b/app/test/test_timer_secondary.c
@@ -23,8 +23,7 @@
 #define TEST_INFO_MZ_NAME      "test_timer_info_mz"
 #define MSECPERSEC             1E3
 
-#define launch_proc(ARGV) \
-       process_dup(ARGV, sizeof(ARGV)/(sizeof(ARGV[0])), __func__)
+#define launch_proc(ARGV) process_dup(ARGV, RTE_DIM(ARGV), __func__)
 
 struct test_info {
        unsigned int mstr_lcore;