[fio.git] / idletime.c

#include <math.h>
#include "json.h"
#include "idletime.h"

static volatile struct idle_prof_common ipc;

/*
 * Get time to complete an unit work on a particular cpu.
 * The minimum number in CALIBRATE_RUNS runs is returned.
 */
static double calibrate_unit(unsigned char *data)
{
	unsigned long t, i, j, k;
	struct timeval tps;
	double tunit = 0.0;

	for (i = 0; i < CALIBRATE_RUNS; i++) {

		fio_gettime(&tps, NULL);
		/* scale for less variance */
		for (j = 0; j < CALIBRATE_SCALE; j++) {
			/* unit of work */
			for (k=0; k < page_size; k++) {
				data[(k + j) % page_size] = k % 256;
				/*
				 * we won't see STOP here. this is to match
				 * the same statement in the profiling loop.
				 */
				if (ipc.status == IDLE_PROF_STATUS_PROF_STOP)
					return 0.0;
			}
		}

		t = utime_since_now(&tps);
		if (!t)
			continue;

		/* get the minimum time to complete CALIBRATE_SCALE units */
		if ((i == 0) || ((double)t < tunit))
			tunit = (double)t;
	}

	return tunit / CALIBRATE_SCALE;
}

static void *idle_prof_thread_fn(void *data)
{
	int retval;
	unsigned long j, k;
	struct idle_prof_thread *ipt = data;

	/* wait for all threads are spawned */
	pthread_mutex_lock(&ipt->init_lock);

	/* exit if any other thread failed to start */
	if (ipc.status == IDLE_PROF_STATUS_ABORT)
		return NULL;

#if defined(FIO_HAVE_CPU_AFFINITY)
	os_cpu_mask_t cpu_mask;
	memset(&cpu_mask, 0, sizeof(cpu_mask));
	fio_cpu_set(&cpu_mask, ipt->cpu);

	if ((retval=fio_setaffinity(gettid(), cpu_mask)) == -1)
		log_err("fio: fio_setaffinity failed\n");
#else
	retval = -1;
	log_err("fio: fio_setaffinity not supported\n");
#endif
	if (retval == -1) {
		ipt->state = TD_EXITED;
		pthread_mutex_unlock(&ipt->init_lock);
		return NULL;
        }

	ipt->cali_time = calibrate_unit(ipt->data);

	/* delay to set IDLE class till now for better calibration accuracy */
#if defined(CONFIG_SCHED_IDLE)
	if ((retval = fio_set_sched_idle()))
		log_err("fio: fio_set_sched_idle failed\n");
#else
	retval = -1;
	log_err("fio: fio_set_sched_idle not supported\n");
#endif
	if (retval == -1) {
		ipt->state = TD_EXITED;
		pthread_mutex_unlock(&ipt->init_lock);
		return NULL;
	}

	ipt->state = TD_INITIALIZED;

	/* signal the main thread that calibration is done */
	pthread_cond_signal(&ipt->cond);
	pthread_mutex_unlock(&ipt->init_lock);

	/* wait for other calibration to finish */
	pthread_mutex_lock(&ipt->start_lock);

	/* exit if other threads failed to initialize */
	if (ipc.status == IDLE_PROF_STATUS_ABORT)
		return NULL;

	/* exit if we are doing calibration only */
	if (ipc.status == IDLE_PROF_STATUS_CALI_STOP)
		return NULL;

	fio_gettime(&ipt->tps, NULL);
	ipt->state = TD_RUNNING;

	j = 0;
	while (1) {
		for (k = 0; k < page_size; k++) {
			ipt->data[(k + j) % page_size] = k % 256;
			if (ipc.status == IDLE_PROF_STATUS_PROF_STOP) {
				fio_gettime(&ipt->tpe, NULL);
				goto idle_prof_done;
			}
		}
		j++;
	}

idle_prof_done:

	ipt->loops = j + (double) k / page_size;
	ipt->state = TD_EXITED;
	pthread_mutex_unlock(&ipt->start_lock);

	return NULL;
}

/* calculate mean and standard deviation to complete an unit of work */
static void calibration_stats(void)
{
	int i;
	double sum = 0.0, var = 0.0;
	struct idle_prof_thread *ipt;

	for (i = 0; i < ipc.nr_cpus; i++) {
		ipt = &ipc.ipts[i];
		sum += ipt->cali_time;
	}

	ipc.cali_mean = sum/ipc.nr_cpus;

	for (i = 0; i < ipc.nr_cpus; i++) {
		ipt = &ipc.ipts[i];
		var += pow(ipt->cali_time-ipc.cali_mean, 2);
	}

	ipc.cali_stddev = sqrt(var/(ipc.nr_cpus-1));
}

