Modify the test cases to allocate the QSBR variable dynamically.
Signed-off-by: Honnappa Nagarahalli <honnappa.nagaraha...@arm.com>
---
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
