[dpdk-dev] [PATCH v2 08/15] test/rcu: remove arbitrary limit on max core count

David Marchand david.marchand at redhat.com
Sat Jun 15 08:42:23 CEST 2019


We can have up to RTE_MAX_LCORE in a dpdk application.
Remove the limit on 128 cores and tests that are now always false.

Fixes: b87089b0bb19 ("test/rcu: add API and functional tests")
Cc: stable at dpdk.org

Signed-off-by: David Marchand <david.marchand at redhat.com>
---
Changelog since v1:
- new patch added to remove the local TEST_RCU_MAX_LCORE limit
- changed some integer types to accomodate with the change

---
 app/test/test_rcu_qsbr.c      | 133 ++++++++++++++++++------------------------
 app/test/test_rcu_qsbr_perf.c |  63 +++++++-------------
 2 files changed, 79 insertions(+), 117 deletions(-)

diff --git a/app/test/test_rcu_qsbr.c b/app/test/test_rcu_qsbr.c
index 5f0b138..97af087 100644
--- a/app/test/test_rcu_qsbr.c
+++ b/app/test/test_rcu_qsbr.c
@@ -26,19 +26,18 @@
 /* Make sure that this has the same value as __RTE_QSBR_CNT_INIT */
 #define TEST_RCU_QSBR_CNT_INIT 1
 
-#define TEST_RCU_MAX_LCORE 128
-uint16_t enabled_core_ids[TEST_RCU_MAX_LCORE];
+uint16_t enabled_core_ids[RTE_MAX_LCORE];
 uint8_t num_cores;
 
 static uint32_t *keys;
 #define TOTAL_ENTRY (1024 * 8)
 #define COUNTER_VALUE 4096
-static uint32_t *hash_data[TEST_RCU_MAX_LCORE][TOTAL_ENTRY];
+static uint32_t *hash_data[RTE_MAX_LCORE][TOTAL_ENTRY];
 static uint8_t writer_done;
 