void fio_idle_prof_init(void)
{
	int i, ret;
	struct timeval tp;
	struct timespec ts;
	pthread_attr_t tattr;
	struct idle_prof_thread *ipt;

	ipc.nr_cpus = cpus_online();
	ipc.status = IDLE_PROF_STATUS_OK;

	if (ipc.opt == IDLE_PROF_OPT_NONE)
		return;

	if ((ret = pthread_attr_init(&tattr))) {
		log_err("fio: pthread_attr_init %s\n", strerror(ret));
		return;
	}
	if ((ret = pthread_attr_setscope(&tattr, PTHREAD_SCOPE_SYSTEM))) {
		log_err("fio: pthread_attr_setscope %s\n", strerror(ret));
		return;
	}

	ipc.ipts = malloc(ipc.nr_cpus * sizeof(struct idle_prof_thread));
	if (!ipc.ipts) {
		log_err("fio: malloc failed\n");
		return;
	}

	ipc.buf = malloc(ipc.nr_cpus * page_size);
	if (!ipc.buf) {
		log_err("fio: malloc failed\n");
		free(ipc.ipts);
		return;
	}

	/*
	 * profiling aborts on any single thread failure since the
	 * result won't be accurate if any cpu is not used.
	 */
	for (i = 0; i < ipc.nr_cpus; i++) {
		ipt = &ipc.ipts[i];

		ipt->cpu = i;	
		ipt->state = TD_NOT_CREATED;
		ipt->data = (unsigned char *)(ipc.buf + page_size * i);

		if ((ret = pthread_mutex_init(&ipt->init_lock, NULL))) {
			ipc.status = IDLE_PROF_STATUS_ABORT;
			log_err("fio: pthread_mutex_init %s\n", strerror(ret));
			break;
		}

		if ((ret = pthread_mutex_init(&ipt->start_lock, NULL))) {
			ipc.status = IDLE_PROF_STATUS_ABORT;
			log_err("fio: pthread_mutex_init %s\n", strerror(ret));
			break;
		}

		if ((ret = pthread_cond_init(&ipt->cond, NULL))) {
			ipc.status = IDLE_PROF_STATUS_ABORT;
			log_err("fio: pthread_cond_init %s\n", strerror(ret));
			break;
		}

		/* make sure all threads are spawned before they start */
		pthread_mutex_lock(&ipt->init_lock);

		/* make sure all threads finish init before profiling starts */
		pthread_mutex_lock(&ipt->start_lock);

		if ((ret = pthread_create(&ipt->thread, &tattr, idle_prof_thread_fn, ipt))) {
			ipc.status = IDLE_PROF_STATUS_ABORT;
			log_err("fio: pthread_create %s\n", strerror(ret));
			break;
		} else
			ipt->state = TD_CREATED;

		if ((ret = pthread_detach(ipt->thread))) {
			/* log error and let the thread spin */
			log_err("fio: pthread_detatch %s\n", strerror(ret));
		}
	}

	/*
	 * let good threads continue so that they can exit
	 * if errors on other threads occurred previously.
	 */
	for (i = 0; i < ipc.nr_cpus; i++) {
		ipt = &ipc.ipts[i];
		pthread_mutex_unlock(&ipt->init_lock);
	}
	
	if (ipc.status == IDLE_PROF_STATUS_ABORT)
		return;
	
	/* wait for calibration to finish */
	for (i = 0; i < ipc.nr_cpus; i++) {
		ipt = &ipc.ipts[i];
		pthread_mutex_lock(&ipt->init_lock);
		while ((ipt->state != TD_EXITED) &&
		       (ipt->state!=TD_INITIALIZED)) {
			fio_gettime(&tp, NULL);
			ts.tv_sec = tp.tv_sec + 1;
			ts.tv_nsec = tp.tv_usec * 1000;
			pthread_cond_timedwait(&ipt->cond, &ipt->init_lock, &ts);
		}
		pthread_mutex_unlock(&ipt->init_lock);
	
		/*
		 * any thread failed to initialize would abort other threads
		 * later after fio_idle_prof_start. 
		 */	
		if (ipt->state == TD_EXITED)
			ipc.status = IDLE_PROF_STATUS_ABORT;
	}

	if (ipc.status != IDLE_PROF_STATUS_ABORT)
		calibration_stats();
	else
		ipc.cali_mean = ipc.cali_stddev = 0.0;

	if (ipc.opt == IDLE_PROF_OPT_CALI)
		ipc.status = IDLE_PROF_STATUS_CALI_STOP;
}

