The following changes since commit 59f94d26f98e9c0bc18d4e013f3361c51a2c6b25: Change ARRAY_SIZE to FIO_ARRAY_SIZE (2021-01-06 11:32:59 -0700) are available in the Git repository at: git://git.kernel.dk/fio.git master for you to fetch changes up to 8f14dc61422df3b1eaee1293a7d10ba791c8084c: Merge branch 'cpu-engine' of https://github.com/bvanassche/fio (2021-01-07 20:53:00 -0700) ---------------------------------------------------------------- Bart Van Assche (1): engines/cpu: Fix td_vmsg() call Erwan Velu (1): engines/cpu: Adding qsort capabilities Jens Axboe (3): Merge branch 'evelu-qsort' of https://github.com/ErwanAliasr1/fio engines/cpu: style cleanups Merge branch 'cpu-engine' of https://github.com/bvanassche/fio HOWTO | 6 +- engines/cpu.c | 233 ++++++++++++++++++++++++++++++++++++++++++++++++++--- examples/cpuio.fio | 14 +++- fio.1 | 21 +++-- 4 files changed, 254 insertions(+), 20 deletions(-) --- Diff of recent changes: diff --git a/HOWTO b/HOWTO index d663166d..0547c721 100644 --- a/HOWTO +++ b/HOWTO @@ -1912,12 +1912,14 @@ I/O engine **cpuio** Doesn't transfer any data, but burns CPU cycles according to the - :option:`cpuload` and :option:`cpuchunks` options. Setting - :option:`cpuload`\=85 will cause that job to do nothing but burn 85% + :option:`cpuload`, :option:`cpuchunks` and :option:`cpumode` options. + Setting :option:`cpuload`\=85 will cause that job to do nothing but burn 85% of the CPU. In case of SMP machines, use :option:`numjobs`\=<nr_of_cpu> to get desired CPU usage, as the cpuload only loads a single CPU at the desired rate. A job never finishes unless there is at least one non-cpuio job. + Setting :option:`cpumode`\=qsort replace the default noop instructions loop + by a qsort algorithm to consume more energy. **rdma** The RDMA I/O engine supports both RDMA memory semantics diff --git a/engines/cpu.c b/engines/cpu.c index 4d572b44..ccbfe003 100644 --- a/engines/cpu.c +++ b/engines/cpu.c @@ -8,11 +8,26 @@ #include "../fio.h" #include "../optgroup.h" +// number of 32 bit integers to sort +size_t qsort_size = (256 * (1ULL << 10)); // 256KB + +struct mwc { + uint32_t w; + uint32_t z; +}; + +enum stress_mode { + FIO_CPU_NOOP = 0, + FIO_CPU_QSORT = 1, +}; + struct cpu_options { void *pad; unsigned int cpuload; unsigned int cpucycle; + enum stress_mode cpumode; unsigned int exit_io_done; + int32_t *qsort_data; }; static struct fio_option options[] = { @@ -25,6 +40,26 @@ static struct fio_option options[] = { .category = FIO_OPT_C_ENGINE, .group = FIO_OPT_G_INVALID, }, + { + .name = "cpumode", + .lname = "cpumode", + .type = FIO_OPT_STR, + .help = "Stress mode", + .off1 = offsetof(struct cpu_options, cpumode), + .def = "noop", + .posval = { + { .ival = "noop", + .oval = FIO_CPU_NOOP, + .help = "NOOP instructions", + }, + { .ival = "qsort", + .oval = FIO_CPU_QSORT, + .help = "QSORT computation", + }, + }, + .category = FIO_OPT_C_ENGINE, + .group = FIO_OPT_G_INVALID, + }, { .name = "cpuchunks", .lname = "CPU chunk", @@ -52,6 +87,91 @@ static struct fio_option options[] = { }, }; +/* + * mwc32() + * Multiply-with-carry random numbers + * fast pseudo random number generator, see + * http://www.cse.yorku.ca/~oz/marsaglia-rng.html + */ +uint32_t mwc32(struct mwc *mwc) +{ + mwc->z = 36969 * (mwc->z & 65535) + (mwc->z >> 16); + mwc->w = 18000 * (mwc->w & 65535) + (mwc->w >> 16); + return (mwc->z << 16) + mwc->w; +} + +/* + * stress_qsort_cmp_1() + * qsort comparison - sort on int32 values + */ +static int stress_qsort_cmp_1(const void *p1, const void *p2) +{ + const int32_t *i1 = (const int32_t *)p1; + const int32_t *i2 = (const int32_t *)p2; + + if (*i1 > *i2) + return 1; + else if (*i1 < *i2) + return -1; + else + return 0; +} + +/* + * stress_qsort_cmp_2() + * qsort comparison - reverse sort on int32 values + */ +static int stress_qsort_cmp_2(const void *p1, const void *p2) +{ + return stress_qsort_cmp_1(p2, p1); +} + +/* + * stress_qsort_cmp_3() + * qsort comparison - sort on int8 values + */ +static int stress_qsort_cmp_3(const void *p1, const void *p2) +{ + const int8_t *i1 = (const int8_t *)p1; + const int8_t *i2 = (const int8_t *)p2; + + /* Force re-ordering on 8 bit value */ + return *i1 - *i2; +} + +static int do_qsort(struct thread_data *td) +{ + struct thread_options *o = &td->o; + struct cpu_options *co = td->eo; + struct timespec start, now; + + fio_get_mono_time(&start); + + /* Sort "random" data */ + qsort(co->qsort_data, qsort_size, sizeof(*(co->qsort_data)), stress_qsort_cmp_1); + + /* Reverse sort */ + qsort(co->qsort_data, qsort_size, sizeof(*(co->qsort_data)), stress_qsort_cmp_2); + + /* And re-order by byte compare */ + qsort((uint8_t *)co->qsort_data, qsort_size * 4, sizeof(uint8_t), stress_qsort_cmp_3); + + /* Reverse sort this again */ + qsort(co->qsort_data, qsort_size, sizeof(*(co->qsort_data)), stress_qsort_cmp_2); + fio_get_mono_time(&now); + + /* Adjusting cpucycle automatically to be as close as possible to the + * expected cpuload The time to execute do_qsort() may change over time + * as per : - the job concurrency - the cpu clock adjusted by the power + * management After every do_qsort() call, the next thinktime is + * adjusted regarding the last run performance + */ + co->cpucycle = utime_since(&start, &now); + o->thinktime = ((unsigned long long) co->cpucycle * + (100 - co->cpuload)) / co->cpuload; + + return 0; +} static enum fio_q_status fio_cpuio_queue(struct thread_data *td, struct io_u fio_unused *io_u) @@ -63,14 +183,69 @@ static enum fio_q_status fio_cpuio_queue(struct thread_data *td, return FIO_Q_BUSY; } - usec_spin(co->cpucycle); + switch (co->cpumode) { + case FIO_CPU_NOOP: + usec_spin(co->cpucycle); + break; + case FIO_CPU_QSORT: + do_qsort(td); + break; + } + return FIO_Q_COMPLETED; } +static int noop_init(struct thread_data *td) +{ + struct cpu_options *co = td->eo; + + log_info("%s (noop): ioengine=%s, cpuload=%u, cpucycle=%u\n", + td->o.name, td->io_ops->name, co->cpuload, co->cpucycle); + return 0; +} + +static int qsort_cleanup(struct thread_data *td) +{ + struct cpu_options *co = td->eo; + + if (co->qsort_data) { + free(co->qsort_data); + co->qsort_data = NULL; + } + + return 0; +} + +static int qsort_init(struct thread_data *td) +{ + /* Setting up a default entropy */ + struct mwc mwc = { 521288629UL, 362436069UL }; + struct cpu_options *co = td->eo; + int32_t *ptr; + int i; + + co->qsort_data = calloc(qsort_size, sizeof(*co->qsort_data)); + if (co->qsort_data == NULL) { + td_verror(td, ENOMEM, "qsort_init"); + return 1; + } + + /* This is expensive, init the memory once */ + for (ptr = co->qsort_data, i = 0; i < qsort_size; i++) + *ptr++ = mwc32(&mwc); + + log_info("%s (qsort): ioengine=%s, cpuload=%u, cpucycle=%u\n", + td->o.name, td->io_ops->name, co->cpuload, co->cpucycle); + + return 0; +} + static int fio_cpuio_init(struct thread_data *td) { struct thread_options *o = &td->o; struct cpu_options *co = td->eo; + int td_previous_state; + char *msg; if (!co->cpuload) { td_vmsg(td, EINVAL, "cpu thread needs rate (cpuload=)","cpuio"); @@ -80,21 +255,58 @@ static int fio_cpuio_init(struct thread_data *td) if (co->cpuload > 100) co->cpuload = 100; + /* Saving the current thread state */ + td_previous_state = td->runstate; + + /* Reporting that we are preparing the engine + * This is useful as the qsort() calibration takes time + * This prevents the job from starting before init is completed + */ + td_set_runstate(td, TD_SETTING_UP); + /* * set thinktime_sleep and thinktime_spin appropriately */ o->thinktime_blocks = 1; o->thinktime_spin = 0; - o->thinktime = ((unsigned long long) co->cpucycle * (100 - co->cpuload)) / co->cpuload; + o->thinktime = ((unsigned long long) co->cpucycle * + (100 - co->cpuload)) / co->cpuload; o->nr_files = o->open_files = 1; - log_info("%s: ioengine=%s, cpuload=%u, cpucycle=%u\n", - td->o.name, td->io_ops->name, co->cpuload, co->cpucycle); + switch (co->cpumode) { + case FIO_CPU_NOOP: + noop_init(td); + break; + case FIO_CPU_QSORT: + qsort_init(td); + break; + default: + if (asprintf(&msg, "bad cpu engine mode: %d", co->cpumode) < 0) + msg = NULL; + td_vmsg(td, EINVAL, msg ? : "(?)", __func__); + free(msg); + return 1; + } + /* Let's restore the previous state. */ + td_set_runstate(td, td_previous_state); return 0; } +static void fio_cpuio_cleanup(struct thread_data *td) +{ + struct cpu_options *co = td->eo; + + switch (co->cpumode) { + case FIO_CPU_NOOP: + break; + case FIO_CPU_QSORT: + qsort_cleanup(td); + break; + } +} + static int fio_cpuio_open(struct thread_data fio_unused *td, struct fio_file fio_unused *f) { @@ -102,12 +314,13 @@ static int fio_cpuio_open(struct thread_data fio_unused *td, } static struct ioengine_ops ioengine = { - .name = "cpuio", - .version = FIO_IOOPS_VERSION, - .queue = fio_cpuio_queue, - .init = fio_cpuio_init, - .open_file = fio_cpuio_open, - .flags = FIO_SYNCIO | FIO_DISKLESSIO | FIO_NOIO, + .name = "cpuio", + .version = FIO_IOOPS_VERSION, + .queue = fio_cpuio_queue, + .init = fio_cpuio_init, + .cleanup = fio_cpuio_cleanup, + .open_file = fio_cpuio_open, + .flags = FIO_SYNCIO | FIO_DISKLESSIO | FIO_NOIO, .options = options, .option_struct_size = sizeof(struct cpu_options), }; diff --git a/examples/cpuio.fio b/examples/cpuio.fio index 577e0729..471cf4b2 100644 --- a/examples/cpuio.fio +++ b/examples/cpuio.fio @@ -1,8 +1,18 @@ [global] ioengine=cpuio time_based -runtime=10 +runtime=15 -[burn50percent] +# The following example load 2 cores at 50% with the noop (default) mode +[burn_2x50_noop] cpuload=50 +numjobs=2 +cpumode=noop +# Once burn_2x50_noop is over, +# fio load 2 cores at 50% with the qsort mode which drains much more power +[burn_2x50%_qsort] +stonewall +cpuload=50 +numjobs=2 +cpumode=qsort diff --git a/fio.1 b/fio.1 index b29ac437..e361b05f 100644 --- a/fio.1 +++ b/fio.1 @@ -1690,12 +1690,21 @@ This engine defines engine specific options. .TP .B cpuio Doesn't transfer any data, but burns CPU cycles according to the -\fBcpuload\fR and \fBcpuchunks\fR options. Setting -\fBcpuload\fR\=85 will cause that job to do nothing but burn 85% -of the CPU. In case of SMP machines, use `numjobs=<nr_of_cpu>' -to get desired CPU usage, as the cpuload only loads a -single CPU at the desired rate. A job never finishes unless there is -at least one non-cpuio job. +\fBcpuload\fR, \fBcpuchunks\fR and \fBcpumode\fR options. +A job never finishes unless there is at least one non-cpuio job. +.RS +.P +.PD 0 +\fBcpuload\fR\=85 will cause that job to do nothing but burn 85% of the CPU. +In case of SMP machines, use \fBnumjobs=<nr_of_cpu>\fR\ to get desired CPU usage, +as the cpuload only loads a single CPU at the desired rate. + +.P +\fBcpumode\fR\=qsort replace the default noop instructions loop +by a qsort algorithm to consume more energy. + +.P +.RE .TP .B rdma The RDMA I/O engine supports both RDMA memory semantics
