X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=idletime.c;h=a366d2b16311bf6ec1b8e8d50fb84c44edc71eda;hp=fb6f9ddcb13350815ead74fc895901151be534c0;hb=99b9a85a2962b4792f92d167fc66744a9ebb1128;hpb=7e09a9f10bb301635b6f9206b3144878a2710b0a

diff --git a/idletime.c b/idletime.c
index fb6f9ddc..a366d2b1 100644
--- a/idletime.c
+++ b/idletime.c
@@ -4,7 +4,8 @@
 
 static volatile struct idle_prof_common ipc;
 
-/* Get time to complete an unit work on a particular cpu.
+/*
+ * 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)
@@ -13,15 +14,16 @@ static double calibrate_unit(unsigned char *data)
 	struct timeval tps;
 	double tunit = 0.0;
 
-	for (i=0; i<CALIBRATE_RUNS; i++) {
+	for (i = 0; i < CALIBRATE_RUNS; i++) {
 
 		fio_gettime(&tps, NULL);
 		/* scale for less variance */
-		for (j=0; j < CALIBRATE_SCALE; j++) {
+		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
+				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)
@@ -34,11 +36,31 @@ static double calibrate_unit(unsigned char *data)
 			continue;
 
 		/* get the minimum time to complete CALIBRATE_SCALE units */
-		if ((i==0) || ((double)t < tunit))
+		if ((i == 0) || ((double)t < tunit))
 			tunit = (double)t;
 	}
 
-	return tunit/CALIBRATE_SCALE;
+	return tunit / CALIBRATE_SCALE;
+}
+
+static int set_cpu_affinity(struct idle_prof_thread *ipt)
+{
+#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 (fio_setaffinity(gettid(), cpu_mask)) {
+		log_err("fio: fio_setaffinity failed\n");
+		return -1;
+	}
+
+	return 0;
+#else
+	log_err("fio: fio_setaffinity not supported\n");
+	return -1;
+#endif
 }
 
 static void *idle_prof_thread_fn(void *data)
@@ -51,20 +73,12 @@ static void *idle_prof_thread_fn(void *data)
 	pthread_mutex_lock(&ipt->init_lock);
 
 	/* exit if any other thread failed to start */
-	if (ipc.status == IDLE_PROF_STATUS_ABORT)
+	if (ipc.status == IDLE_PROF_STATUS_ABORT) {
+		pthread_mutex_unlock(&ipt->init_lock);
 		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
+	retval = set_cpu_affinity(ipt);
 	if (retval == -1) {
 		ipt->state = TD_EXITED;
 		pthread_mutex_unlock(&ipt->init_lock);
@@ -97,20 +111,24 @@ static void *idle_prof_thread_fn(void *data)
 	pthread_mutex_lock(&ipt->start_lock);
 
 	/* exit if other threads failed to initialize */
-	if (ipc.status == IDLE_PROF_STATUS_ABORT)
+	if (ipc.status == IDLE_PROF_STATUS_ABORT) {
+		pthread_mutex_unlock(&ipt->start_lock);
 		return NULL;
+	}
 
 	/* exit if we are doing calibration only */
-	if (ipc.status == IDLE_PROF_STATUS_CALI_STOP)
+	if (ipc.status == IDLE_PROF_STATUS_CALI_STOP) {
+		pthread_mutex_unlock(&ipt->start_lock);
 		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;
+		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;
@@ -121,7 +139,7 @@ static void *idle_prof_thread_fn(void *data)
 
 idle_prof_done:
 
-	ipt->loops = j + (double)k/page_size;
+	ipt->loops = j + (double) k / page_size;
 	ipt->state = TD_EXITED;
 	pthread_mutex_unlock(&ipt->start_lock);
 
@@ -132,7 +150,7 @@ idle_prof_done:
 static void calibration_stats(void)
 {
 	int i;
-	double sum=0.0, var=0.0;
+	double sum = 0.0, var = 0.0;
 	struct idle_prof_thread *ipt;
 
 	for (i = 0; i < ipc.nr_cpus; i++) {
@@ -155,7 +173,7 @@ void fio_idle_prof_init(void)
 	int i, ret;
 	struct timeval tp;
 	struct timespec ts;
-        pthread_attr_t tattr;
+	pthread_attr_t tattr;
 	struct idle_prof_thread *ipt;
 
 	ipc.nr_cpus = cpus_online();
@@ -186,7 +204,8 @@ void fio_idle_prof_init(void)
 		return;
 	}
 
-	/* profiling aborts on any single thread failure since the
+	/*
+	 * 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++) {
@@ -224,9 +243,8 @@ void fio_idle_prof_init(void)
 			ipc.status = IDLE_PROF_STATUS_ABORT;
 			log_err("fio: pthread_create %s\n", strerror(ret));
 			break;
-		} else {
+		} else
 			ipt->state = TD_CREATED;
-		}
 
 		if ((ret = pthread_detach(ipt->thread))) {
 			/* log error and let the thread spin */
@@ -234,8 +252,9 @@ void fio_idle_prof_init(void)
 		}
 	}
 
-	/* let good threads continue so that they can exit
-	 * if errors on other threads occurred previously. 
+	/*
+	 * 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];
@@ -249,7 +268,8 @@ void fio_idle_prof_init(void)
 	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)) {
+		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;
@@ -257,7 +277,8 @@ void fio_idle_prof_init(void)
 		}
 		pthread_mutex_unlock(&ipt->init_lock);
 	
-		/* any thread failed to initialize would abort other threads
+		/*
+		 * any thread failed to initialize would abort other threads
 		 * later after fio_idle_prof_start. 
 		 */	
 		if (ipt->state == TD_EXITED)
@@ -266,7 +287,7 @@ void fio_idle_prof_init(void)
 
 	if (ipc.status != IDLE_PROF_STATUS_ABORT)
 		calibration_stats();
-	else 
+	else
 		ipc.cali_mean = ipc.cali_stddev = 0.0;
 
 	if (ipc.opt == IDLE_PROF_OPT_CALI)
@@ -308,7 +329,8 @@ void fio_idle_prof_stop(void)
 	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)) {
+		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;
@@ -320,19 +342,22 @@ void fio_idle_prof_stop(void)
 		/* calculate idleness */
 		if (ipc.cali_mean != 0.0) {
 			runt = utime_since(&ipt->tps, &ipt->tpe);
-			ipt->idleness = ipt->loops * ipc.cali_mean / runt;
-		} else 
+			if (runt)
+				ipt->idleness = ipt->loops * ipc.cali_mean / runt;
+			else
+				ipt->idleness = 0.0;
+		} else
 			ipt->idleness = 0.0;
 	}
 
