/*
* assign_size -- assigns file and buffer size
* depending on the operation mode and type.
*/
static int
assign_size(struct pmem_bench *pmb, struct benchmark_args *args,
enum operation_type *op_type)
{
*op_type = parse_op_type(pmb->pargs->operation);
if (*op_type == OP_TYPE_UNKNOWN) {
fprintf(stderr, "Invalid operation argument '%s'",
pmb->pargs->operation);
return -1;
}
enum operation_mode op_mode_src =
parse_op_mode(pmb->pargs->src_mode);
if (op_mode_src == OP_MODE_UNKNOWN) {
fprintf(stderr, "Invalid source mode argument '%s'",
pmb->pargs->src_mode);
return -1;
}
enum operation_mode op_mode_dest =
parse_op_mode(pmb->pargs->dest_mode);
if (op_mode_dest == OP_MODE_UNKNOWN) {
fprintf(stderr, "Invalid destination mode argument '%s'",
pmb->pargs->dest_mode);
return -1;
}
size_t large = args->n_ops_per_thread
* pmb->pargs->chunk_size * args->n_threads;
size_t small = pmb->pargs->chunk_size;
if (*op_type == OP_TYPE_WRITE) {
pmb->bsize = op_mode_src == OP_MODE_STAT ? small : large;
pmb->fsize = op_mode_dest == OP_MODE_STAT ? small : large;
if (pmb->pargs->src_off != 0)
pmb->bsize += MAX_OFFSET;
if (pmb->pargs->dest_off != 0)
pmb->fsize += MAX_OFFSET;
} else {
pmb->fsize = op_mode_src == OP_MODE_STAT ? small : large;
pmb->bsize = op_mode_dest == OP_MODE_STAT ? small : large;
if (pmb->pargs->src_off != 0)
pmb->fsize += MAX_OFFSET;
if (pmb->pargs->dest_off != 0)
pmb->bsize += MAX_OFFSET;
}
return 0;
}
/*
* assign_mode_func -- parses "--src-mode" and "--dest-mode" command line
* arguments and returns one of the above mode functions.
*/
static offset_fn
assign_mode_func(char *option)
{
enum operation_mode op_mode = parse_op_mode(option);
switch (op_mode) {
case OP_MODE_STAT: return mode_stat;
case OP_MODE_SEQ: return mode_seq;
case OP_MODE_RAND: return mode_rand;
default: return NULL;
}
}
/*
* memset_init -- initialization function
*/
static int
memset_init(struct benchmark *bench, struct benchmark_args *args)
{
assert(bench != nullptr);
assert(args != nullptr);
assert(args->opts != nullptr);
int ret = 0;
size_t size;
size_t large;
size_t little;
size_t file_size = 0;
int flags = 0;
enum file_type type = util_file_get_type(args->fname);
if (type == OTHER_ERROR) {
fprintf(stderr, "could not check type of file %s\n",
args->fname);
return -1;
}
int (*warmup_func)(struct memset_bench *) = warmup_persist;
auto *mb = (struct memset_bench *)malloc(sizeof(struct memset_bench));
if (!mb) {
perror("malloc");
return -1;
}
mb->pargs = (struct memset_args *)args->opts;
mb->pargs->chunk_size = args->dsize;
enum operation_mode op_mode = parse_op_mode(mb->pargs->mode);
if (op_mode == OP_MODE_UNKNOWN) {
fprintf(stderr, "Invalid operation mode argument '%s'\n",
mb->pargs->mode);
ret = -1;
goto err_free_mb;
}
size = MAX_OFFSET + mb->pargs->chunk_size;
large = size * args->n_ops_per_thread * args->n_threads;
little = size * args->n_threads;
mb->fsize = (op_mode == OP_MODE_STAT) ? little : large;
/* initialize offsets[] array depending on benchmark args */
if (init_offsets(args, mb, op_mode) < 0) {
ret = -1;
goto err_free_mb;
}
/* initialize memset() value */
mb->const_b = CONST_B;
if (type != TYPE_DEVDAX) {
file_size = mb->fsize;
flags = PMEM_FILE_CREATE | PMEM_FILE_EXCL;
}
/* create a pmem file and memory map it */
if ((mb->pmem_addr = pmem_map_file(args->fname, file_size, flags,
args->fmode, nullptr, nullptr)) ==
nullptr) {
perror(args->fname);
ret = -1;
goto err_free_offsets;
}
if (mb->pargs->memset) {
if (mb->pargs->persist && mb->pargs->msync) {
fprintf(stderr,
"Invalid benchmark parameters: persist and msync cannot be specified together\n");
ret = -1;
goto err_free_offsets;
}
if (mb->pargs->persist) {
mb->func_op = libc_memset_persist;
} else if (mb->pargs->msync) {
mb->func_op = libc_memset_msync;
warmup_func = warmup_msync;
} else {
mb->func_op = libc_memset;
}
} else {
mb->func_op = (mb->pargs->persist) ? libpmem_memset_persist
: libpmem_memset_nodrain;
}
if (!mb->pargs->no_warmup && type != TYPE_DEVDAX) {
ret = warmup_func(mb);
if (ret) {
perror("Pool warmup failed");
goto err_free_offsets;
}
}
pmembench_set_priv(bench, mb);
return ret;
err_free_offsets:
free(mb->offsets);
err_free_mb:
free(mb);
return ret;
}
