#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 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[TOTAL_ENTRY];
static volatile uint8_t writer_done;
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_hash *h[TEST_RCU_MAX_LCORE];
-static char hash_name[TEST_RCU_MAX_LCORE][8];
+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;
static rte_atomic64_t update_cycles, check_cycles;
*/
#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)
{
static int
test_rcu_qsbr_perf(void)
{
- int i, sz;
- int tmp_num_cores;
+ size_t sz;
+ unsigned int i, tmp_num_cores;
writer_done = 0;
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,
/* Wait until all readers have exited */
rte_eal_mp_wait_lcore();
- printf("Total RCU updates = %"PRIi64"\n", rte_atomic64_read(&updates));
- printf("Cycles per %d updates: %"PRIi64"\n", RCU_SCALE_DOWN,
+ printf("Total quiescent state updates = %"PRIi64"\n",
+ rte_atomic64_read(&updates));
+ printf("Cycles per %d quiescent state updates: %"PRIi64"\n",
+ RCU_SCALE_DOWN,
rte_atomic64_read(&update_cycles) /
(rte_atomic64_read(&updates) / RCU_SCALE_DOWN));
printf("Total RCU checks = %"PRIi64"\n", rte_atomic64_read(&checks));
static int
test_rcu_qsbr_rperf(void)
{
- int i, sz;
- int tmp_num_cores;
+ size_t sz;
+ unsigned int i, tmp_num_cores;
rte_atomic64_clear(&updates);
rte_atomic64_clear(&update_cycles);
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,
/* Wait until all readers have exited */
rte_eal_mp_wait_lcore();
- printf("Total RCU updates = %"PRIi64"\n", rte_atomic64_read(&updates));
- printf("Cycles per %d updates: %"PRIi64"\n", RCU_SCALE_DOWN,
+ printf("Total quiescent state updates = %"PRIi64"\n",
+ rte_atomic64_read(&updates));
+ printf("Cycles per %d quiescent state updates: %"PRIi64"\n",
+ RCU_SCALE_DOWN,
rte_atomic64_read(&update_cycles) /
(rte_atomic64_read(&updates) / RCU_SCALE_DOWN));
static int
test_rcu_qsbr_wperf(void)
{
- int i, sz;
+ size_t sz;
+ unsigned int i;
rte_atomic64_clear(&checks);
rte_atomic64_clear(&check_cycles);
/* 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++)
uint32_t *pdata;
temp = t[read_type];
- hash = h[read_type];
+ hash = h;
rte_rcu_qsbr_thread_register(temp, thread_id);
rte_rcu_qsbr_thread_online(temp, thread_id);
for (i = 0; i < TOTAL_ENTRY; i++) {
rte_rcu_qsbr_lock(temp, thread_id);
- if (rte_hash_lookup_data(hash, keys+i,
+ if (rte_hash_lookup_data(hash, keys + i,
(void **)&pdata) != -ENOENT) {
- *pdata = 0;
- while (*pdata < COUNTER_VALUE)
- ++*pdata;
+ pdata[thread_id] = 0;
+ while (pdata[thread_id] < COUNTER_VALUE)
+ pdata[thread_id]++;
}
rte_rcu_qsbr_unlock(temp, thread_id);
}
return 0;
}
-static struct rte_hash *
-init_hash(int hash_id)
+static struct rte_hash *init_hash(void)
{
int i;
- struct rte_hash *h = NULL;
+ struct rte_hash *hash = NULL;
- sprintf(hash_name[hash_id], "hash%d", hash_id);
+ snprintf(hash_name, 8, "hash");
struct rte_hash_parameters hash_params = {
.entries = TOTAL_ENTRY,
.key_len = sizeof(uint32_t),
.hash_func = rte_hash_crc,
.extra_flag =
RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF,
- .name = hash_name[hash_id],
+ .name = hash_name,
};
- h = rte_hash_create(&hash_params);
- if (h == NULL) {
+ hash = rte_hash_create(&hash_params);
+ if (hash == NULL) {
printf("Hash create Failed\n");
return NULL;
}
for (i = 0; i < TOTAL_ENTRY; i++) {
- hash_data[hash_id][i] = rte_zmalloc(NULL, sizeof(uint32_t), 0);
- if (hash_data[hash_id][i] == NULL) {
+ hash_data[i] = rte_zmalloc(NULL,
+ sizeof(uint32_t) * RTE_MAX_LCORE, 0);
+ if (hash_data[i] == NULL) {
printf("No memory\n");
return NULL;
}
keys[i] = i;
for (i = 0; i < TOTAL_ENTRY; i++) {
- if (rte_hash_add_key_data(h, keys + i,
- (void *)((uintptr_t)hash_data[hash_id][i]))
- < 0) {
+ if (rte_hash_add_key_data(hash, keys + i,
+ (void *)((uintptr_t)hash_data[i])) < 0) {
printf("Hash key add Failed #%d\n", i);
return NULL;
}
}
- return h;
+ return hash;
}
/*
test_rcu_qsbr_sw_sv_1qs(void)
{
uint64_t token, begin, cycles;
- int i, tmp_num_cores, sz;
+ size_t sz;
+ unsigned int i, j, tmp_num_cores;
int32_t pos;
writer_done = 0;
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,
rte_rcu_qsbr_init(t[0], tmp_num_cores);
/* Shared data structure created */
- h[0] = init_hash(0);
- if (h[0] == NULL) {
+ h = init_hash();
+ if (h == NULL) {
printf("Hash init failed\n");
goto error;
}
for (i = 0; i < TOTAL_ENTRY; i++) {
/* Delete elements from the shared data structure */
- pos = rte_hash_del_key(h[0], keys + i);
+ pos = rte_hash_del_key(h, keys + i);
if (pos < 0) {
printf("Delete key failed #%d\n", keys[i]);
goto error;
/* Check the quiescent state status */
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,
- *hash_data[0][i]);
- goto error;
+ for (j = 0; j < tmp_num_cores; j++) {
+ if (hash_data[i][j] != COUNTER_VALUE &&
+ hash_data[i][j] != 0) {
+ printf("Reader thread ID %u did not complete #%d = %d\n",
+ j, i, hash_data[i][j]);
+ goto error;
+ }
}
- if (rte_hash_free_key_with_position(h[0], pos) < 0) {
+ if (rte_hash_free_key_with_position(h, pos) < 0) {
printf("Failed to free the key #%d\n", keys[i]);
goto error;
}
- rte_free(hash_data[0][i]);
- hash_data[0][i] = NULL;
+ rte_free(hash_data[i]);
+ hash_data[i] = NULL;
}
cycles = rte_rdtsc_precise() - begin;
for (i = 0; i < num_cores; i++)
if (rte_eal_wait_lcore(enabled_core_ids[i]) < 0)
goto error;
- rte_hash_free(h[0]);
+ rte_hash_free(h);
rte_free(keys);
printf("Following numbers include calls to rte_hash functions\n");
- printf("Cycles per 1 update(online/update/offline): %"PRIi64"\n",
+ printf("Cycles per 1 quiescent state update(online/update/offline): %"PRIi64"\n",
rte_atomic64_read(&update_cycles) /
rte_atomic64_read(&updates));
/* Wait until all readers have exited */
rte_eal_mp_wait_lcore();
- rte_hash_free(h[0]);
+ rte_hash_free(h);
rte_free(keys);
for (i = 0; i < TOTAL_ENTRY; i++)
- rte_free(hash_data[0][i]);
+ rte_free(hash_data[i]);
rte_free(t[0]);
test_rcu_qsbr_sw_sv_1qs_non_blocking(void)
{
uint64_t token, begin, cycles;
- int i, ret, tmp_num_cores, sz;
+ int ret;
+ size_t sz;
+ unsigned int i, j, tmp_num_cores;
int32_t pos;
writer_done = 0;
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,
rte_rcu_qsbr_init(t[0], tmp_num_cores);
/* Shared data structure created */
- h[0] = init_hash(0);
- if (h[0] == NULL) {
+ h = init_hash();
+ if (h == NULL) {
printf("Hash init failed\n");
goto error;
}
for (i = 0; i < TOTAL_ENTRY; i++) {
/* Delete elements from the shared data structure */
- pos = rte_hash_del_key(h[0], keys + i);
+ pos = rte_hash_del_key(h, keys + i);
if (pos < 0) {
printf("Delete key failed #%d\n", keys[i]);
goto error;
do {
ret = rte_rcu_qsbr_check(t[0], token, false);
} while (ret == 0);
- if (*hash_data[0][i] != COUNTER_VALUE &&
- *hash_data[0][i] != 0) {
- printf("Reader did not complete #%d = %d\n", i,
- *hash_data[0][i]);
- goto error;
+ for (j = 0; j < tmp_num_cores; j++) {
+ if (hash_data[i][j] != COUNTER_VALUE &&
+ hash_data[i][j] != 0) {
+ printf("Reader thread ID %u did not complete #%d = %d\n",
+ j, i, hash_data[i][j]);
+ goto error;
+ }
}
- if (rte_hash_free_key_with_position(h[0], pos) < 0) {
+ if (rte_hash_free_key_with_position(h, pos) < 0) {
printf("Failed to free the key #%d\n", keys[i]);
goto error;
}
- rte_free(hash_data[0][i]);
- hash_data[0][i] = NULL;
+ rte_free(hash_data[i]);
+ hash_data[i] = NULL;
}
cycles = rte_rdtsc_precise() - begin;
for (i = 0; i < num_cores; i++)
if (rte_eal_wait_lcore(enabled_core_ids[i]) < 0)
goto error;
- rte_hash_free(h[0]);
+ rte_hash_free(h);
rte_free(keys);
printf("Following numbers include calls to rte_hash functions\n");
- printf("Cycles per 1 update(online/update/offline): %"PRIi64"\n",
+ printf("Cycles per 1 quiescent state update(online/update/offline): %"PRIi64"\n",
rte_atomic64_read(&update_cycles) /
rte_atomic64_read(&updates));
/* Wait until all readers have exited */
rte_eal_mp_wait_lcore();
- rte_hash_free(h[0]);
+ rte_hash_free(h);
rte_free(keys);
for (i = 0; i < TOTAL_ENTRY; i++)
- rte_free(hash_data[0][i]);
+ rte_free(hash_data[i]);
rte_free(t[0]);
static int
test_rcu_qsbr_main(void)
{
+ uint16_t core_id;
+
+ if (rte_lcore_count() < 3) {
+ printf("Not enough cores for rcu_qsbr_perf_autotest, expecting at least 3\n");
+ return TEST_SKIPPED;
+ }
+
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;
-
- 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;
+ 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);
printf("Perf test with all reader threads registered\n");
printf("--------------------------------------------\n");
all_registered = 1;
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;
}
git.droids-corp.org / dpdk.git / blobdiff