-	/* memory allocations are freed via explicit fio_idle_prof_cleanup
+	/*
+	 * memory allocations are freed via explicit fio_idle_prof_cleanup
 	 * after profiling stats are collected by apps.  
 	 */
-
-	return;
 }
 
-/* return system idle percentage when cpu is -1;
+/*
+ * return system idle percentage when cpu is -1;
  * return one cpu idle percentage otherwise.
  */
 static double fio_idle_prof_cpu_stat(int cpu)
@@ -360,10 +385,10 @@ static double fio_idle_prof_cpu_stat(int cpu)
 		p = ipt->idleness;
 	}
 
-	return p*100.0;
+	return p * 100.0;
 }
 
-void fio_idle_prof_cleanup(void)
+static void fio_idle_prof_cleanup(void)
 {
 	if (ipc.ipts) {
 		free(ipc.ipts);
@@ -400,7 +425,7 @@ int fio_idle_prof_parse_opt(const char *args)
 		ipc.opt = IDLE_PROF_OPT_PERCPU;
 		return 0;
 	} else {
-		log_err("fio: incorrect idle-prof option\n", args);
+		log_err("fio: incorrect idle-prof option: %s\n", args);
 		return -1;
 	}	
 #else
@@ -414,7 +439,7 @@ 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");
@@ -426,9 +451,8 @@ void show_idle_prof_stats(int output, struct json_object *parent)
 
 		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++) {
+			for (i = 1; i < nr_cpus; i++)
 				log_info(", %3.2f%%", fio_idle_prof_cpu_stat(i));
-			}
 			log_info("\n");
 		}
 
@@ -443,7 +467,7 @@ void show_idle_prof_stats(int output, struct json_object *parent)
 
 		return;
 	}
- 
+
 	if ((ipc.opt != IDLE_PROF_OPT_NONE) && (output == FIO_OUTPUT_JSON)) {
 		if (!parent)
 			return;
@@ -456,7 +480,7 @@ void show_idle_prof_stats(int output, struct json_object *parent)
 		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++) {
+			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));
 			}
@@ -466,7 +490,5 @@ void show_idle_prof_stats(int output, struct json_object *parent)
 		json_object_add_value_float(tmp, "unit_stddev", ipc.cali_stddev);
 		
 		fio_idle_prof_cleanup();
-
-		return;
 	}
 }