void fio_idle_prof_start(void)
{
	int i;
	struct idle_prof_thread *ipt;

	if (ipc.opt == IDLE_PROF_OPT_NONE)
		return;

	/* unlock regardless abort is set or not */
	for (i = 0; i < ipc.nr_cpus; i++) {
		ipt = &ipc.ipts[i];
		pthread_mutex_unlock(&ipt->start_lock);
	}
}

void fio_idle_prof_stop(void)
{
	int i;
	uint64_t runt;
	struct timeval tp;
	struct timespec ts;
	struct idle_prof_thread *ipt;

	if (ipc.opt == IDLE_PROF_OPT_NONE)
		return;

	if (ipc.opt == IDLE_PROF_OPT_CALI)
		return;

	ipc.status = IDLE_PROF_STATUS_PROF_STOP;

	/* wait for all threads to exit from profiling */
	for (i = 0; i < ipc.nr_cpus; i++) {
		ipt = &ipc.ipts[i];
		pthread_mutex_lock(&ipt->start_lock);
		while ((ipt->state != TD_EXITED) &&
		       (ipt->state!=TD_NOT_CREATED)) {
			fio_gettime(&tp, NULL);
			ts.tv_sec = tp.tv_sec + 1;
			ts.tv_nsec = tp.tv_usec * 1000;
			/* timed wait in case a signal is not received */
			pthread_cond_timedwait(&ipt->cond, &ipt->start_lock, &ts);
		}
		pthread_mutex_unlock(&ipt->start_lock);

		/* calculate idleness */
		if (ipc.cali_mean != 0.0) {
			runt = utime_since(&ipt->tps, &ipt->tpe);
			ipt->idleness = ipt->loops * ipc.cali_mean / runt;
		} else
			ipt->idleness = 0.0;
	}

	/*
	 * memory allocations are freed via explicit fio_idle_prof_cleanup
	 * after profiling stats are collected by apps.  
	 */
}

/*
 * return system idle percentage when cpu is -1;
 * return one cpu idle percentage otherwise.
 */
static double fio_idle_prof_cpu_stat(int cpu)
{
	int i, nr_cpus = ipc.nr_cpus;
	struct idle_prof_thread *ipt;
	double p = 0.0;

	if (ipc.opt == IDLE_PROF_OPT_NONE)
		return 0.0;

	if ((cpu >= nr_cpus) || (cpu < -1)) {
		log_err("fio: idle profiling invalid cpu index\n");
		return 0.0;
	}

	if (cpu == -1) {
		for (i = 0; i < nr_cpus; i++) {
			ipt = &ipc.ipts[i];
			p += ipt->idleness;
		}
		p /= nr_cpus;
	} else {
		ipt = &ipc.ipts[cpu];
		p = ipt->idleness;
	}

	return p * 100.0;
}

void fio_idle_prof_cleanup(void)
{
	if (ipc.ipts) {
		free(ipc.ipts);
		ipc.ipts = NULL;
	}

	if (ipc.buf) {
		free(ipc.buf);
		ipc.buf = NULL;
	}
}

int fio_idle_prof_parse_opt(const char *args)
{
	ipc.opt = IDLE_PROF_OPT_NONE; /* default */

	if (!args) {
		log_err("fio: empty idle-prof option string\n");
		return -1;
	}	

#if defined(FIO_HAVE_CPU_AFFINITY) && defined(CONFIG_SCHED_IDLE)
	if (strcmp("calibrate", args) == 0) {
		ipc.opt = IDLE_PROF_OPT_CALI;
		fio_idle_prof_init();
		fio_idle_prof_start();
		fio_idle_prof_stop();
		show_idle_prof_stats(FIO_OUTPUT_NORMAL, NULL);
		return 1;
	} else if (strcmp("system", args) == 0) {
		ipc.opt = IDLE_PROF_OPT_SYSTEM;
		return 0;
	} else if (strcmp("percpu", args) == 0) {
		ipc.opt = IDLE_PROF_OPT_PERCPU;
		return 0;
	} else {
		log_err("fio: incorrect idle-prof option\n", args);
		return -1;
	}	
#else
	log_err("fio: idle-prof not supported on this platform\n");
	return -1;
#endif
}

