X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest%2Ftest_rcu_qsbr.c;h=0a9e5ecd1a44b4d581ee73ee9cd057aa2a894920;hb=2ead29e1d6fca678a4e29245710d02fab038b810;hp=5f0b1383e564812e7662684401d56580e696a993;hpb=752fc771e594a808e7840d78c877c6865a9ef960;p=dpdk.git diff --git a/app/test/test_rcu_qsbr.c b/app/test/test_rcu_qsbr.c index 5f0b1383e5..0a9e5ecd1a 100644 --- a/app/test/test_rcu_qsbr.c +++ b/app/test/test_rcu_qsbr.c @@ -1,21 +1,23 @@ /* SPDX-License-Identifier: BSD-3-Clause - * Copyright (c) 2018 Arm Limited + * Copyright (c) 2019-2020 Arm Limited */ #include -#include +#include #include #include #include #include #include #include +#include #include #include "test.h" /* Check condition and return an error if true. */ -#define TEST_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,22 +25,32 @@ } \ } while (0) +/* Check condition and go to label if true. */ +#define TEST_RCU_QSBR_GOTO_IF_ERROR(label, cond, str, ...) \ +do { \ + if (cond) { \ + printf("ERROR file %s, line %d: " str "\n", __FILE__, \ + __LINE__, ##__VA_ARGS__); \ + goto label; \ + } \ +} while (0) + /* 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]; -uint8_t num_cores; +static uint16_t enabled_core_ids[RTE_MAX_LCORE]; +static unsigned int 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 uint8_t cb_failed; -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]; +static struct rte_hash *h[RTE_MAX_LCORE]; +static char hash_name[RTE_MAX_LCORE][8]; struct test_rcu_thread_info { /* Index in RCU array */ @@ -48,38 +60,17 @@ 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; -} +static struct test_rcu_thread_info thread_info[RTE_MAX_LCORE/4]; static int alloc_rcu(void) { int i; - uint32_t sz; + size_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 +82,7 @@ free_rcu(void) { 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; @@ -104,20 +95,24 @@ free_rcu(void) static int test_rcu_qsbr_get_memsize(void) { - uint32_t sz; + size_t sz; printf("\nTest rte_rcu_qsbr_thread_register()\n"); 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(128); /* For 128 threads, * for machines with cache line size of 64B - 8384 * for machines with cache line size of 128 - 16768 */ - TEST_RCU_QSBR_RETURN_IF_ERROR((sz != 8384 && sz != 16768), - "Get Memsize"); + if (RTE_CACHE_LINE_SIZE == 64) + TEST_RCU_QSBR_RETURN_IF_ERROR((sz != 8384), + "Get Memsize for 128 threads"); + else if (RTE_CACHE_LINE_SIZE == 128) + TEST_RCU_QSBR_RETURN_IF_ERROR((sz != 16768), + "Get Memsize for 128 threads"); return 0; } @@ -132,7 +127,7 @@ test_rcu_qsbr_init(void) 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 +151,7 @@ test_rcu_qsbr_thread_register(void) 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 +163,7 @@ test_rcu_qsbr_thread_register(void) "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 +180,11 @@ test_rcu_qsbr_thread_register(void) 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; + unsigned int skip_thread_id; 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 +195,7 @@ test_rcu_qsbr_thread_unregister(void) 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 +204,7 @@ test_rcu_qsbr_thread_unregister(void) "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,26 +229,27 @@ test_rcu_qsbr_thread_unregister(void) /* * 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( (token != (TEST_RCU_QSBR_CNT_INIT + 1)), "QSBR Start"); + skip_thread_id = rte_rand() % RTE_MAX_LCORE; /* Update quiescent state counter */ for (i = 0; i < num_threads[j]; i++) { /* Skip one update */ - if (i == (TEST_RCU_MAX_LCORE - 10)) + if ((j == 1) && (i == skip_thread_id)) 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 +258,7 @@ test_rcu_qsbr_thread_unregister(void) 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], skip_thread_id); } /* Validate the updates */ @@ -270,7 +268,7 @@ test_rcu_qsbr_thread_unregister(void) 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 +290,7 @@ test_rcu_qsbr_start(void) 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 +329,7 @@ test_rcu_qsbr_check(void) 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 +363,7 @@ test_rcu_qsbr_check(void) 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]); @@ -410,11 +408,11 @@ test_rcu_qsbr_synchronize_reader(void *arg) static int test_rcu_qsbr_synchronize(void) { - int i; + unsigned int i; 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 +422,7 @@ test_rcu_qsbr_synchronize(void) /* 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 +434,12 @@ test_rcu_qsbr_synchronize(void) 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 +472,7 @@ test_rcu_qsbr_thread_online(void) 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 +499,9 @@ test_rcu_qsbr_thread_online(void) 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 +510,7 @@ test_rcu_qsbr_thread_online(void) 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 +530,7 @@ test_rcu_qsbr_thread_offline(void) 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 +558,10 @@ test_rcu_qsbr_thread_offline(void) /* * 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 +572,13 @@ test_rcu_qsbr_thread_offline(void) /* 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 +586,11 @@ test_rcu_qsbr_thread_offline(void) 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"); @@ -600,6 +598,330 @@ test_rcu_qsbr_thread_offline(void) return 0; } +static void +test_rcu_qsbr_free_resource1(void *p, void *e, unsigned int n) +{ + if (p != NULL || e != NULL || n != 1) { + printf("%s: Test failed\n", __func__); + cb_failed = 1; + } +} + +static void +test_rcu_qsbr_free_resource2(void *p, void *e, unsigned int n) +{ + if (p != NULL || e == NULL || n != 1) { + printf("%s: Test failed\n", __func__); + cb_failed = 1; + } +} + +/* + * rte_rcu_qsbr_dq_create: create a queue used to store the data structure + * elements that can be freed later. This queue is referred to as 'defer queue'. + */ +static int +test_rcu_qsbr_dq_create(void) +{ + char rcu_dq_name[RTE_RCU_QSBR_DQ_NAMESIZE]; + struct rte_rcu_qsbr_dq_parameters params; + struct rte_rcu_qsbr_dq *dq; + + printf("\nTest rte_rcu_qsbr_dq_create()\n"); + + /* Pass invalid parameters */ + dq = rte_rcu_qsbr_dq_create(NULL); + TEST_RCU_QSBR_RETURN_IF_ERROR((dq != NULL), "dq create invalid params"); + + memset(¶ms, 0, sizeof(struct rte_rcu_qsbr_dq_parameters)); + dq = rte_rcu_qsbr_dq_create(¶ms); + TEST_RCU_QSBR_RETURN_IF_ERROR((dq != NULL), "dq create invalid params"); + + snprintf(rcu_dq_name, sizeof(rcu_dq_name), "TEST_RCU"); + params.name = rcu_dq_name; + dq = rte_rcu_qsbr_dq_create(¶ms); + TEST_RCU_QSBR_RETURN_IF_ERROR((dq != NULL), "dq create invalid params"); + + params.free_fn = test_rcu_qsbr_free_resource1; + dq = rte_rcu_qsbr_dq_create(¶ms); + TEST_RCU_QSBR_RETURN_IF_ERROR((dq != NULL), "dq create invalid params"); + + rte_rcu_qsbr_init(t[0], RTE_MAX_LCORE); + params.v = t[0]; + dq = rte_rcu_qsbr_dq_create(¶ms); + TEST_RCU_QSBR_RETURN_IF_ERROR((dq != NULL), "dq create invalid params"); + + params.size = 1; + dq = rte_rcu_qsbr_dq_create(¶ms); + TEST_RCU_QSBR_RETURN_IF_ERROR((dq != NULL), "dq create invalid params"); + + params.esize = 3; + dq = rte_rcu_qsbr_dq_create(¶ms); + TEST_RCU_QSBR_RETURN_IF_ERROR((dq != NULL), "dq create invalid params"); + + params.trigger_reclaim_limit = 0; + params.max_reclaim_size = 0; + dq = rte_rcu_qsbr_dq_create(¶ms); + TEST_RCU_QSBR_RETURN_IF_ERROR((dq != NULL), "dq create invalid params"); + + /* Pass all valid parameters */ + params.esize = 16; + params.trigger_reclaim_limit = 0; + params.max_reclaim_size = params.size; + dq = rte_rcu_qsbr_dq_create(¶ms); + TEST_RCU_QSBR_RETURN_IF_ERROR((dq == NULL), "dq create valid params"); + rte_rcu_qsbr_dq_delete(dq); + + params.esize = 16; + params.flags = RTE_RCU_QSBR_DQ_MT_UNSAFE; + dq = rte_rcu_qsbr_dq_create(¶ms); + TEST_RCU_QSBR_RETURN_IF_ERROR((dq == NULL), "dq create valid params"); + rte_rcu_qsbr_dq_delete(dq); + + return 0; +} + +/* + * rte_rcu_qsbr_dq_enqueue: enqueue one resource to the defer queue, + * to be freed later after at least one grace period is over. + */ +static int +test_rcu_qsbr_dq_enqueue(void) +{ + int ret; + uint64_t r; + char rcu_dq_name[RTE_RCU_QSBR_DQ_NAMESIZE]; + struct rte_rcu_qsbr_dq_parameters params; + struct rte_rcu_qsbr_dq *dq; + + printf("\nTest rte_rcu_qsbr_dq_enqueue()\n"); + + /* Create a queue with simple parameters */ + memset(¶ms, 0, sizeof(struct rte_rcu_qsbr_dq_parameters)); + snprintf(rcu_dq_name, sizeof(rcu_dq_name), "TEST_RCU"); + params.name = rcu_dq_name; + params.free_fn = test_rcu_qsbr_free_resource1; + rte_rcu_qsbr_init(t[0], RTE_MAX_LCORE); + params.v = t[0]; + params.size = 1; + params.esize = 16; + params.trigger_reclaim_limit = 0; + params.max_reclaim_size = params.size; + dq = rte_rcu_qsbr_dq_create(¶ms); + TEST_RCU_QSBR_RETURN_IF_ERROR((dq == NULL), "dq create valid params"); + + /* Pass invalid parameters */ + ret = rte_rcu_qsbr_dq_enqueue(NULL, NULL); + TEST_RCU_QSBR_RETURN_IF_ERROR((ret == 0), "dq enqueue invalid params"); + + ret = rte_rcu_qsbr_dq_enqueue(dq, NULL); + TEST_RCU_QSBR_RETURN_IF_ERROR((ret == 0), "dq enqueue invalid params"); + + ret = rte_rcu_qsbr_dq_enqueue(NULL, &r); + TEST_RCU_QSBR_RETURN_IF_ERROR((ret == 0), "dq enqueue invalid params"); + + ret = rte_rcu_qsbr_dq_delete(dq); + TEST_RCU_QSBR_RETURN_IF_ERROR((ret == 1), "dq delete valid params"); + + return 0; +} + +/* + * rte_rcu_qsbr_dq_reclaim: Reclaim resources from the defer queue. + */ +static int +test_rcu_qsbr_dq_reclaim(void) +{ + int ret; + char rcu_dq_name[RTE_RCU_QSBR_DQ_NAMESIZE]; + struct rte_rcu_qsbr_dq_parameters params; + struct rte_rcu_qsbr_dq *dq; + + printf("\nTest rte_rcu_qsbr_dq_reclaim()\n"); + + /* Pass invalid parameters */ + ret = rte_rcu_qsbr_dq_reclaim(NULL, 10, NULL, NULL, NULL); + TEST_RCU_QSBR_RETURN_IF_ERROR((ret != 1), "dq reclaim invalid params"); + + /* Pass invalid parameters */ + memset(¶ms, 0, sizeof(struct rte_rcu_qsbr_dq_parameters)); + snprintf(rcu_dq_name, sizeof(rcu_dq_name), "TEST_RCU"); + params.name = rcu_dq_name; + params.free_fn = test_rcu_qsbr_free_resource1; + rte_rcu_qsbr_init(t[0], RTE_MAX_LCORE); + params.v = t[0]; + params.size = 1; + params.esize = 3; + params.trigger_reclaim_limit = 0; + params.max_reclaim_size = params.size; + dq = rte_rcu_qsbr_dq_create(¶ms); + ret = rte_rcu_qsbr_dq_reclaim(dq, 0, NULL, NULL, NULL); + TEST_RCU_QSBR_RETURN_IF_ERROR((ret != 1), "dq reclaim invalid params"); + + return 0; +} + +/* + * rte_rcu_qsbr_dq_delete: Delete a defer queue. + */ +static int +test_rcu_qsbr_dq_delete(void) +{ + int ret; + char rcu_dq_name[RTE_RCU_QSBR_DQ_NAMESIZE]; + struct rte_rcu_qsbr_dq_parameters params; + struct rte_rcu_qsbr_dq *dq; + + printf("\nTest rte_rcu_qsbr_dq_delete()\n"); + + /* Pass invalid parameters */ + ret = rte_rcu_qsbr_dq_delete(NULL); + TEST_RCU_QSBR_RETURN_IF_ERROR((ret != 0), "dq delete invalid params"); + + memset(¶ms, 0, sizeof(struct rte_rcu_qsbr_dq_parameters)); + snprintf(rcu_dq_name, sizeof(rcu_dq_name), "TEST_RCU"); + params.name = rcu_dq_name; + params.free_fn = test_rcu_qsbr_free_resource1; + rte_rcu_qsbr_init(t[0], RTE_MAX_LCORE); + params.v = t[0]; + params.size = 1; + params.esize = 16; + params.trigger_reclaim_limit = 0; + params.max_reclaim_size = params.size; + dq = rte_rcu_qsbr_dq_create(¶ms); + TEST_RCU_QSBR_RETURN_IF_ERROR((dq == NULL), "dq create valid params"); + ret = rte_rcu_qsbr_dq_delete(dq); + TEST_RCU_QSBR_RETURN_IF_ERROR((ret != 0), "dq delete valid params"); + + return 0; +} + +/* + * rte_rcu_qsbr_dq_enqueue: enqueue one resource to the defer queue, + * to be freed later after at least one grace period is over. + */ +static int +test_rcu_qsbr_dq_functional(int32_t size, int32_t esize, uint32_t flags) +{ + int i, j, ret; + char rcu_dq_name[RTE_RCU_QSBR_DQ_NAMESIZE]; + struct rte_rcu_qsbr_dq_parameters params; + struct rte_rcu_qsbr_dq *dq; + uint64_t *e; + uint64_t sc = 200; + int max_entries; + + printf("\nTest rte_rcu_qsbr_dq_xxx functional tests()\n"); + printf("Size = %d, esize = %d, flags = 0x%x\n", size, esize, flags); + + e = (uint64_t *)rte_zmalloc(NULL, esize, RTE_CACHE_LINE_SIZE); + if (e == NULL) + return 0; + cb_failed = 0; + + /* Initialize the RCU variable. No threads are registered */ + rte_rcu_qsbr_init(t[0], RTE_MAX_LCORE); + + /* Create a queue with simple parameters */ + memset(¶ms, 0, sizeof(struct rte_rcu_qsbr_dq_parameters)); + snprintf(rcu_dq_name, sizeof(rcu_dq_name), "TEST_RCU"); + params.name = rcu_dq_name; + params.flags = flags; + params.free_fn = test_rcu_qsbr_free_resource2; + params.v = t[0]; + params.size = size; + params.esize = esize; + params.trigger_reclaim_limit = size >> 3; + params.max_reclaim_size = (size >> 4)?(size >> 4):1; + dq = rte_rcu_qsbr_dq_create(¶ms); + TEST_RCU_QSBR_RETURN_IF_ERROR((dq == NULL), "dq create valid params"); + + /* Given the size calculate the maximum number of entries + * that can be stored on the defer queue (look at the logic used + * in capacity calculation of rte_ring). + */ + max_entries = rte_align32pow2(size + 1) - 1; + printf("max_entries = %d\n", max_entries); + + /* Enqueue few counters starting with the value 'sc' */ + /* The queue size will be rounded up to 2. The enqueue API also + * reclaims if the queue size is above certain limit. Since, there + * are no threads registered, reclamation succeeds. Hence, it should + * be possible to enqueue more than the provided queue size. + */ + for (i = 0; i < 10; i++) { + ret = rte_rcu_qsbr_dq_enqueue(dq, e); + TEST_RCU_QSBR_GOTO_IF_ERROR(end, (ret != 0), + "dq enqueue functional, i = %d", i); + for (j = 0; j < esize/8; j++) + e[j] = sc++; + } + + /* Validate that call back function did not return any error */ + TEST_RCU_QSBR_GOTO_IF_ERROR(end, (cb_failed == 1), "CB failed"); + + /* Register a thread on the RCU QSBR variable. Reclamation will not + * succeed. It should not be possible to enqueue more than the size + * number of resources. + */ + rte_rcu_qsbr_thread_register(t[0], 1); + rte_rcu_qsbr_thread_online(t[0], 1); + + for (i = 0; i < max_entries; i++) { + ret = rte_rcu_qsbr_dq_enqueue(dq, e); + TEST_RCU_QSBR_GOTO_IF_ERROR(end, (ret != 0), + "dq enqueue functional, max_entries = %d, i = %d", + max_entries, i); + for (j = 0; j < esize/8; j++) + e[j] = sc++; + } + + /* Enqueue fails as queue is full */ + ret = rte_rcu_qsbr_dq_enqueue(dq, e); + TEST_RCU_QSBR_GOTO_IF_ERROR(end, (ret == 0), "defer queue is not full"); + + /* Delete should fail as there are elements in defer queue which + * cannot be reclaimed. + */ + ret = rte_rcu_qsbr_dq_delete(dq); + TEST_RCU_QSBR_RETURN_IF_ERROR((ret == 0), "dq delete valid params"); + + /* Report quiescent state, enqueue should succeed */ + rte_rcu_qsbr_quiescent(t[0], 1); + for (i = 0; i < max_entries; i++) { + ret = rte_rcu_qsbr_dq_enqueue(dq, e); + TEST_RCU_QSBR_GOTO_IF_ERROR(end, (ret != 0), + "dq enqueue functional"); + for (j = 0; j < esize/8; j++) + e[j] = sc++; + } + + /* Validate that call back function did not return any error */ + TEST_RCU_QSBR_GOTO_IF_ERROR(end, (cb_failed == 1), "CB failed"); + + /* Queue is full */ + ret = rte_rcu_qsbr_dq_enqueue(dq, e); + TEST_RCU_QSBR_GOTO_IF_ERROR(end, (ret == 0), "defer queue is not full"); + + /* Report quiescent state, delete should succeed */ + rte_rcu_qsbr_quiescent(t[0], 1); + ret = rte_rcu_qsbr_dq_delete(dq); + TEST_RCU_QSBR_RETURN_IF_ERROR((ret != 0), "dq delete valid params"); + + rte_free(e); + + /* Validate that call back function did not return any error */ + TEST_RCU_QSBR_RETURN_IF_ERROR((cb_failed == 1), "CB failed"); + + return 0; + +end: + rte_free(e); + ret = rte_rcu_qsbr_dq_delete(dq); + TEST_RCU_QSBR_RETURN_IF_ERROR((ret != 0), "dq delete valid params"); + return -1; +} + /* * rte_rcu_qsbr_dump: Dump status of a single QS variable to a file */ @@ -615,8 +937,8 @@ test_rcu_qsbr_dump(void) 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 +1060,7 @@ init_hash(int hash_id) 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 +1102,7 @@ test_rcu_qsbr_sw_sv_3qs(void) 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); @@ -912,8 +1233,8 @@ error: static int test_rcu_qsbr_mw_mv_mqs(void) { - int i, j; - uint8_t test_cores; + unsigned int i, j; + unsigned int test_cores; writer_done = 0; test_cores = num_cores / 4; @@ -924,7 +1245,7 @@ test_rcu_qsbr_mw_mv_mqs(void) 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,12 +1319,17 @@ error: static int test_rcu_qsbr_main(void) { - if (get_enabled_cores_mask() != 0) - return -1; + uint16_t core_id; - if (num_cores < 4) { - printf("Test failed! Need 4 or more cores\n"); - goto test_fail; + if (rte_lcore_count() < 5) { + printf("Not enough cores for rcu_qsbr_autotest, expecting at least 5\n"); + return TEST_SKIPPED; + } + + num_cores = 0; + RTE_LCORE_FOREACH_SLAVE(core_id) { + enabled_core_ids[num_cores] = core_id; + num_cores++; } /* Error-checking test cases */ @@ -1039,6 +1365,18 @@ test_rcu_qsbr_main(void) if (test_rcu_qsbr_thread_offline() < 0) goto test_fail; + if (test_rcu_qsbr_dq_create() < 0) + goto test_fail; + + if (test_rcu_qsbr_dq_reclaim() < 0) + goto test_fail; + + if (test_rcu_qsbr_dq_delete() < 0) + goto test_fail; + + if (test_rcu_qsbr_dq_enqueue() < 0) + goto test_fail; + printf("\nFunctional tests\n"); if (test_rcu_qsbr_sw_sv_3qs() < 0) @@ -1047,6 +1385,18 @@ test_rcu_qsbr_main(void) if (test_rcu_qsbr_mw_mv_mqs() < 0) goto test_fail; + if (test_rcu_qsbr_dq_functional(1, 8, 0) < 0) + goto test_fail; + + if (test_rcu_qsbr_dq_functional(2, 8, RTE_RCU_QSBR_DQ_MT_UNSAFE) < 0) + goto test_fail; + + if (test_rcu_qsbr_dq_functional(303, 16, 0) < 0) + goto test_fail; + + if (test_rcu_qsbr_dq_functional(7, 128, RTE_RCU_QSBR_DQ_MT_UNSAFE) < 0) + goto test_fail; + free_rcu(); printf("\n");