-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 struct rte_rcu_qsbr *t[RTE_MAX_LCORE];
+struct rte_hash *h[RTE_MAX_LCORE];
+char hash_name[RTE_MAX_LCORE][8];
 
 struct test_rcu_thread_info {
 	/* Index in RCU array */
@@ -48,28 +47,7 @@ struct test_rcu_thread_info {
 	/* lcore IDs registered on the RCU variable */
 	uint16_t r_core_ids[2];
 };
-struct test_rcu_thread_info thread_info[TEST_RCU_MAX_LCORE/4];
-
-static inline int
-get_enabled_cores_mask(void)
-{
-	uint16_t core_id;
-	uint32_t max_cores = rte_lcore_count();
-
-	if (max_cores > TEST_RCU_MAX_LCORE) {
-		printf("Number of cores exceed %d\n", TEST_RCU_MAX_LCORE);
-		return -1;
-	}
-
-	core_id = 0;
-	num_cores = 0;
-	RTE_LCORE_FOREACH_SLAVE(core_id) {
-		enabled_core_ids[num_cores] = core_id;
-		num_cores++;
-	}
-
-	return 0;
-}
+struct test_rcu_thread_info thread_info[RTE_MAX_LCORE/4];
 
 static int
 alloc_rcu(void)
@@ -77,9 +55,9 @@ struct test_rcu_thread_info {
 	int i;
 	uint32_t sz;
 
-	sz = rte_rcu_qsbr_get_memsize(TEST_RCU_MAX_LCORE);
+	sz = rte_rcu_qsbr_get_memsize(RTE_MAX_LCORE);
 
-	for (i = 0; i < TEST_RCU_MAX_LCORE; i++)
+	for (i = 0; i < RTE_MAX_LCORE; i++)
 		t[i] = (struct rte_rcu_qsbr *)rte_zmalloc(NULL, sz,
 						RTE_CACHE_LINE_SIZE);
 
@@ -91,7 +69,7 @@ struct test_rcu_thread_info {
 {
 	int i;
 
-	for (i = 0; i < TEST_RCU_MAX_LCORE; i++)
+	for (i = 0; i < RTE_MAX_LCORE; i++)
 		rte_free(t[i]);
 
 	return 0;
@@ -111,7 +89,7 @@ struct test_rcu_thread_info {
 	sz = rte_rcu_qsbr_get_memsize(0);
 	TEST_RCU_QSBR_RETURN_IF_ERROR((sz != 1), "Get Memsize for 0 threads");
 
-	sz = rte_rcu_qsbr_get_memsize(TEST_RCU_MAX_LCORE);
+	sz = rte_rcu_qsbr_get_memsize(RTE_MAX_LCORE);
 	/* For 128 threads,
 	 * for machines with cache line size of 64B - 8384
 	 * for machines with cache line size of 128 - 16768
@@ -132,7 +110,7 @@ struct test_rcu_thread_info {
 
 	printf("\nTest rte_rcu_qsbr_init()\n");
 
-	r = rte_rcu_qsbr_init(NULL, TEST_RCU_MAX_LCORE);
+	r = rte_rcu_qsbr_init(NULL, RTE_MAX_LCORE);
 	TEST_RCU_QSBR_RETURN_IF_ERROR((r != 1), "NULL variable");
 
 	return 0;
@@ -156,7 +134,7 @@ struct test_rcu_thread_info {
 	TEST_RCU_QSBR_RETURN_IF_ERROR((ret == 0),
 		"NULL variable, invalid thread id");
 
-	rte_rcu_qsbr_init(t[0], TEST_RCU_MAX_LCORE);
+	rte_rcu_qsbr_init(t[0], RTE_MAX_LCORE);
 
 	/* Register valid thread id */
 	ret = rte_rcu_qsbr_thread_register(t[0], enabled_core_ids[0]);
@@ -168,7 +146,7 @@ struct test_rcu_thread_info {
 		"Already registered thread id");
 
 	/* Register valid thread id - max allowed thread id */
-	ret = rte_rcu_qsbr_thread_register(t[0], TEST_RCU_MAX_LCORE - 1);
+	ret = rte_rcu_qsbr_thread_register(t[0], RTE_MAX_LCORE - 1);
 	TEST_RCU_QSBR_RETURN_IF_ERROR((ret == 1), "Max thread id");
 
 	ret = rte_rcu_qsbr_thread_register(t[0], 100000);
@@ -185,9 +163,10 @@ struct test_rcu_thread_info {
 static int
 test_rcu_qsbr_thread_unregister(void)
 {
-	int i, j, ret;
+	unsigned int num_threads[3] = {1, RTE_MAX_LCORE, 1};
+	unsigned int i, j;
 	uint64_t token;
-	uint8_t num_threads[3] = {1, TEST_RCU_MAX_LCORE, 1};
+	int ret;
 
 	printf("\nTest rte_rcu_qsbr_thread_unregister()\n");
 
@@ -198,7 +177,7 @@ struct test_rcu_thread_info {
 	TEST_RCU_QSBR_RETURN_IF_ERROR((ret == 0),
 		"NULL variable, invalid thread id");
 
-	rte_rcu_qsbr_init(t[0], TEST_RCU_MAX_LCORE);
+	rte_rcu_qsbr_init(t[0], RTE_MAX_LCORE);
 
 	rte_rcu_qsbr_thread_register(t[0], enabled_core_ids[0]);
 
@@ -207,7 +186,7 @@ struct test_rcu_thread_info {
 		"NULL variable, invalid thread id");
 
 	/* Find first disabled core */
-	for (i = 0; i < TEST_RCU_MAX_LCORE; i++) {
+	for (i = 0; i < RTE_MAX_LCORE; i++) {
 		if (enabled_core_ids[i] == 0)
 			break;
 	}
@@ -232,15 +211,15 @@ struct test_rcu_thread_info {
 	/*
 	 * Test with different thread_ids:
 	 * 1 - thread_id = 0
-	 * 2 - All possible thread_ids, from 0 to TEST_RCU_MAX_LCORE
-	 * 3 - thread_id = TEST_RCU_MAX_LCORE - 1
+	 * 2 - All possible thread_ids, from 0 to RTE_MAX_LCORE
+	 * 3 - thread_id = RTE_MAX_LCORE - 1
 	 */
 	for (j = 0; j < 3; j++) {
-		rte_rcu_qsbr_init(t[0], TEST_RCU_MAX_LCORE);
+		rte_rcu_qsbr_init(t[0], RTE_MAX_LCORE);
 
 		for (i = 0; i < num_threads[j]; i++)
 			rte_rcu_qsbr_thread_register(t[0],
-				(j == 2) ? (TEST_RCU_MAX_LCORE - 1) : i);
+				(j == 2) ? (RTE_MAX_LCORE - 1) : i);
 
 		token = rte_rcu_qsbr_start(t[0]);
 		TEST_RCU_QSBR_RETURN_IF_ERROR(
@@ -248,10 +227,10 @@ struct test_rcu_thread_info {
 		/* Update quiescent state counter */
 		for (i = 0; i < num_threads[j]; i++) {
 			/* Skip one update */
-			if (i == (TEST_RCU_MAX_LCORE - 10))
+			if (i == (RTE_MAX_LCORE - 10))
 				continue;
 			rte_rcu_qsbr_quiescent(t[0],
-				(j == 2) ? (TEST_RCU_MAX_LCORE - 1) : i);
+				(j == 2) ? (RTE_MAX_LCORE - 1) : i);
 		}
 
 		if (j == 1) {
@@ -260,7 +239,7 @@ struct test_rcu_thread_info {
 			TEST_RCU_QSBR_RETURN_IF_ERROR((ret == 0),
 						"Non-blocking QSBR check");
 			/* Update the previously skipped thread */
-			rte_rcu_qsbr_quiescent(t[0], TEST_RCU_MAX_LCORE - 10);
+			rte_rcu_qsbr_quiescent(t[0], RTE_MAX_LCORE - 10);
 		}
 
 		/* Validate the updates */
@@ -270,7 +249,7 @@ struct test_rcu_thread_info {
 
 		for (i = 0; i < num_threads[j]; i++)
 			rte_rcu_qsbr_thread_unregister(t[0],
-				(j == 2) ? (TEST_RCU_MAX_LCORE - 1) : i);
+				(j == 2) ? (RTE_MAX_LCORE - 1) : i);
 
 		/* Check with no thread registered */
 		ret = rte_rcu_qsbr_check(t[0], token, true);
@@ -292,7 +271,7 @@ struct test_rcu_thread_info {
 
 	printf("\nTest rte_rcu_qsbr_start()\n");
 
-	rte_rcu_qsbr_init(t[0], TEST_RCU_MAX_LCORE);
+	rte_rcu_qsbr_init(t[0], RTE_MAX_LCORE);
 
 	for (i = 0; i < 3; i++)
 		rte_rcu_qsbr_thread_register(t[0], enabled_core_ids[i]);
@@ -331,7 +310,7 @@ struct test_rcu_thread_info {
 
 	printf("\nTest rte_rcu_qsbr_check()\n");
 
-	rte_rcu_qsbr_init(t[0], TEST_RCU_MAX_LCORE);
+	rte_rcu_qsbr_init(t[0], RTE_MAX_LCORE);
 
 	token = rte_rcu_qsbr_start(t[0]);
 	TEST_RCU_QSBR_RETURN_IF_ERROR(
@@ -365,7 +344,7 @@ struct test_rcu_thread_info {
 	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], TEST_RCU_MAX_LCORE);
+	rte_rcu_qsbr_init(t[0], RTE_MAX_LCORE);
 
 	for (i = 0; i < 4; i++)
 		rte_rcu_qsbr_thread_register(t[0], enabled_core_ids[i]);
@@ -414,7 +393,7 @@ struct test_rcu_thread_info {
 
 	printf("\nTest rte_rcu_qsbr_synchronize()\n");
 
-	rte_rcu_qsbr_init(t[0], TEST_RCU_MAX_LCORE);
+	rte_rcu_qsbr_init(t[0], RTE_MAX_LCORE);
 
 	/* Test if the API returns when there are no threads reporting
 	 * QS on the variable.
@@ -424,7 +403,7 @@ struct test_rcu_thread_info {
 	/* Test if the API returns when there are threads registered
 	 * but not online.
 	 */
-	for (i = 0; i < TEST_RCU_MAX_LCORE; i++)
+	for (i = 0; i < RTE_MAX_LCORE; i++)
 		rte_rcu_qsbr_thread_register(t[0], i);
 	rte_rcu_qsbr_synchronize(t[0], RTE_QSBR_THRID_INVALID);
 
@@ -436,12 +415,12 @@ struct test_rcu_thread_info {
 	rte_rcu_qsbr_thread_offline(t[0], 0);
 
 	/* Check the other boundary */
-	rte_rcu_qsbr_thread_online(t[0], TEST_RCU_MAX_LCORE - 1);
-	rte_rcu_qsbr_synchronize(t[0], TEST_RCU_MAX_LCORE - 1);
-	rte_rcu_qsbr_thread_offline(t[0], TEST_RCU_MAX_LCORE - 1);
+	rte_rcu_qsbr_thread_online(t[0], RTE_MAX_LCORE - 1);
+	rte_rcu_qsbr_synchronize(t[0], RTE_MAX_LCORE - 1);
+	rte_rcu_qsbr_thread_offline(t[0], RTE_MAX_LCORE - 1);
 
 	/* Test if the API returns after unregisterng all the threads */
-	for (i = 0; i < TEST_RCU_MAX_LCORE; i++)
+	for (i = 0; i < RTE_MAX_LCORE; i++)
 		rte_rcu_qsbr_thread_unregister(t[0], i);
 	rte_rcu_qsbr_synchronize(t[0], RTE_QSBR_THRID_INVALID);
 
@@ -474,7 +453,7 @@ struct test_rcu_thread_info {
 
 	printf("Test rte_rcu_qsbr_thread_online()\n");
 
-	rte_rcu_qsbr_init(t[0], TEST_RCU_MAX_LCORE);
+	rte_rcu_qsbr_init(t[0], RTE_MAX_LCORE);
 
 	/* Register 2 threads to validate that only the
 	 * online thread is waited upon.
@@ -501,9 +480,9 @@ struct test_rcu_thread_info {
 	TEST_RCU_QSBR_RETURN_IF_ERROR((ret == 0), "thread update");
 
 	/* Make all the threads online */
-	rte_rcu_qsbr_init(t[0], TEST_RCU_MAX_LCORE);
+	rte_rcu_qsbr_init(t[0], RTE_MAX_LCORE);
 	token = rte_rcu_qsbr_start(t[0]);
-	for (i = 0; i < TEST_RCU_MAX_LCORE; i++) {
+	for (i = 0; i < RTE_MAX_LCORE; i++) {
 		rte_rcu_qsbr_thread_register(t[0], i);
 		rte_rcu_qsbr_thread_online(t[0], i);
 	}
@@ -512,7 +491,7 @@ struct test_rcu_thread_info {
 	TEST_RCU_QSBR_RETURN_IF_ERROR((ret == 0), "thread online");
 	/* Check if all the online threads can report QS */
 	token = rte_rcu_qsbr_start(t[0]);
-	for (i = 0; i < TEST_RCU_MAX_LCORE; i++)
+	for (i = 0; i < RTE_MAX_LCORE; i++)
 		rte_rcu_qsbr_quiescent(t[0], i);
 	ret = rte_rcu_qsbr_check(t[0], token, true);
 	TEST_RCU_QSBR_RETURN_IF_ERROR((ret == 0), "thread update");
@@ -532,7 +511,7 @@ struct test_rcu_thread_info {
 
 	printf("\nTest rte_rcu_qsbr_thread_offline()\n");
 
-	rte_rcu_qsbr_init(t[0], TEST_RCU_MAX_LCORE);
+	rte_rcu_qsbr_init(t[0], RTE_MAX_LCORE);
 
 	rte_rcu_qsbr_thread_register(t[0], enabled_core_ids[0]);
 
@@ -560,10 +539,10 @@ struct test_rcu_thread_info {
 	/*
 	 * Check a sequence of online/status/offline/status/online/status
 	 */
-	rte_rcu_qsbr_init(t[0], TEST_RCU_MAX_LCORE);
+	rte_rcu_qsbr_init(t[0], RTE_MAX_LCORE);
 	token = rte_rcu_qsbr_start(t[0]);
 	/* Make the threads online */
-	for (i = 0; i < TEST_RCU_MAX_LCORE; i++) {
+	for (i = 0; i < RTE_MAX_LCORE; i++) {
 		rte_rcu_qsbr_thread_register(t[0], i);
 		rte_rcu_qsbr_thread_online(t[0], i);
 	}
@@ -574,13 +553,13 @@ struct test_rcu_thread_info {
 
 	/* Check if all the online threads can report QS */
 	token = rte_rcu_qsbr_start(t[0]);
-	for (i = 0; i < TEST_RCU_MAX_LCORE; i++)
+	for (i = 0; i < RTE_MAX_LCORE; i++)
 		rte_rcu_qsbr_quiescent(t[0], i);
 	ret = rte_rcu_qsbr_check(t[0], token, true);
 	TEST_RCU_QSBR_RETURN_IF_ERROR((ret == 0), "report QS");
 
 	/* Make all the threads offline */
-	for (i = 0; i < TEST_RCU_MAX_LCORE; i++)
+	for (i = 0; i < RTE_MAX_LCORE; i++)
 		rte_rcu_qsbr_thread_offline(t[0], i);
 	/* Make sure these threads are not being waited on */
 	token = rte_rcu_qsbr_start(t[0]);
@@ -588,11 +567,11 @@ struct test_rcu_thread_info {
 	TEST_RCU_QSBR_RETURN_IF_ERROR((ret == 0), "offline QS");
 
 	/* Make the threads online */
-	for (i = 0; i < TEST_RCU_MAX_LCORE; i++)
+	for (i = 0; i < RTE_MAX_LCORE; i++)
 		rte_rcu_qsbr_thread_online(t[0], i);
 	/* Check if all the online threads can report QS */
 	token = rte_rcu_qsbr_start(t[0]);
-	for (i = 0; i < TEST_RCU_MAX_LCORE; i++)
+	for (i = 0; i < RTE_MAX_LCORE; i++)
 		rte_rcu_qsbr_quiescent(t[0], i);
 	ret = rte_rcu_qsbr_check(t[0], token, true);
 	TEST_RCU_QSBR_RETURN_IF_ERROR((ret == 0), "online again");
@@ -615,8 +594,8 @@ struct test_rcu_thread_info {
 	rte_rcu_qsbr_dump(stdout, NULL);
 	rte_rcu_qsbr_dump(NULL, NULL);
 
-	rte_rcu_qsbr_init(t[0], TEST_RCU_MAX_LCORE);
-	rte_rcu_qsbr_init(t[1], TEST_RCU_MAX_LCORE);
+	rte_rcu_qsbr_init(t[0], RTE_MAX_LCORE);
+	rte_rcu_qsbr_init(t[1], RTE_MAX_LCORE);
 
 	/* QS variable with 0 core mask */
 	rte_rcu_qsbr_dump(stdout, t[0]);
@@ -738,8 +717,7 @@ struct test_rcu_thread_info {
 
 	for (i = 0; i < TOTAL_ENTRY; i++) {
 		hash_data[hash_id][i] =
-			rte_zmalloc(NULL,
-				sizeof(uint32_t) * TEST_RCU_MAX_LCORE, 0);
+			rte_zmalloc(NULL, sizeof(uint32_t) * RTE_MAX_LCORE, 0);
 		if (hash_data[hash_id][i] == NULL) {
 			printf("No memory\n");
 			return NULL;
@@ -781,7 +759,7 @@ struct test_rcu_thread_info {
 
 	printf("Test: 1 writer, 1 QSBR variable, simultaneous QSBR queries\n");
 
-	rte_rcu_qsbr_init(t[0], TEST_RCU_MAX_LCORE);
+	rte_rcu_qsbr_init(t[0], RTE_MAX_LCORE);
 
 	/* Shared data structure created */
 	h[0] = init_hash(0);
@@ -924,7 +902,7 @@ struct test_rcu_thread_info {
 
 	for (i = 0; i < test_cores / 4; i++) {
 		j = i * 4;
-		rte_rcu_qsbr_init(t[i], TEST_RCU_MAX_LCORE);
+		rte_rcu_qsbr_init(t[i], RTE_MAX_LCORE);
 		h[i] = init_hash(i);
 		if (h[i] == NULL) {
 			printf("Hash init failed\n");
@@ -998,8 +976,13 @@ struct test_rcu_thread_info {
 static int
 test_rcu_qsbr_main(void)
 {
-	if (get_enabled_cores_mask() != 0)
-		return -1;
+	uint16_t core_id;
+
+	num_cores = 0;
+	RTE_LCORE_FOREACH_SLAVE(core_id) {
+		enabled_core_ids[num_cores] = core_id;
+		num_cores++;
+	}
 
 	if (num_cores < 4) {
 		printf("Test failed! Need 4 or more cores\n");
diff --git a/app/test/test_rcu_qsbr_perf.c b/app/test/test_rcu_qsbr_perf.c
index 33ca36c..c918a94 100644
--- a/app/test/test_rcu_qsbr_perf.c
+++ b/app/test/test_rcu_qsbr_perf.c
@@ -16,8 +16,7 @@
 #include "test.h"
 
 /* Check condition and return an error if true. */
-#define TEST_RCU_MAX_LCORE 128
-static uint16_t enabled_core_ids[TEST_RCU_MAX_LCORE];
+static uint16_t enabled_core_ids[RTE_MAX_LCORE];
 static uint8_t num_cores;
 
 static uint32_t *keys;
@@ -28,7 +27,7 @@
 static volatile uint8_t all_registered;
 static volatile uint32_t thr_id;
 
-static struct rte_rcu_qsbr *t[TEST_RCU_MAX_LCORE];
+static struct rte_rcu_qsbr *t[RTE_MAX_LCORE];
 static struct rte_hash *h;
 static char hash_name[8];
 static rte_atomic64_t updates, checks;
@@ -39,40 +38,19 @@
  */
 #define RCU_SCALE_DOWN 1000
 
-/* Simple way to allocate thread ids in 0 to TEST_RCU_MAX_LCORE space */
+/* Simple way to allocate thread ids in 0 to RTE_MAX_LCORE space */
 static inline uint32_t
 alloc_thread_id(void)
 {
 	uint32_t tmp_thr_id;
 
 	tmp_thr_id = __atomic_fetch_add(&thr_id, 1, __ATOMIC_RELAXED);
-	if (tmp_thr_id >= TEST_RCU_MAX_LCORE)
+	if (tmp_thr_id >= RTE_MAX_LCORE)
 		printf("Invalid thread id %u\n", tmp_thr_id);
 
 	return tmp_thr_id;
 }
 
-static inline int
-get_enabled_cores_mask(void)
-{
-	uint16_t core_id;
-	uint32_t max_cores = rte_lcore_count();
-
-	if (max_cores > TEST_RCU_MAX_LCORE) {
-		printf("Number of cores exceed %d\n", TEST_RCU_MAX_LCORE);
-		return -1;
-	}
-
-	core_id = 0;
-	num_cores = 0;
-	RTE_LCORE_FOREACH_SLAVE(core_id) {
-		enabled_core_ids[num_cores] = core_id;
-		num_cores++;
-	}
-
-	return 0;
-}
-
 static int
 test_rcu_qsbr_reader_perf(void *arg)
 {
@@ -165,7 +143,7 @@
 	if (all_registered == 1)
 		tmp_num_cores = num_cores - 1;
 	else
-		tmp_num_cores = TEST_RCU_MAX_LCORE;
+		tmp_num_cores = RTE_MAX_LCORE;
 
 	sz = rte_rcu_qsbr_get_memsize(tmp_num_cores);
 	t[0] = (struct rte_rcu_qsbr *)rte_zmalloc("rcu0", sz,
@@ -223,7 +201,7 @@
 	if (all_registered == 1)
 		tmp_num_cores = num_cores;
 	else
-		tmp_num_cores = TEST_RCU_MAX_LCORE;
+		tmp_num_cores = RTE_MAX_LCORE;
 
 	sz = rte_rcu_qsbr_get_memsize(tmp_num_cores);
 	t[0] = (struct rte_rcu_qsbr *)rte_zmalloc("rcu0", sz,
@@ -269,11 +247,11 @@
 	/* Number of readers does not matter for QS variable in this test
 	 * case as no reader will be registered.
 	 */
-	sz = rte_rcu_qsbr_get_memsize(TEST_RCU_MAX_LCORE);
+	sz = rte_rcu_qsbr_get_memsize(RTE_MAX_LCORE);
 	t[0] = (struct rte_rcu_qsbr *)rte_zmalloc("rcu0", sz,
 						RTE_CACHE_LINE_SIZE);
 	/* QS variable is initialized */
-	rte_rcu_qsbr_init(t[0], TEST_RCU_MAX_LCORE);
+	rte_rcu_qsbr_init(t[0], RTE_MAX_LCORE);
 
 	/* Writer threads are launched */
 	for (i = 0; i < num_cores; i++)
@@ -367,7 +345,7 @@ static struct rte_hash *init_hash(void)
 
 	for (i = 0; i < TOTAL_ENTRY; i++) {
 		hash_data[i] = rte_zmalloc(NULL,
-				sizeof(uint32_t) * TEST_RCU_MAX_LCORE, 0);
+				sizeof(uint32_t) * RTE_MAX_LCORE, 0);
 		if (hash_data[i] == NULL) {
 			printf("No memory\n");
 			return NULL;
@@ -417,7 +395,7 @@ static struct rte_hash *init_hash(void)
 	if (all_registered == 1)
 		tmp_num_cores = num_cores;
 	else
-		tmp_num_cores = TEST_RCU_MAX_LCORE;
+		tmp_num_cores = RTE_MAX_LCORE;
 
 	sz = rte_rcu_qsbr_get_memsize(tmp_num_cores);
 	t[0] = (struct rte_rcu_qsbr *)rte_zmalloc("rcu0", sz,
@@ -530,7 +508,7 @@ static struct rte_hash *init_hash(void)
 	if (all_registered == 1)
 		tmp_num_cores = num_cores;
 	else
-		tmp_num_cores = TEST_RCU_MAX_LCORE;
+		tmp_num_cores = RTE_MAX_LCORE;
 
 	sz = rte_rcu_qsbr_get_memsize(tmp_num_cores);
 	t[0] = (struct rte_rcu_qsbr *)rte_zmalloc("rcu0", sz,
@@ -626,23 +604,24 @@ static struct rte_hash *init_hash(void)
 static int
 test_rcu_qsbr_main(void)
 {
+	uint16_t core_id;
+
 	rte_atomic64_init(&updates);
 	rte_atomic64_init(&update_cycles);
 	rte_atomic64_init(&checks);
 	rte_atomic64_init(&check_cycles);
 
-	if (get_enabled_cores_mask() != 0)
-		return -1;
+	num_cores = 0;
+	RTE_LCORE_FOREACH_SLAVE(core_id) {
+		enabled_core_ids[num_cores] = core_id;
+		num_cores++;
+	}
 
 	printf("Number of cores provided = %d\n", num_cores);
 	if (num_cores < 2) {
 		printf("Test failed! Need 2 or more cores\n");
 		goto test_fail;
 	}
-	if (num_cores > TEST_RCU_MAX_LCORE) {
-		printf("Test failed! %d cores supported\n", TEST_RCU_MAX_LCORE);
-		goto test_fail;
-	}
 
 	printf("Perf test with all reader threads registered\n");
 	printf("--------------------------------------------\n");
@@ -664,12 +643,12 @@ static struct rte_hash *init_hash(void)
 		goto test_fail;
 
 	/* Make sure the actual number of cores provided is less than
-	 * TEST_RCU_MAX_LCORE. This will allow for some threads not
+	 * RTE_MAX_LCORE. This will allow for some threads not
 	 * to be registered on the QS variable.
 	 */
-	if (num_cores >= TEST_RCU_MAX_LCORE) {
+	if (num_cores >= RTE_MAX_LCORE) {
 		printf("Test failed! number of cores provided should be less than %d\n",
-			TEST_RCU_MAX_LCORE);
+			RTE_MAX_LCORE);
 		goto test_fail;
 	}
 
-- 
1.8.3.1



More information about the dev mailing list