void show_idle_prof_stats(int output, struct json_object *parent)
{
	int i, nr_cpus = ipc.nr_cpus;
	struct json_object *tmp;
	char s[MAX_CPU_STR_LEN];

	if (output == FIO_OUTPUT_NORMAL) {
		if (ipc.opt > IDLE_PROF_OPT_CALI)
			log_info("\nCPU idleness:\n");
		else if (ipc.opt == IDLE_PROF_OPT_CALI)
			log_info("CPU idleness:\n");

		if (ipc.opt >= IDLE_PROF_OPT_SYSTEM)
			log_info("  system: %3.2f%%\n", fio_idle_prof_cpu_stat(-1));

		if (ipc.opt == IDLE_PROF_OPT_PERCPU) {
			log_info("  percpu: %3.2f%%", fio_idle_prof_cpu_stat(0));
			for (i = 1; i < nr_cpus; i++)
				log_info(", %3.2f%%", fio_idle_prof_cpu_stat(i));
			log_info("\n");
		}

		if (ipc.opt >= IDLE_PROF_OPT_CALI) {
			log_info("  unit work: mean=%3.2fus,", ipc.cali_mean);
			log_info(" stddev=%3.2f\n", ipc.cali_stddev);
		}

		/* dynamic mem allocations can now be freed */
		if (ipc.opt != IDLE_PROF_OPT_NONE)
			fio_idle_prof_cleanup();

		return;
	}

	if ((ipc.opt != IDLE_PROF_OPT_NONE) && (output == FIO_OUTPUT_JSON)) {
		if (!parent)
			return;

		tmp = json_create_object();
		if (!tmp)
			return;

		json_object_add_value_object(parent, "cpu_idleness", tmp);
		json_object_add_value_float(tmp, "system", fio_idle_prof_cpu_stat(-1));

		if (ipc.opt == IDLE_PROF_OPT_PERCPU) {
			for (i = 0; i < nr_cpus; i++) {
				snprintf(s, MAX_CPU_STR_LEN, "cpu-%d", i);
				json_object_add_value_float(tmp, s, fio_idle_prof_cpu_stat(i));
			}
		}

		json_object_add_value_float(tmp, "unit_mean", ipc.cali_mean);
		json_object_add_value_float(tmp, "unit_stddev", ipc.cali_stddev);
		
		fio_idle_prof_cleanup();
	}
}
Commit	Line	Data
f2a2ce0e HL	1	#include <math.h>
	2	#include "json.h"
	3	#include "idletime.h"
	4
	5	static volatile struct idle_prof_common ipc;
	6
