From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from foss.arm.com (usa-sjc-mx-foss1.foss.arm.com [217.140.101.70]) by dpdk.org (Postfix) with ESMTP id 454132C6D for ; Fri, 22 Feb 2019 08:05:12 +0100 (CET) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.72.51.249]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 9DBD115AB; Thu, 21 Feb 2019 23:05:11 -0800 (PST) Received: from qc2400f-1.austin.arm.com (qc2400f-1.austin.arm.com [10.118.12.104]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 2534C3F690; Thu, 21 Feb 2019 23:05:11 -0800 (PST) From: Honnappa Nagarahalli To: konstantin.ananyev@intel.com, stephen@networkplumber.org, paulmck@linux.ibm.com, dev@dpdk.org, honnappa.nagarahalli@arm.com Cc: gavin.hu@arm.com, dharmik.thakkar@arm.com, malvika.gupta@arm.com, nd@arm.com Date: Fri, 22 Feb 2019 01:04:26 -0600 Message-Id: <20190222070427.22866-5-honnappa.nagarahalli@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190222070427.22866-1-honnappa.nagarahalli@arm.com> References: <20181222021420.5114-1-honnappa.nagarahalli@arm.com> <20190222070427.22866-1-honnappa.nagarahalli@arm.com> Subject: [dpdk-dev] [RFC v3 4/5] test/rcu_qsbr: modify test cases for dynamic memory allocation X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 22 Feb 2019 07:05:13 -0000 Modify the test cases to allocate the QSBR variable dynamically. Signed-off-by: Honnappa Nagarahalli --- test/test/test_rcu_qsbr.c | 225 ++++++++++++++++++--------------- test/test/test_rcu_qsbr_perf.c | 33 ++--- 2 files changed, 144 insertions(+), 114 deletions(-) diff --git a/test/test/test_rcu_qsbr.c b/test/test/test_rcu_qsbr.c index ae60614af..09744279f 100644 --- a/test/test/test_rcu_qsbr.c +++ b/test/test/test_rcu_qsbr.c @@ -15,7 +15,7 @@ #include "test.h" /* Check condition and return an error if true. */ -#define RCU_QSBR_RETURN_IF_ERROR(cond, str, ...) do { \ +#define TEST_RCU_QSBR_RETURN_IF_ERROR(cond, str, ...) do { \ if (cond) { \ printf("ERROR file %s, line %d: " str "\n", __FILE__, \ __LINE__, ##__VA_ARGS__); \ @@ -23,8 +23,8 @@ } \ } while (0) -#define RTE_RCU_MAX_LCORE 128 -uint16_t enabled_core_ids[RTE_RCU_MAX_LCORE]; +#define TEST_RCU_MAX_LCORE 128 +uint16_t enabled_core_ids[TEST_RCU_MAX_LCORE]; uint8_t num_cores; uint16_t num_1qs = 1; /* Number of quiescent states = 1 */ uint16_t num_2qs = 2; /* Number of quiescent states = 2 */ @@ -33,20 +33,20 @@ uint16_t num_3qs = 3; /* Number of quiescent states = 3 */ static uint32_t *keys; #define TOTAL_ENTRY (1024 * 8) #define COUNTER_VALUE 4096 -uint32_t *hash_data[RTE_RCU_MAX_LCORE][TOTAL_ENTRY]; +uint32_t *hash_data[TEST_RCU_MAX_LCORE][TOTAL_ENTRY]; uint8_t writer_done; -struct rte_rcu_qsbr t[RTE_RCU_MAX_LCORE]; -struct rte_hash *h[RTE_RCU_MAX_LCORE]; -char hash_name[RTE_RCU_MAX_LCORE][8]; +static struct rte_rcu_qsbr *t[TEST_RCU_MAX_LCORE]; +struct rte_hash *h[TEST_RCU_MAX_LCORE]; +char hash_name[TEST_RCU_MAX_LCORE][8]; static inline int get_enabled_cores_mask(void) { uint16_t core_id; uint32_t max_cores = rte_lcore_count(); - if (max_cores > RTE_RCU_MAX_LCORE) { - printf("Number of cores exceed %d\n", RTE_RCU_MAX_LCORE); + if (max_cores > TEST_RCU_MAX_LCORE) { + printf("Number of cores exceed %d\n", TEST_RCU_MAX_LCORE); return -1; } @@ -60,6 +60,30 @@ get_enabled_cores_mask(void) return 0; } +/* + * rte_rcu_qsbr_register_thread: Add a reader thread, to the list of threads + * reporting their quiescent state on a QS variable. + */ +static int +test_rcu_qsbr_get_memsize(void) +{ + uint32_t sz; + + printf("\nTest rte_rcu_qsbr_register_thread()\n"); + + sz = rte_rcu_qsbr_get_memsize(TEST_RCU_MAX_LCORE); + t[0] = (struct rte_rcu_qsbr *)rte_zmalloc("rcu0", sz, + RTE_CACHE_LINE_SIZE); + t[1] = (struct rte_rcu_qsbr *)rte_zmalloc("rcu1", sz, + RTE_CACHE_LINE_SIZE); + t[2] = (struct rte_rcu_qsbr *)rte_zmalloc("rcu2", sz, + RTE_CACHE_LINE_SIZE); + t[3] = (struct rte_rcu_qsbr *)rte_zmalloc("rcu3", sz, + RTE_CACHE_LINE_SIZE); + + return 0; +} + /* * rte_rcu_qsbr_register_thread: Add a reader thread, to the list of threads * reporting their quiescent state on a QS variable. @@ -69,9 +93,9 @@ test_rcu_qsbr_register_thread(void) { printf("\nTest rte_rcu_qsbr_register_thread()\n"); - rte_rcu_qsbr_init(&t[0]); + rte_rcu_qsbr_init(t[0], TEST_RCU_MAX_LCORE); - rte_rcu_qsbr_register_thread(&t[0], enabled_core_ids[0]); + rte_rcu_qsbr_register_thread(t[0], enabled_core_ids[0]); return 0; } @@ -84,68 +108,68 @@ test_rcu_qsbr_unregister_thread(void) { int i, j, ret; uint64_t token; - uint8_t num_threads[3] = {1, RTE_RCU_MAX_THREADS, 1}; + uint8_t num_threads[3] = {1, TEST_RCU_MAX_LCORE, 1}; printf("\nTest rte_rcu_qsbr_unregister_thread()\n"); - rte_rcu_qsbr_init(&t[0]); + rte_rcu_qsbr_init(t[0], TEST_RCU_MAX_LCORE); - rte_rcu_qsbr_register_thread(&t[0], enabled_core_ids[0]); + rte_rcu_qsbr_register_thread(t[0], enabled_core_ids[0]); /* Find first disabled core */ - for (i = 0; i < RTE_RCU_MAX_LCORE; i++) { + for (i = 0; i < TEST_RCU_MAX_LCORE; i++) { if (enabled_core_ids[i] == 0) break; } /* Test with disabled lcore */ - rte_rcu_qsbr_unregister_thread(&t[0], i); + rte_rcu_qsbr_unregister_thread(t[0], i); /* Test with enabled lcore */ - rte_rcu_qsbr_unregister_thread(&t[0], enabled_core_ids[0]); + rte_rcu_qsbr_unregister_thread(t[0], enabled_core_ids[0]); /* * Test with different thread_ids: * 1 - thread_id = 0 - * 2 - All possible thread_ids, from 0 to RTE_RCU_MAX_THREADS - * 3 - thread_id = RTE_RCU_MAX_THREADS - 1 + * 2 - All possible thread_ids, from 0 to TEST_RCU_MAX_LCORE + * 3 - thread_id = TEST_RCU_MAX_LCORE - 1 */ for (j = 0; j < 3; j++) { - rte_rcu_qsbr_init(&t[0]); + rte_rcu_qsbr_init(t[0], TEST_RCU_MAX_LCORE); for (i = 0; i < num_threads[j]; i++) - rte_rcu_qsbr_register_thread(&t[0], - (j == 2) ? (RTE_RCU_MAX_THREADS - 1) : i); + rte_rcu_qsbr_register_thread(t[0], + (j == 2) ? (TEST_RCU_MAX_LCORE - 1) : i); - rte_rcu_qsbr_start(&t[0], 1, &token); - RCU_QSBR_RETURN_IF_ERROR((token != 1), "QSBR Start"); + rte_rcu_qsbr_start(t[0], 1, &token); + TEST_RCU_QSBR_RETURN_IF_ERROR((token != 1), "QSBR Start"); /* Update quiescent state counter */ for (i = 0; i < num_threads[j]; i++) { /* Skip one update */ - if (i == (RTE_RCU_MAX_THREADS - 10)) + if (i == (TEST_RCU_MAX_LCORE - 10)) continue; - rte_rcu_qsbr_update(&t[0], - (j == 2) ? (RTE_RCU_MAX_THREADS - 1) : i); + rte_rcu_qsbr_update(t[0], + (j == 2) ? (TEST_RCU_MAX_LCORE - 1) : i); } if (j == 1) { /* Validate the updates */ - ret = rte_rcu_qsbr_check(&t[0], token, false); - RCU_QSBR_RETURN_IF_ERROR((ret == 1), "Non-blocking QSBR check"); + ret = rte_rcu_qsbr_check(t[0], token, false); + TEST_RCU_QSBR_RETURN_IF_ERROR((ret == 1), "Non-blocking QSBR check"); /* Update the previously skipped thread */ - rte_rcu_qsbr_update(&t[0], RTE_RCU_MAX_THREADS - 10); + rte_rcu_qsbr_update(t[0], TEST_RCU_MAX_LCORE - 10); } /* Validate the updates */ - ret = rte_rcu_qsbr_check(&t[0], token, false); - RCU_QSBR_RETURN_IF_ERROR((ret == 0), "Non-blocking QSBR check"); + ret = rte_rcu_qsbr_check(t[0], token, false); + TEST_RCU_QSBR_RETURN_IF_ERROR((ret == 0), "Non-blocking QSBR check"); for (i = 0; i < num_threads[j]; i++) - rte_rcu_qsbr_unregister_thread(&t[0], - (j == 2) ? (RTE_RCU_MAX_THREADS - 1) : i); + rte_rcu_qsbr_unregister_thread(t[0], + (j == 2) ? (TEST_RCU_MAX_LCORE - 1) : i); /* Check with no thread registered */ - ret = rte_rcu_qsbr_check(&t[0], token, true); - RCU_QSBR_RETURN_IF_ERROR((ret == 0), "Blocking QSBR check"); + ret = rte_rcu_qsbr_check(t[0], token, true); + TEST_RCU_QSBR_RETURN_IF_ERROR((ret == 0), "Blocking QSBR check"); } return 0; } @@ -162,13 +186,13 @@ test_rcu_qsbr_start(void) printf("\nTest rte_rcu_qsbr_start()\n"); - rte_rcu_qsbr_init(&t[0]); + rte_rcu_qsbr_init(t[0], TEST_RCU_MAX_LCORE); for (i = 0; i < 3; i++) - rte_rcu_qsbr_register_thread(&t[0], enabled_core_ids[i]); + rte_rcu_qsbr_register_thread(t[0], enabled_core_ids[i]); - rte_rcu_qsbr_start(&t[0], 1, &token); - RCU_QSBR_RETURN_IF_ERROR((token != 1), "QSBR Start"); + rte_rcu_qsbr_start(t[0], 1, &token); + TEST_RCU_QSBR_RETURN_IF_ERROR((token != 1), "QSBR Start"); return 0; } @@ -177,7 +201,7 @@ test_rcu_qsbr_check_reader(void *arg) { struct rte_rcu_qsbr *temp; uint8_t read_type = (uint8_t)((uintptr_t)arg); - temp = &t[read_type]; + temp = t[read_type]; /* Update quiescent state counter */ rte_rcu_qsbr_update(temp, enabled_core_ids[0]); @@ -198,50 +222,50 @@ test_rcu_qsbr_check(void) printf("\nTest rte_rcu_qsbr_check()\n"); - rte_rcu_qsbr_init(&t[0]); + rte_rcu_qsbr_init(t[0], TEST_RCU_MAX_LCORE); - rte_rcu_qsbr_start(&t[0], 1, &token); - RCU_QSBR_RETURN_IF_ERROR((token != 1), "QSBR Start"); + rte_rcu_qsbr_start(t[0], 1, &token); + TEST_RCU_QSBR_RETURN_IF_ERROR((token != 1), "QSBR Start"); - ret = rte_rcu_qsbr_check(&t[0], 0, false); - RCU_QSBR_RETURN_IF_ERROR((ret == 0), "Token = 0"); + ret = rte_rcu_qsbr_check(t[0], 0, false); + TEST_RCU_QSBR_RETURN_IF_ERROR((ret == 0), "Token = 0"); - ret = rte_rcu_qsbr_check(&t[0], token, true); - RCU_QSBR_RETURN_IF_ERROR((ret == 0), "Blocking QSBR check"); + ret = rte_rcu_qsbr_check(t[0], token, true); + TEST_RCU_QSBR_RETURN_IF_ERROR((ret == 0), "Blocking QSBR check"); for (i = 0; i < 3; i++) - rte_rcu_qsbr_register_thread(&t[0], enabled_core_ids[i]); + rte_rcu_qsbr_register_thread(t[0], enabled_core_ids[i]); - ret = rte_rcu_qsbr_check(&t[0], token, false); - RCU_QSBR_RETURN_IF_ERROR((ret == 0), "Non-blocking QSBR check"); + ret = rte_rcu_qsbr_check(t[0], token, false); + TEST_RCU_QSBR_RETURN_IF_ERROR((ret == 0), "Non-blocking QSBR check"); - rte_rcu_qsbr_start(&t[0], 1, &token); - RCU_QSBR_RETURN_IF_ERROR((token != 2), "QSBR Start"); + rte_rcu_qsbr_start(t[0], 1, &token); + TEST_RCU_QSBR_RETURN_IF_ERROR((token != 2), "QSBR Start"); - ret = rte_rcu_qsbr_check(&t[0], token, false); - RCU_QSBR_RETURN_IF_ERROR((ret == 1), "Non-blocking QSBR check"); + ret = rte_rcu_qsbr_check(t[0], token, false); + TEST_RCU_QSBR_RETURN_IF_ERROR((ret == 1), "Non-blocking QSBR check"); for (i = 0; i < 3; i++) - rte_rcu_qsbr_unregister_thread(&t[0], enabled_core_ids[i]); + rte_rcu_qsbr_unregister_thread(t[0], enabled_core_ids[i]); - ret = rte_rcu_qsbr_check(&t[0], token, true); - RCU_QSBR_RETURN_IF_ERROR((ret == 0), "Blocking QSBR check"); + ret = rte_rcu_qsbr_check(t[0], token, true); + TEST_RCU_QSBR_RETURN_IF_ERROR((ret == 0), "Blocking QSBR check"); - rte_rcu_qsbr_init(&t[0]); + rte_rcu_qsbr_init(t[0], TEST_RCU_MAX_LCORE); for (i = 0; i < 4; i++) - rte_rcu_qsbr_register_thread(&t[0], enabled_core_ids[i]); + rte_rcu_qsbr_register_thread(t[0], enabled_core_ids[i]); - rte_rcu_qsbr_start(&t[0], 1, &token); - RCU_QSBR_RETURN_IF_ERROR((token != 1), "QSBR Start"); + rte_rcu_qsbr_start(t[0], 1, &token); + TEST_RCU_QSBR_RETURN_IF_ERROR((token != 1), "QSBR Start"); rte_eal_remote_launch(test_rcu_qsbr_check_reader, NULL, enabled_core_ids[0]); rte_eal_mp_wait_lcore(); - ret = rte_rcu_qsbr_check(&t[0], token, true); - RCU_QSBR_RETURN_IF_ERROR((ret != 1), "Blocking QSBR check"); + ret = rte_rcu_qsbr_check(t[0], token, true); + TEST_RCU_QSBR_RETURN_IF_ERROR((ret != 1), "Blocking QSBR check"); return 0; } @@ -256,19 +280,19 @@ test_rcu_qsbr_dump(void) printf("\nTest rte_rcu_qsbr_dump()\n"); - rte_rcu_qsbr_init(&t[0]); - rte_rcu_qsbr_init(&t[1]); + rte_rcu_qsbr_init(t[0], TEST_RCU_MAX_LCORE); + rte_rcu_qsbr_init(t[1], TEST_RCU_MAX_LCORE); /* QS variable with 0 core mask */ - rte_rcu_qsbr_dump(stdout, &t[0]); + rte_rcu_qsbr_dump(stdout, t[0]); - rte_rcu_qsbr_register_thread(&t[0], enabled_core_ids[0]); + rte_rcu_qsbr_register_thread(t[0], enabled_core_ids[0]); for (i = 1; i < 3; i++) - rte_rcu_qsbr_register_thread(&t[1], enabled_core_ids[i]); + rte_rcu_qsbr_register_thread(t[1], enabled_core_ids[i]); - rte_rcu_qsbr_dump(stdout, &t[0]); - rte_rcu_qsbr_dump(stdout, &t[1]); + rte_rcu_qsbr_dump(stdout, t[0]); + rte_rcu_qsbr_dump(stdout, t[1]); printf("\n"); return 0; } @@ -283,7 +307,7 @@ test_rcu_qsbr_reader(void *arg) uint8_t read_type = (uint8_t)((uintptr_t)arg); uint32_t *pdata; - temp = &t[read_type]; + temp = t[read_type]; hash = h[read_type]; do { @@ -313,8 +337,8 @@ test_rcu_qsbr_writer(void *arg) struct rte_hash *hash = NULL; uint8_t writer_type = (uint8_t)((uintptr_t)arg); - temp = &t[(writer_type/2) % RTE_RCU_MAX_LCORE]; - hash = h[(writer_type/2) % RTE_RCU_MAX_LCORE]; + temp = t[(writer_type/2) % TEST_RCU_MAX_LCORE]; + hash = h[(writer_type/2) % TEST_RCU_MAX_LCORE]; /* Delete element from the shared data structure */ pos = rte_hash_del_key(hash, keys + (writer_type % TOTAL_ENTRY)); @@ -330,12 +354,12 @@ test_rcu_qsbr_writer(void *arg) rte_rcu_qsbr_start(temp, writer_type + 1, &token); /* Check the quiescent state status */ rte_rcu_qsbr_check(temp, token, true); - if (*hash_data[(writer_type/2) % RTE_RCU_MAX_LCORE] + if (*hash_data[(writer_type/2) % TEST_RCU_MAX_LCORE] [writer_type % TOTAL_ENTRY] != COUNTER_VALUE && - *hash_data[(writer_type/2) % RTE_RCU_MAX_LCORE] + *hash_data[(writer_type/2) % TEST_RCU_MAX_LCORE] [writer_type % TOTAL_ENTRY] != 0) { printf("Reader did not complete #%d = %d\t", writer_type, - *hash_data[(writer_type/2) % RTE_RCU_MAX_LCORE] + *hash_data[(writer_type/2) % TEST_RCU_MAX_LCORE] [writer_type % TOTAL_ENTRY]); return -1; } @@ -345,9 +369,9 @@ test_rcu_qsbr_writer(void *arg) keys[writer_type % TOTAL_ENTRY]); return -1; } - rte_free(hash_data[(writer_type/2) % RTE_RCU_MAX_LCORE] + rte_free(hash_data[(writer_type/2) % TEST_RCU_MAX_LCORE] [writer_type % TOTAL_ENTRY]); - hash_data[(writer_type/2) % RTE_RCU_MAX_LCORE] + hash_data[(writer_type/2) % TEST_RCU_MAX_LCORE] [writer_type % TOTAL_ENTRY] = NULL; return 0; @@ -419,11 +443,11 @@ test_rcu_qsbr_sw_sv_1qs(void) "Blocking QSBR Check\n"); /* QS variable is initialized */ - rte_rcu_qsbr_init(&t[0]); + rte_rcu_qsbr_init(t[0], TEST_RCU_MAX_LCORE); /* Register worker threads on 4 cores */ for (i = 0; i < 4; i++) - rte_rcu_qsbr_register_thread(&t[0], enabled_core_ids[i]); + rte_rcu_qsbr_register_thread(t[0], enabled_core_ids[i]); /* Shared data structure created */ h[0] = init_hash(0); @@ -445,10 +469,10 @@ test_rcu_qsbr_sw_sv_1qs(void) goto error; } /* Start the quiescent state query process */ - rte_rcu_qsbr_start(&t[0], num_1qs, &token); + rte_rcu_qsbr_start(t[0], num_1qs, &token); /* Check the quiescent state status */ - rte_rcu_qsbr_check(&t[0], token, true); + rte_rcu_qsbr_check(t[0], token, true); if (*hash_data[0][i] != COUNTER_VALUE && *hash_data[0][i] != 0) { printf("Reader did not complete #%d = %d\n", i, @@ -504,10 +528,10 @@ test_rcu_qsbr_sw_sv_1qs_non_blocking(void) printf("Test: 1 writer, 1 QSBR variable, 1 QSBR Query, " "Non-Blocking QSBR check\n"); - rte_rcu_qsbr_init(&t[0]); + rte_rcu_qsbr_init(t[0], TEST_RCU_MAX_LCORE); /* Register worker threads on 4 cores */ for (i = 0; i < 4; i++) - rte_rcu_qsbr_register_thread(&t[0], enabled_core_ids[i]); + rte_rcu_qsbr_register_thread(t[0], enabled_core_ids[i]); /* Shared data structure created */ h[0] = init_hash(0); @@ -529,11 +553,11 @@ test_rcu_qsbr_sw_sv_1qs_non_blocking(void) goto error; } /* Start the quiescent state query process */ - rte_rcu_qsbr_start(&t[0], num_1qs, &token); + rte_rcu_qsbr_start(t[0], num_1qs, &token); /* Check the quiescent state status */ do { - ret = rte_rcu_qsbr_check(&t[0], token, false); + ret = rte_rcu_qsbr_check(t[0], token, false); } while (ret == 0); if (*hash_data[0][i] != COUNTER_VALUE && *hash_data[0][i] != 0) { @@ -588,11 +612,11 @@ test_rcu_qsbr_sw_sv_3qs(void) printf("Test: 1 writer, 1 QSBR variable, simultaneous QSBR queries\n"); - rte_rcu_qsbr_init(&t[0]); + rte_rcu_qsbr_init(t[0], TEST_RCU_MAX_LCORE); /* Register worker threads on 4 cores */ for (i = 0; i < 4; i++) - rte_rcu_qsbr_register_thread(&t[0], enabled_core_ids[i]); + rte_rcu_qsbr_register_thread(t[0], enabled_core_ids[i]); /* Shared data structure created */ h[0] = init_hash(0); @@ -613,7 +637,7 @@ test_rcu_qsbr_sw_sv_3qs(void) goto error; } /* Start the quiescent state query process */ - rte_rcu_qsbr_start(&t[0], num_1qs, &token[0]); + rte_rcu_qsbr_start(t[0], num_1qs, &token[0]); /* Delete element from the shared data structure */ pos[1] = rte_hash_del_key(h[0], keys + 3); @@ -625,7 +649,7 @@ test_rcu_qsbr_sw_sv_3qs(void) * Start the quiescent state query process * Note: num_2qs kept greater than 1 for test only */ - rte_rcu_qsbr_start(&t[0], num_2qs, &token[1]); + rte_rcu_qsbr_start(t[0], num_2qs, &token[1]); /* Delete element from the shared data structure */ pos[2] = rte_hash_del_key(h[0], keys + 6); @@ -637,10 +661,10 @@ test_rcu_qsbr_sw_sv_3qs(void) * Start the quiescent state query process * Note: num_3qs kept greater than 1 for test only */ - rte_rcu_qsbr_start(&t[0], num_3qs, &token[2]); + rte_rcu_qsbr_start(t[0], num_3qs, &token[2]); /* Check the quiescent state status */ - rte_rcu_qsbr_check(&t[0], token[0], true); + rte_rcu_qsbr_check(t[0], token[0], true); if (*hash_data[0][0] != COUNTER_VALUE && *hash_data[0][0] != 0) { printf("Reader did not complete #0 = %d\n", *hash_data[0][0]); goto error; @@ -654,7 +678,7 @@ test_rcu_qsbr_sw_sv_3qs(void) hash_data[0][0] = NULL; /* Check the quiescent state status */ - rte_rcu_qsbr_check(&t[0], token[1], true); + rte_rcu_qsbr_check(t[0], token[1], true); if (*hash_data[0][3] != COUNTER_VALUE && *hash_data[0][3] != 0) { printf("Reader did not complete #3 = %d\n", *hash_data[0][3]); goto error; @@ -668,7 +692,7 @@ test_rcu_qsbr_sw_sv_3qs(void) hash_data[0][3] = NULL; /* Check the quiescent state status */ - rte_rcu_qsbr_check(&t[0], token[2], true); + rte_rcu_qsbr_check(t[0], token[2], true); if (*hash_data[0][6] != COUNTER_VALUE && *hash_data[0][6] != 0) { printf("Reader did not complete #6 = %d\n", *hash_data[0][6]); goto error; @@ -722,7 +746,7 @@ test_rcu_qsbr_mw_mv_mqs(void) , test_cores / 2, test_cores / 4); for (i = 0; i < num_cores / 4; i++) { - rte_rcu_qsbr_init(&t[i]); + rte_rcu_qsbr_init(t[i], TEST_RCU_MAX_LCORE); h[i] = init_hash(i); if (h[i] == NULL) { printf("Hash init failed\n"); @@ -732,8 +756,8 @@ test_rcu_qsbr_mw_mv_mqs(void) /* Register worker threads on 2 cores */ for (i = 0; i < test_cores / 2; i += 2) { - rte_rcu_qsbr_register_thread(&t[i / 2], enabled_core_ids[i]); - rte_rcu_qsbr_register_thread(&t[i / 2], + rte_rcu_qsbr_register_thread(t[i / 2], enabled_core_ids[i]); + rte_rcu_qsbr_register_thread(t[i / 2], enabled_core_ids[i + 1]); } @@ -776,7 +800,7 @@ test_rcu_qsbr_mw_mv_mqs(void) for (i = 0; i < num_cores / 4; i++) rte_hash_free(h[i]); rte_free(keys); - for (j = 0; j < RTE_RCU_MAX_LCORE; j++) + for (j = 0; j < TEST_RCU_MAX_LCORE; j++) for (i = 0; i < TOTAL_ENTRY; i++) rte_free(hash_data[j][i]); @@ -788,6 +812,9 @@ test_rcu_qsbr_main(void) { if (get_enabled_cores_mask() != 0) return -1; + +test_rcu_qsbr_get_memsize(); + /* Error-checking test cases */ if (test_rcu_qsbr_register_thread() < 0) goto test_fail; diff --git a/test/test/test_rcu_qsbr_perf.c b/test/test/test_rcu_qsbr_perf.c index 51af4961d..89c5030bb 100644 --- a/test/test/test_rcu_qsbr_perf.c +++ b/test/test/test_rcu_qsbr_perf.c @@ -24,7 +24,7 @@ uint8_t num_cores; uint32_t *hash_data[TEST_RCU_MAX_LCORE][TOTAL_ENTRY]; uint8_t writer_done; -static struct rte_rcu_qsbr t; +static struct rte_rcu_qsbr *t; struct rte_hash *h[TEST_RCU_MAX_LCORE]; char hash_name[TEST_RCU_MAX_LCORE][8]; static rte_atomic64_t updates, checks; @@ -70,13 +70,13 @@ test_rcu_qsbr_reader_perf(void *arg) if (writer_present) { while (!writer_done) { /* Update quiescent state counter */ - rte_rcu_qsbr_update(&t, lcore_id); + rte_rcu_qsbr_update(t, lcore_id); loop_cnt++; } } else { while (loop_cnt < 100000000) { /* Update quiescent state counter */ - rte_rcu_qsbr_update(&t, lcore_id); + rte_rcu_qsbr_update(t, lcore_id); loop_cnt++; } } @@ -86,7 +86,7 @@ test_rcu_qsbr_reader_perf(void *arg) rte_atomic64_add(&updates, loop_cnt); /* Unregister before exiting to avoid writer from waiting */ - rte_rcu_qsbr_unregister_thread(&t, lcore_id); + rte_rcu_qsbr_unregister_thread(t, lcore_id); return 0; } @@ -103,10 +103,10 @@ test_rcu_qsbr_writer_perf(void *arg) do { /* Start the quiescent state query process */ - if (wait) rte_rcu_qsbr_start(&t, 1, &token); + if (wait) rte_rcu_qsbr_start(t, 1, &token); /* Check quiescent state status */ - rte_rcu_qsbr_check(&t, token, wait); + rte_rcu_qsbr_check(t, token, wait); loop_cnt++; } while (loop_cnt < 20000000); @@ -134,11 +134,11 @@ test_rcu_qsbr_perf(void) printf("\nPerf Test: 6 Readers/1 Writer('wait' in qsbr_check == true)\n"); /* QS variable is initialized */ - rte_rcu_qsbr_init(&t); + rte_rcu_qsbr_init(t, TEST_RCU_MAX_LCORE); /* Register worker threads on 6 cores */ for (i = 0; i < 6; i++) - rte_rcu_qsbr_register_thread(&t, enabled_core_ids[i]); + rte_rcu_qsbr_register_thread(t, enabled_core_ids[i]); /* Reader threads are launched */ for (i = 0; i < 6; i++) @@ -179,17 +179,15 @@ test_rcu_qsbr_rperf(void) rte_atomic64_clear(&updates); rte_atomic64_clear(&update_cycles); - rte_atomic64_clear(&checks); - rte_atomic64_clear(&check_cycles); printf("\nPerf Test: 8 Readers\n"); /* QS variable is initialized */ - rte_rcu_qsbr_init(&t); + rte_rcu_qsbr_init(t, TEST_RCU_MAX_LCORE); /* Register worker threads on 8 cores */ for (i = 0; i < 8; i++) - rte_rcu_qsbr_register_thread(&t, enabled_core_ids[i]); + rte_rcu_qsbr_register_thread(t, enabled_core_ids[i]); /* Reader threads are launched */ for (i = 0; i < 8; i++) @@ -200,6 +198,8 @@ test_rcu_qsbr_rperf(void) rte_eal_mp_wait_lcore(); printf("Total RCU updates = %ld\n", rte_atomic64_read(&updates)); + printf("Total update cycles = %ld\n", + rte_atomic64_read(&update_cycles)); printf("Cycles per %d updates: %lu\n", RCU_SCALE_DOWN, rte_atomic64_read(&update_cycles) / (rte_atomic64_read(&updates) / RCU_SCALE_DOWN)); @@ -216,15 +216,13 @@ test_rcu_qsbr_wperf(void) { int i; - rte_atomic64_clear(&updates); - rte_atomic64_clear(&update_cycles); rte_atomic64_clear(&checks); rte_atomic64_clear(&check_cycles); printf("\nPerf test: 8 Writers ('wait' in qsbr_check == false)\n"); /* QS variable is initialized */ - rte_rcu_qsbr_init(&t); + rte_rcu_qsbr_init(t, TEST_RCU_MAX_LCORE); /* Writer threads are launched */ for (i = 0; i < 8; i++) @@ -245,6 +243,8 @@ test_rcu_qsbr_wperf(void) static int test_rcu_qsbr_main(void) { + uint32_t sz; + rte_atomic64_init(&updates); rte_atomic64_init(&update_cycles); rte_atomic64_init(&checks); @@ -253,6 +253,9 @@ test_rcu_qsbr_main(void) if (get_enabled_cores_mask() != 0) return -1; + sz = rte_rcu_qsbr_get_memsize(TEST_RCU_MAX_LCORE); + t = (struct rte_rcu_qsbr *)rte_zmalloc("rcu", sz, RTE_CACHE_LINE_SIZE); + if (test_rcu_qsbr_perf() < 0) goto test_fail; -- 2.17.1