idletime: style cleanups
authorJens Axboe <axboe@kernel.dk>
Wed, 30 Jan 2013 13:08:00 +0000 (14:08 +0100)
committerJens Axboe <axboe@kernel.dk>
Wed, 30 Jan 2013 13:08:00 +0000 (14:08 +0100)
Signed-off-by: Jens Axboe <axboe@kernel.dk>
idletime.c

index fb6f9dd..244723f 100644 (file)
@@ -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,11 @@ 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 void *idle_prof_thread_fn(void *data)
@@ -109,8 +111,8 @@ static void *idle_prof_thread_fn(void *data)
 
        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 +123,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 +134,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 +157,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 +188,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 +227,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 +236,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 +252,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 +261,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 +271,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 +313,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;
@@ -321,18 +327,18 @@ void fio_idle_prof_stop(void)
                if (ipc.cali_mean != 0.0) {
                        runt = utime_since(&ipt->tps, &ipt->tpe);
                        ipt->idleness = ipt->loops * ipc.cali_mean / runt;
-               } else 
+               } 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,7 +366,7 @@ 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)
@@ -414,7 +420,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 +432,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 +448,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 +461,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 +471,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;
        }
 }