680b5abc JA	7	/*
680b5abc JA	8	* Get time to complete an unit work on a particular cpu.
f2a2ce0e HL	9	* The minimum number in CALIBRATE_RUNS runs is returned.
	10	*/
	11	static double calibrate_unit(unsigned char *data)
	12	{
	13	unsigned long t, i, j, k;
	14	struct timeval tps;
	15	double tunit = 0.0;
	16
680b5abc	17	for (i = 0; i < CALIBRATE_RUNS; i++) {
f2a2ce0e HL	18
	19	fio_gettime(&tps, NULL);
	20	/* scale for less variance */
680b5abc	21	for (j = 0; j < CALIBRATE_SCALE; j++) {
f2a2ce0e HL	22	/* unit of work */
f2a2ce0e HL	23	for (k=0; k < page_size; k++) {
680b5abc JA	24	data[(k + j) % page_size] = k % 256;
	25	/*
	26	* we won't see STOP here. this is to match
f2a2ce0e HL	27	* the same statement in the profiling loop.
	28	*/
	29	if (ipc.status == IDLE_PROF_STATUS_PROF_STOP)
	30	return 0.0;
	31	}
	32	}
	33
	34	t = utime_since_now(&tps);
	35	if (!t)
	36	continue;
	37
	38	/* get the minimum time to complete CALIBRATE_SCALE units */
680b5abc	39	if ((i == 0) \|\| ((double)t < tunit))
f2a2ce0e HL	40	tunit = (double)t;
	41	}
	42
680b5abc	43	return tunit / CALIBRATE_SCALE;
f2a2ce0e HL	44	}
	45
	46	static void idle_prof_thread_fn(void data)
	47	{
	48	int retval;
	49	unsigned long j, k;
	50	struct idle_prof_thread *ipt = data;
	51
	52	/* wait for all threads are spawned */
	53	pthread_mutex_lock(&ipt->init_lock);
	54
	55	/* exit if any other thread failed to start */
	56	if (ipc.status == IDLE_PROF_STATUS_ABORT)
	57	return NULL;
	58
	59	#if defined(FIO_HAVE_CPU_AFFINITY)
	60	os_cpu_mask_t cpu_mask;
	61	memset(&cpu_mask, 0, sizeof(cpu_mask));
	62	fio_cpu_set(&cpu_mask, ipt->cpu);
	63
	64	if ((retval=fio_setaffinity(gettid(), cpu_mask)) == -1)
	65	log_err("fio: fio_setaffinity failed\n");
	66	#else
	67	retval = -1;
	68	log_err("fio: fio_setaffinity not supported\n");
	69	#endif
	70	if (retval == -1) {
	71	ipt->state = TD_EXITED;
	72	pthread_mutex_unlock(&ipt->init_lock);
	73	return NULL;
	74	}
	75
	76	ipt->cali_time = calibrate_unit(ipt->data);
	77
	78	/* delay to set IDLE class till now for better calibration accuracy */
7e09a9f1	79	#if defined(CONFIG_SCHED_IDLE)
f2a2ce0e HL	80	if ((retval = fio_set_sched_idle()))
	81	log_err("fio: fio_set_sched_idle failed\n");
	82	#else
	83	retval = -1;
	84	log_err("fio: fio_set_sched_idle not supported\n");
	85	#endif
	86	if (retval == -1) {
	87	ipt->state = TD_EXITED;
	88	pthread_mutex_unlock(&ipt->init_lock);
	89	return NULL;
	90	}
	91
	92	ipt->state = TD_INITIALIZED;
	93
	94	/* signal the main thread that calibration is done */
	95	pthread_cond_signal(&ipt->cond);
	96	pthread_mutex_unlock(&ipt->init_lock);
	97
	98	/* wait for other calibration to finish */
	99	pthread_mutex_lock(&ipt->start_lock);
	100
	101	/* exit if other threads failed to initialize */
	102	if (ipc.status == IDLE_PROF_STATUS_ABORT)
	103	return NULL;
	104
	105	/* exit if we are doing calibration only */
	106	if (ipc.status == IDLE_PROF_STATUS_CALI_STOP)
	107	return NULL;
	108
	109	fio_gettime(&ipt->tps, NULL);
	110	ipt->state = TD_RUNNING;
	111
	112	j = 0;
	113	while (1) {
680b5abc JA	114	for (k = 0; k < page_size; k++) {
680b5abc JA	115	ipt->data[(k + j) % page_size] = k % 256;
f2a2ce0e HL	116	if (ipc.status == IDLE_PROF_STATUS_PROF_STOP) {
	117	fio_gettime(&ipt->tpe, NULL);
	118	goto idle_prof_done;
	119	}
	120	}
	121	j++;
	122	}
	123
	124	idle_prof_done:
	125
680b5abc	126	ipt->loops = j + (double) k / page_size;
f2a2ce0e HL	127	ipt->state = TD_EXITED;
	128	pthread_mutex_unlock(&ipt->start_lock);
	129
	130	return NULL;
	131	}
	132
	133	/* calculate mean and standard deviation to complete an unit of work */
	134	static void calibration_stats(void)
	135	{
	136	int i;
680b5abc	137	double sum = 0.0, var = 0.0;
f2a2ce0e HL	138	struct idle_prof_thread *ipt;
	139
	140	for (i = 0; i < ipc.nr_cpus; i++) {
	141	ipt = &ipc.ipts[i];
	142	sum += ipt->cali_time;
	143	}
	144
	145	ipc.cali_mean = sum/ipc.nr_cpus;
	146
	147	for (i = 0; i < ipc.nr_cpus; i++) {
	148	ipt = &ipc.ipts[i];
	149	var += pow(ipt->cali_time-ipc.cali_mean, 2);
	150	}
	151
	152	ipc.cali_stddev = sqrt(var/(ipc.nr_cpus-1));
	153	}
	154
	155	void fio_idle_prof_init(void)
	156	{
	157	int i, ret;
	158	struct timeval tp;
	159	struct timespec ts;
680b5abc	160	pthread_attr_t tattr;
f2a2ce0e HL	161	struct idle_prof_thread *ipt;
	162
	163	ipc.nr_cpus = cpus_online();
	164	ipc.status = IDLE_PROF_STATUS_OK;
	165
	166	if (ipc.opt == IDLE_PROF_OPT_NONE)
	167	return;
	168
	169	if ((ret = pthread_attr_init(&tattr))) {
	170	log_err("fio: pthread_attr_init %s\n", strerror(ret));
	171	return;
	172	}
	173	if ((ret = pthread_attr_setscope(&tattr, PTHREAD_SCOPE_SYSTEM))) {
	174	log_err("fio: pthread_attr_setscope %s\n", strerror(ret));
	175	return;
	176	}
	177
	178	ipc.ipts = malloc(ipc.nr_cpus * sizeof(struct idle_prof_thread));
	179	if (!ipc.ipts) {
	180	log_err("fio: malloc failed\n");
	181	return;
	182	}
	183
	184	ipc.buf = malloc(ipc.nr_cpus * page_size);
	185	if (!ipc.buf) {
	186	log_err("fio: malloc failed\n");
	187	free(ipc.ipts);
	188	return;
	189	}
	190
680b5abc JA	191	/*
680b5abc JA	192	* profiling aborts on any single thread failure since the
f2a2ce0e HL	193	* result won't be accurate if any cpu is not used.
	194	*/
	195	for (i = 0; i < ipc.nr_cpus; i++) {
	196	ipt = &ipc.ipts[i];
	197
	198	ipt->cpu = i;
	199	ipt->state = TD_NOT_CREATED;
	200	ipt->data = (unsigned char )(ipc.buf + page_size i);
	201
	202	if ((ret = pthread_mutex_init(&ipt->init_lock, NULL))) {
	203	ipc.status = IDLE_PROF_STATUS_ABORT;
	204	log_err("fio: pthread_mutex_init %s\n", strerror(ret));
	205	break;
	206	}
	207
	208	if ((ret = pthread_mutex_init(&ipt->start_lock, NULL))) {
	209	ipc.status = IDLE_PROF_STATUS_ABORT;
	210	log_err("fio: pthread_mutex_init %s\n", strerror(ret));
	211	break;
	212	}
	213
	214	if ((ret = pthread_cond_init(&ipt->cond, NULL))) {
	215	ipc.status = IDLE_PROF_STATUS_ABORT;
	216	log_err("fio: pthread_cond_init %s\n", strerror(ret));
	217	break;
	218	}
	219
	220	/* make sure all threads are spawned before they start */
	221	pthread_mutex_lock(&ipt->init_lock);
	222
	223	/* make sure all threads finish init before profiling starts */
	224	pthread_mutex_lock(&ipt->start_lock);
	225
	226	if ((ret = pthread_create(&ipt->thread, &tattr, idle_prof_thread_fn, ipt))) {
	227	ipc.status = IDLE_PROF_STATUS_ABORT;
	228	log_err("fio: pthread_create %s\n", strerror(ret));
	229	break;
680b5abc	230	} else
f2a2ce0e	231	ipt->state = TD_CREATED;
f2a2ce0e HL	232
	233	if ((ret = pthread_detach(ipt->thread))) {
	234	/* log error and let the thread spin */
	235	log_err("fio: pthread_detatch %s\n", strerror(ret));
	236	}
	237	}
	238
680b5abc JA	239	/*
	240	* let good threads continue so that they can exit
	241	* if errors on other threads occurred previously.
f2a2ce0e HL	242	*/
	243	for (i = 0; i < ipc.nr_cpus; i++) {
	244	ipt = &ipc.ipts[i];
	245	pthread_mutex_unlock(&ipt->init_lock);
	246	}
	247
	248	if (ipc.status == IDLE_PROF_STATUS_ABORT)
	249	return;
	250
	251	/* wait for calibration to finish */
	252	for (i = 0; i < ipc.nr_cpus; i++) {
	253	ipt = &ipc.ipts[i];
	254	pthread_mutex_lock(&ipt->init_lock);
680b5abc JA	255	while ((ipt->state != TD_EXITED) &&
680b5abc JA	256	(ipt->state!=TD_INITIALIZED)) {
f2a2ce0e HL	257	fio_gettime(&tp, NULL);
	258	ts.tv_sec = tp.tv_sec + 1;
	259	ts.tv_nsec = tp.tv_usec * 1000;
	260	pthread_cond_timedwait(&ipt->cond, &ipt->init_lock, &ts);
	261	}
	262	pthread_mutex_unlock(&ipt->init_lock);
	263
680b5abc JA	264	/*
680b5abc JA	265	* any thread failed to initialize would abort other threads
f2a2ce0e HL	266	* later after fio_idle_prof_start.
	267	*/
	268	if (ipt->state == TD_EXITED)
	269	ipc.status = IDLE_PROF_STATUS_ABORT;
	270	}
	271
	272	if (ipc.status != IDLE_PROF_STATUS_ABORT)
	273	calibration_stats();
680b5abc	274	else
f2a2ce0e HL	275	ipc.cali_mean = ipc.cali_stddev = 0.0;
	276
	277	if (ipc.opt == IDLE_PROF_OPT_CALI)
	278	ipc.status = IDLE_PROF_STATUS_CALI_STOP;
	279	}
	280
	281	void fio_idle_prof_start(void)
	282	{
	283	int i;
	284	struct idle_prof_thread *ipt;
	285
	286	if (ipc.opt == IDLE_PROF_OPT_NONE)
	287	return;
	288
	289	/* unlock regardless abort is set or not */
	290	for (i = 0; i < ipc.nr_cpus; i++) {
	291	ipt = &ipc.ipts[i];
	292	pthread_mutex_unlock(&ipt->start_lock);
	293	}
	294	}
	295
	296	void fio_idle_prof_stop(void)
	297	{
	298	int i;
	299	uint64_t runt;
	300	struct timeval tp;
	301	struct timespec ts;
	302	struct idle_prof_thread *ipt;
	303
	304	if (ipc.opt == IDLE_PROF_OPT_NONE)
	305	return;
	306
	307	if (ipc.opt == IDLE_PROF_OPT_CALI)
	308	return;
	309
	310	ipc.status = IDLE_PROF_STATUS_PROF_STOP;
	311
	312	/* wait for all threads to exit from profiling */
	313	for (i = 0; i < ipc.nr_cpus; i++) {
	314	ipt = &ipc.ipts[i];
	315	pthread_mutex_lock(&ipt->start_lock);
680b5abc JA	316	while ((ipt->state != TD_EXITED) &&
680b5abc JA	317	(ipt->state!=TD_NOT_CREATED)) {
f2a2ce0e HL	318	fio_gettime(&tp, NULL);
	319	ts.tv_sec = tp.tv_sec + 1;
	320	ts.tv_nsec = tp.tv_usec * 1000;
	321	/* timed wait in case a signal is not received */
	322	pthread_cond_timedwait(&ipt->cond, &ipt->start_lock, &ts);
	323	}
	324	pthread_mutex_unlock(&ipt->start_lock);
	325
	326	/* calculate idleness */
	327	if (ipc.cali_mean != 0.0) {
	328	runt = utime_since(&ipt->tps, &ipt->tpe);
	329	ipt->idleness = ipt->loops * ipc.cali_mean / runt;
680b5abc	330	} else
f2a2ce0e HL	331	ipt->idleness = 0.0;
	332	}
	333
680b5abc JA	334	/*
680b5abc JA	335	* memory allocations are freed via explicit fio_idle_prof_cleanup
f2a2ce0e HL	336	* after profiling stats are collected by apps.
f2a2ce0e HL	337	*/
f2a2ce0e HL	338	}
f2a2ce0e HL	339
680b5abc JA	340	/*
680b5abc JA	341	* return system idle percentage when cpu is -1;
f2a2ce0e HL	342	* return one cpu idle percentage otherwise.
	343	*/
	344	static double fio_idle_prof_cpu_stat(int cpu)
	345	{
	346	int i, nr_cpus = ipc.nr_cpus;
	347	struct idle_prof_thread *ipt;
	348	double p = 0.0;
	349
	350	if (ipc.opt == IDLE_PROF_OPT_NONE)
	351	return 0.0;
	352
	353	if ((cpu >= nr_cpus) \|\| (cpu < -1)) {
	354	log_err("fio: idle profiling invalid cpu index\n");
	355	return 0.0;
	356	}
	357
	358	if (cpu == -1) {
	359	for (i = 0; i < nr_cpus; i++) {
	360	ipt = &ipc.ipts[i];
	361	p += ipt->idleness;
	362	}
	363	p /= nr_cpus;
	364	} else {
	365	ipt = &ipc.ipts[cpu];
	366	p = ipt->idleness;
	367	}
	368
680b5abc	369	return p * 100.0;
f2a2ce0e HL	370	}
	371
	372	void fio_idle_prof_cleanup(void)
	373	{
	374	if (ipc.ipts) {
	375	free(ipc.ipts);
	376	ipc.ipts = NULL;
	377	}
	378
	379	if (ipc.buf) {
	380	free(ipc.buf);
	381	ipc.buf = NULL;
	382	}
	383	}
	384
	385	int fio_idle_prof_parse_opt(const char *args)
	386	{
	387	ipc.opt = IDLE_PROF_OPT_NONE; /* default */
	388
	389	if (!args) {
	390	log_err("fio: empty idle-prof option string\n");
	391	return -1;
	392	}
	393
7e09a9f1	394	#if defined(FIO_HAVE_CPU_AFFINITY) && defined(CONFIG_SCHED_IDLE)
f2a2ce0e HL	395	if (strcmp("calibrate", args) == 0) {
	396	ipc.opt = IDLE_PROF_OPT_CALI;
	397	fio_idle_prof_init();
	398	fio_idle_prof_start();
	399	fio_idle_prof_stop();
	400	show_idle_prof_stats(FIO_OUTPUT_NORMAL, NULL);
	401	return 1;
	402	} else if (strcmp("system", args) == 0) {
	403	ipc.opt = IDLE_PROF_OPT_SYSTEM;
	404	return 0;
	405	} else if (strcmp("percpu", args) == 0) {
	406	ipc.opt = IDLE_PROF_OPT_PERCPU;
	407	return 0;
	408	} else {
	409	log_err("fio: incorrect idle-prof option\n", args);
	410	return -1;
	411	}
	412	#else
	413	log_err("fio: idle-prof not supported on this platform\n");
	414	return -1;
	415	#endif
	416	}
	417
	418	void show_idle_prof_stats(int output, struct json_object *parent)
	419	{
	420	int i, nr_cpus = ipc.nr_cpus;
	421	struct json_object *tmp;
	422	char s[MAX_CPU_STR_LEN];
680b5abc	423
f2a2ce0e HL	424	if (output == FIO_OUTPUT_NORMAL) {
	425	if (ipc.opt > IDLE_PROF_OPT_CALI)
	426	log_info("\nCPU idleness:\n");
	427	else if (ipc.opt == IDLE_PROF_OPT_CALI)
	428	log_info("CPU idleness:\n");
	429
	430	if (ipc.opt >= IDLE_PROF_OPT_SYSTEM)
	431	log_info(" system: %3.2f%%\n", fio_idle_prof_cpu_stat(-1));
	432
	433	if (ipc.opt == IDLE_PROF_OPT_PERCPU) {
	434	log_info(" percpu: %3.2f%%", fio_idle_prof_cpu_stat(0));
680b5abc	435	for (i = 1; i < nr_cpus; i++)
f2a2ce0e	436	log_info(", %3.2f%%", fio_idle_prof_cpu_stat(i));
f2a2ce0e HL	437	log_info("\n");
	438	}
	439
	440	if (ipc.opt >= IDLE_PROF_OPT_CALI) {
	441	log_info(" unit work: mean=%3.2fus,", ipc.cali_mean);
	442	log_info(" stddev=%3.2f\n", ipc.cali_stddev);
	443	}
	444
	445	/* dynamic mem allocations can now be freed */
	446	if (ipc.opt != IDLE_PROF_OPT_NONE)
	447	fio_idle_prof_cleanup();
	448
	449	return;
	450	}
680b5abc	451
f2a2ce0e HL	452	if ((ipc.opt != IDLE_PROF_OPT_NONE) && (output == FIO_OUTPUT_JSON)) {
	453	if (!parent)
	454	return;
	455
	456	tmp = json_create_object();
	457	if (!tmp)
	458	return;
	459
	460	json_object_add_value_object(parent, "cpu_idleness", tmp);
	461	json_object_add_value_float(tmp, "system", fio_idle_prof_cpu_stat(-1));
	462
	463	if (ipc.opt == IDLE_PROF_OPT_PERCPU) {
680b5abc	464	for (i = 0; i < nr_cpus; i++) {
f2a2ce0e HL	465	snprintf(s, MAX_CPU_STR_LEN, "cpu-%d", i);
	466	json_object_add_value_float(tmp, s, fio_idle_prof_cpu_stat(i));
	467	}
	468	}
	469
	470	json_object_add_value_float(tmp, "unit_mean", ipc.cali_mean);
	471	json_object_add_value_float(tmp, "unit_stddev", ipc.cali_stddev);
	472
	473	fio_idle_prof_cleanup();
f2a2ce0e HL	474	}
f2a2ce0e HL	475	}