X-Git-Url: https://git.kernel.dk/?a=blobdiff_plain;f=engines%2Fcpu.c;h=ccbfe00355a0b79d10885d86ded205dbe728935e;hb=f0fb0d1403ccd4789ee599b1cb22e50539e1434e;hp=d10669df0db0f4101138f68cc1b5589e31487273;hpb=da751ca9665bcdeca56d2eec5b629a0953c07662;p=fio.git

diff --git a/engines/cpu.c b/engines/cpu.c
index d10669df..ccbfe003 100644
--- a/engines/cpu.c
+++ b/engines/cpu.c
@@ -6,66 +6,323 @@
  *
  */
 #include "../fio.h"
-#include "../os.h"
+#include "../optgroup.h"
 
-static int fio_cpuio_queue(struct thread_data *td, struct io_u fio_unused *io_u)
+// 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[] = {
+	{
+		.name	= "cpuload",
+		.lname	= "CPU load",
+		.type	= FIO_OPT_INT,
+		.off1	= offsetof(struct cpu_options, cpuload),
+		.help	= "Use this percentage of CPU",
+		.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",
+		.type	= FIO_OPT_INT,
+		.off1	= offsetof(struct cpu_options, cpucycle),
+		.help	= "Length of the CPU burn cycles (usecs)",
+		.def	= "50000",
+		.parent = "cpuload",
+		.hide	= 1,
+		.category = FIO_OPT_C_ENGINE,
+		.group	= FIO_OPT_G_INVALID,
+	},
+	{
+		.name	= "exit_on_io_done",
+		.lname	= "Exit when IO threads are done",
+		.type	= FIO_OPT_BOOL,
+		.off1	= offsetof(struct cpu_options, exit_io_done),
+		.help	= "Exit when IO threads finish",
+		.def	= "0",
+		.category = FIO_OPT_C_ENGINE,
+		.group	= FIO_OPT_G_INVALID,
+	},
+	{
+		.name	= NULL,
+	},
+};
+
+/*
+ *  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)
 {
-	__usec_sleep(td->cpucycle);
+	struct cpu_options *co = td->eo;
+
+	if (co->exit_io_done && !fio_running_or_pending_io_threads()) {
+		td->done = 1;
+		return FIO_Q_BUSY;
+	}
+
+	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 fio_cpuio_setup(struct thread_data fio_unused *td)
+static int noop_init(struct thread_data *td)
 {
-	struct fio_file *f;
-	unsigned int i;
+	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;
+}
 
-	td->total_file_size = -1;
-	td->io_size = td->total_file_size;
-	td->total_io_size = td->io_size;
+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;
 
-	for_each_file(td, f, i) {
-		f->real_file_size = -1;
-		f->file_size = -1;
+	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)
 {
-	if (!td->cpuload) {
+	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");
 		return 1;
 	}
 
-	if (td->cpuload > 100)
-		td->cpuload = 100;
+	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
 	 */
-	td->thinktime_blocks = 1;
-	td->thinktime_spin = 0;
-	td->thinktime = (td->cpucycle * (100 - td->cpuload)) / td->cpuload;
+	o->thinktime_blocks = 1;
+	o->thinktime_spin = 0;
+	o->thinktime = ((unsigned long long) co->cpucycle *
+				(100 - co->cpuload)) / co->cpuload;
 
-	td->nr_files = td->open_files = 1;
+	o->nr_files = o->open_files = 1;
+
+	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 int fio_cpuio_open(struct thread_data fio_unused *td, struct fio_file *f)
+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)
 {
-	f->fd = 0;
 	return 0;
 }
 
 static struct ioengine_ops ioengine = {
-	.name		= "cpuio",
-	.version	= FIO_IOOPS_VERSION,
-	.queue		= fio_cpuio_queue,
-	.init		= fio_cpuio_init,
-	.setup		= fio_cpuio_setup,
-	.open_file	= fio_cpuio_open,
-	.flags		= FIO_SYNCIO | FIO_DISKLESSIO,
+	.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),
 };
 
 static void fio_init fio_cpuio_register(void)