examples/accel perf: add compare workload

Optionally let the user specify what % into the buffers there should
be a miscompare if desired.

Signed-off-by: paul luse <paul.e.luse@intel.com>
Change-Id: I3a5524de5e0f7cb91fcf92e76f937bdf280a515b
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/2109
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Darek Stojaczyk <dariusz.stojaczyk@intel.com>
Reviewed-by: Ben Walker <benjamin.walker@intel.com>
Reviewed-by: Shuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
This commit is contained in:
paul luse 2020-04-29 18:57:06 -04:00 committed by Tomasz Zawadzki
parent 964463e420
commit b9218b7ac6
2 changed files with 95 additions and 46 deletions

View File

@ -13,7 +13,7 @@ The software accel engine implemenation has added support for CRC-32C.
A new capability, compare, was added via `spdk_accel_submit_compare`. A new capability, compare, was added via `spdk_accel_submit_compare`.
The software accel engine implemenation has added support forCRC-32Cc and compare. The software accel engine implemenation has added support for compare.
### idxd ### idxd

View File

@ -40,6 +40,8 @@
#include "spdk/accel_engine.h" #include "spdk/accel_engine.h"
#include "spdk/crc32.h" #include "spdk/crc32.h"
#define DATA_PATTERN 0x5a
static uint64_t g_tsc_rate; static uint64_t g_tsc_rate;
static uint64_t g_tsc_us_rate; static uint64_t g_tsc_us_rate;
static uint64_t g_tsc_end; static uint64_t g_tsc_end;
@ -47,6 +49,7 @@ static int g_xfer_size_bytes = 4096;
static int g_queue_depth = 32; static int g_queue_depth = 32;
static int g_time_in_sec = 5; static int g_time_in_sec = 5;
static uint32_t g_crc32c_seed = 0; static uint32_t g_crc32c_seed = 0;
static int g_fail_percent_goal = 0;
static bool g_verify = false; static bool g_verify = false;
static const char *g_workload_type = NULL; static const char *g_workload_type = NULL;
static enum accel_capability g_workload_selection; static enum accel_capability g_workload_selection;
@ -58,8 +61,8 @@ struct worker_thread {
struct spdk_io_channel *ch; struct spdk_io_channel *ch;
uint64_t xfer_completed; uint64_t xfer_completed;
uint64_t xfer_failed; uint64_t xfer_failed;
uint64_t injected_miscompares;
uint64_t current_queue_depth; uint64_t current_queue_depth;
struct spdk_mempool *data_pool;
struct spdk_mempool *task_pool; struct spdk_mempool *task_pool;
struct worker_thread *next; struct worker_thread *next;
unsigned core; unsigned core;
@ -73,6 +76,8 @@ struct ap_task {
void *src; void *src;
void *dst; void *dst;
struct worker_thread *worker; struct worker_thread *worker;
int status;
int expected_status; /* used for compare */
}; };
inline static struct ap_task * inline static struct ap_task *
@ -94,8 +99,10 @@ dump_user_config(struct spdk_app_opts *opts)
printf("Core mask: %s\n\n", opts->reactor_mask); printf("Core mask: %s\n\n", opts->reactor_mask);
printf("Accel Perf Configuration:\n"); printf("Accel Perf Configuration:\n");
printf("Workload Type: %s\n", g_workload_type); printf("Workload Type: %s\n", g_workload_type);
if (!strcmp(g_workload_type, "crc32c")) { if (g_workload_selection == ACCEL_CRC32C) {
printf("CRC-32C seed: %u", g_crc32c_seed); printf("CRC-32C seed: %u\n", g_crc32c_seed);
} else if ((g_workload_selection == ACCEL_COMPARE) && g_fail_percent_goal > 0) {
printf("Miscompare: %u percent\n", g_fail_percent_goal);
} }
printf("Transfer size: %u bytes\n", g_xfer_size_bytes); printf("Transfer size: %u bytes\n", g_xfer_size_bytes);
printf("Queue depth: %u\n", g_queue_depth); printf("Queue depth: %u\n", g_queue_depth);
@ -112,8 +119,9 @@ usage(void)
printf("\t[-n number of channels]\n"); printf("\t[-n number of channels]\n");
printf("\t[-o transfer size in bytes]\n"); printf("\t[-o transfer size in bytes]\n");
printf("\t[-t time in seconds]\n"); printf("\t[-t time in seconds]\n");
printf("\t[-w workload type must be one of these: copy, fill, crc32c\n"); printf("\t[-w workload type must be one of these: copy, fill, crc32c, compare\n");
printf("\t[-s for crc32c workload, use this seed value (default 0)\n"); printf("\t[-s for crc32c workload, use this seed value (default 0)\n");
printf("\t[-P for compare workload, percentage of operations that should miscompare (percent, default 0)\n");
printf("\t[-y verify result if this switch is on]\n"); printf("\t[-y verify result if this switch is on]\n");
} }
@ -124,6 +132,9 @@ parse_args(int argc, char *argv)
case 'o': case 'o':
g_xfer_size_bytes = spdk_strtol(optarg, 10); g_xfer_size_bytes = spdk_strtol(optarg, 10);
break; break;
case 'P':
g_fail_percent_goal = spdk_strtol(optarg, 10);
break;
case 'q': case 'q':
g_queue_depth = spdk_strtol(optarg, 10); g_queue_depth = spdk_strtol(optarg, 10);
break; break;
@ -144,6 +155,8 @@ parse_args(int argc, char *argv)
g_workload_selection = ACCEL_FILL; g_workload_selection = ACCEL_FILL;
} else if (!strcmp(g_workload_type, "crc32c")) { } else if (!strcmp(g_workload_type, "crc32c")) {
g_workload_selection = ACCEL_CRC32C; g_workload_selection = ACCEL_CRC32C;
} else if (!strcmp(g_workload_type, "compare")) {
g_workload_selection = ACCEL_COMPARE;
} }
break; break;
default: default:
@ -158,7 +171,6 @@ unregister_worker(void *arg1)
{ {
struct worker_thread *worker = arg1; struct worker_thread *worker = arg1;
spdk_mempool_free(worker->data_pool);
spdk_mempool_free(worker->task_pool); spdk_mempool_free(worker->task_pool);
spdk_put_io_channel(worker->ch); spdk_put_io_channel(worker->ch);
pthread_mutex_lock(&g_workers_lock); pthread_mutex_lock(&g_workers_lock);
@ -177,13 +189,10 @@ _submit_single(void *arg1, void *arg2)
{ {
struct worker_thread *worker = arg1; struct worker_thread *worker = arg1;
struct ap_task *task = arg2; struct ap_task *task = arg2;
int random_num;
assert(worker); assert(worker);
if (g_verify) {
memset(task->src, 0x5a, g_xfer_size_bytes);
memset(task->dst, 0xa5, g_xfer_size_bytes);
}
task->worker = worker; task->worker = worker;
task->worker->current_queue_depth++; task->worker->current_queue_depth++;
switch (g_workload_selection) { switch (g_workload_selection) {
@ -203,6 +212,19 @@ _submit_single(void *arg1, void *arg2)
worker->ch, (uint32_t *)task->dst, task->src, g_crc32c_seed, worker->ch, (uint32_t *)task->dst, task->src, g_crc32c_seed,
g_xfer_size_bytes, accel_done); g_xfer_size_bytes, accel_done);
break; break;
case ACCEL_COMPARE:
random_num = rand() % 100;
if (random_num < g_fail_percent_goal) {
task->expected_status = -EILSEQ;
*(uint8_t *)task->dst = ~DATA_PATTERN;
} else {
task->expected_status = 0;
*(uint8_t *)task->dst = DATA_PATTERN;
}
spdk_accel_submit_compare(__accel_task_from_ap_task(task),
worker->ch, task->dst, task->src,
g_xfer_size_bytes, accel_done);
break;
default: default:
assert(false); assert(false);
break; break;
@ -220,31 +242,44 @@ _accel_done(void *arg1)
assert(worker); assert(worker);
assert(worker->current_queue_depth > 0); assert(worker->current_queue_depth > 0);
if (g_verify) { if (g_verify && task->status == 0) {
if (!strcmp(g_workload_type, "crc32c")) { switch (g_workload_selection) {
case ACCEL_CRC32C:
/* calculate sw CRC-32C and compare to sw aceel result. */ /* calculate sw CRC-32C and compare to sw aceel result. */
sw_crc32c = spdk_crc32c_update(task->src, g_xfer_size_bytes, ~g_crc32c_seed); sw_crc32c = spdk_crc32c_update(task->src, g_xfer_size_bytes, ~g_crc32c_seed);
if (*(uint32_t *)task->dst != sw_crc32c) { if (*(uint32_t *)task->dst != sw_crc32c) {
SPDK_NOTICELOG("CRC-32C miscompare\n"); SPDK_NOTICELOG("CRC-32C miscompare\n");
worker->xfer_failed++; worker->xfer_failed++;
/* TODO: cleanup */
exit(-1);
} }
} else if (memcmp(task->src, task->dst, g_xfer_size_bytes)) { break;
case ACCEL_COPY:
if (memcmp(task->src, task->dst, g_xfer_size_bytes)) {
SPDK_NOTICELOG("Data miscompare\n"); SPDK_NOTICELOG("Data miscompare\n");
worker->xfer_failed++; worker->xfer_failed++;
/* TODO: cleanup */ }
exit(-1); break;
default:
assert(false);
break;
} }
} }
if (task->expected_status == -EILSEQ) {
assert(task->status != 0);
worker->injected_miscompares++;
} else if (task->status) {
/* Expected to pass but API reported error. */
worker->xfer_failed++;
}
worker->xfer_completed++; worker->xfer_completed++;
worker->current_queue_depth--; worker->current_queue_depth--;
if (!worker->is_draining) { if (!worker->is_draining && worker->xfer_failed == 0) {
_submit_single(worker, task); _submit_single(worker, task);
} else { } else {
spdk_mempool_put(worker->data_pool, task->src); spdk_free(task->src);
spdk_mempool_put(worker->data_pool, task->dst); spdk_free(task->dst);
spdk_mempool_put(worker->task_pool, task); spdk_mempool_put(worker->task_pool, task);
} }
} }
@ -254,11 +289,12 @@ dump_result(void)
{ {
uint64_t total_completed = 0; uint64_t total_completed = 0;
uint64_t total_failed = 0; uint64_t total_failed = 0;
uint64_t total_miscompared = 0;
uint64_t total_xfer_per_sec, total_bw_in_MiBps; uint64_t total_xfer_per_sec, total_bw_in_MiBps;
struct worker_thread *worker = g_workers; struct worker_thread *worker = g_workers;
printf("\nCore Transfers Bandwidth Failed\n"); printf("\nCore Transfers Bandwidth Failed Miscompares\n");
printf("-------------------------------------------------\n"); printf("-----------------------------------------------------------------\n");
while (worker != NULL) { while (worker != NULL) {
uint64_t xfer_per_sec = worker->xfer_completed / g_time_in_sec; uint64_t xfer_per_sec = worker->xfer_completed / g_time_in_sec;
@ -267,11 +303,12 @@ dump_result(void)
total_completed += worker->xfer_completed; total_completed += worker->xfer_completed;
total_failed += worker->xfer_failed; total_failed += worker->xfer_failed;
total_miscompared += worker->injected_miscompares;
if (xfer_per_sec) { if (xfer_per_sec) {
printf("%10d%12" PRIu64 "/s%8" PRIu64 " MiB/s%11" PRIu64 "\n", printf("%10d%12" PRIu64 "/s%8" PRIu64 " MiB/s%11" PRIu64 " %11" PRIu64 "\n",
worker->core, xfer_per_sec, worker->core, xfer_per_sec,
bw_in_MiBps, worker->xfer_failed); bw_in_MiBps, worker->xfer_failed, worker->injected_miscompares);
} }
worker = worker->next; worker = worker->next;
@ -281,9 +318,9 @@ dump_result(void)
total_bw_in_MiBps = (total_completed * g_xfer_size_bytes) / total_bw_in_MiBps = (total_completed * g_xfer_size_bytes) /
(g_time_in_sec * 1024 * 1024); (g_time_in_sec * 1024 * 1024);
printf("=================================================\n"); printf("==================================================================\n");
printf("Total:%16" PRIu64 "/s%8" PRIu64 " MiB/s%11" PRIu64 "\n\n", printf("Total:%16" PRIu64 "/s%8" PRIu64 " MiB/s%11" PRIu64 " %11" PRIu64"\n\n",
total_xfer_per_sec, total_bw_in_MiBps, total_failed); total_xfer_per_sec, total_bw_in_MiBps, total_failed, total_miscompared);
return total_failed ? 1 : 0; return total_failed ? 1 : 0;
} }
@ -328,7 +365,7 @@ static void
_init_thread(void *arg1) _init_thread(void *arg1)
{ {
struct worker_thread *worker; struct worker_thread *worker;
char buf_pool_name[30], task_pool_name[30]; char task_pool_name[30];
struct ap_task *task; struct ap_task *task;
int i; int i;
@ -342,22 +379,15 @@ _init_thread(void *arg1)
worker->thread = spdk_get_thread(); worker->thread = spdk_get_thread();
worker->next = g_workers; worker->next = g_workers;
worker->ch = spdk_accel_engine_get_io_channel(); worker->ch = spdk_accel_engine_get_io_channel();
snprintf(buf_pool_name, sizeof(buf_pool_name), "buf_pool_%d", g_num_workers);
snprintf(task_pool_name, sizeof(task_pool_name), "task_pool_%d", g_num_workers); snprintf(task_pool_name, sizeof(task_pool_name), "task_pool_%d", g_num_workers);
worker->data_pool = spdk_mempool_create(buf_pool_name,
g_queue_depth * 2, /* src + dst */
g_xfer_size_bytes,
SPDK_MEMPOOL_DEFAULT_CACHE_SIZE,
SPDK_ENV_SOCKET_ID_ANY);
worker->task_pool = spdk_mempool_create(task_pool_name, worker->task_pool = spdk_mempool_create(task_pool_name,
g_queue_depth, g_queue_depth,
spdk_accel_task_size() + sizeof(struct ap_task), spdk_accel_task_size() + sizeof(struct ap_task),
SPDK_MEMPOOL_DEFAULT_CACHE_SIZE, SPDK_MEMPOOL_DEFAULT_CACHE_SIZE,
SPDK_ENV_SOCKET_ID_ANY); SPDK_ENV_SOCKET_ID_ANY);
if (!worker->data_pool || !worker->task_pool) { if (!worker->task_pool) {
fprintf(stderr, "Could not allocate buffer pool.\n"); fprintf(stderr, "Could not allocate buffer pool.\n");
spdk_mempool_free(worker->data_pool);
spdk_mempool_free(worker->task_pool);
free(worker); free(worker);
return; return;
} }
@ -377,8 +407,26 @@ _init_thread(void *arg1)
fprintf(stderr, "Unable to get accel_task\n"); fprintf(stderr, "Unable to get accel_task\n");
return; return;
} }
task->src = spdk_mempool_get(worker->data_pool);
task->dst = spdk_mempool_get(worker->data_pool); task->src = spdk_dma_zmalloc(g_xfer_size_bytes, 0, NULL);
if (task->src == NULL) {
fprintf(stderr, "Unable to alloc src buffer\n");
return;
}
memset(task->src, DATA_PATTERN, g_xfer_size_bytes);
task->dst = spdk_dma_zmalloc(g_xfer_size_bytes, 0, NULL);
if (task->dst == NULL) {
fprintf(stderr, "Unable to alloc dst buffer\n");
return;
}
/* For compare we want the buffers to match, otherwise not. */
if (g_workload_selection == ACCEL_COMPARE) {
memset(task->dst, DATA_PATTERN, g_xfer_size_bytes);
} else {
memset(task->dst, ~DATA_PATTERN, g_xfer_size_bytes);
}
_submit_single(worker, task); _submit_single(worker, task);
} }
} }
@ -391,6 +439,7 @@ accel_done(void *ref, int status)
assert(worker); assert(worker);
task->status = status;
spdk_thread_send_msg(worker->thread, _accel_done, task); spdk_thread_send_msg(worker->thread, _accel_done, task);
} }
@ -431,16 +480,16 @@ main(int argc, char **argv)
pthread_mutex_init(&g_workers_lock, NULL); pthread_mutex_init(&g_workers_lock, NULL);
spdk_app_opts_init(&opts); spdk_app_opts_init(&opts);
opts.reactor_mask = "0x1"; opts.reactor_mask = "0x1";
if ((rc = spdk_app_parse_args(argc, argv, &opts, "o:q:t:yw:", NULL, parse_args, if ((rc = spdk_app_parse_args(argc, argv, &opts, "o:q:t:yw:P:", NULL, parse_args,
usage)) != SPDK_APP_PARSE_ARGS_SUCCESS) { usage)) != SPDK_APP_PARSE_ARGS_SUCCESS) {
rc = -1; rc = -1;
goto cleanup; goto cleanup;
} }
if (g_workload_type == NULL || if ((g_workload_selection != ACCEL_COPY) &&
(strcmp(g_workload_type, "copy") && (g_workload_selection != ACCEL_FILL) &&
strcmp(g_workload_type, "fill") && (g_workload_selection != ACCEL_CRC32C) &&
strcmp(g_workload_type, "crc32c"))) { (g_workload_selection != ACCEL_COMPARE)) {
usage(); usage();
rc = -1; rc = -1;
goto cleanup; goto cleanup;