#include <math.h>
+#include "fio.h"
#include "json.h"
#include "idletime.h"
static double calibrate_unit(unsigned char *data)
{
unsigned long t, i, j, k;
- struct timeval tps;
+ struct timespec tps;
double tunit = 0.0;
for (i = 0; i < CALIBRATE_RUNS; i++) {
return tunit / CALIBRATE_SCALE;
}
+static void free_cpu_affinity(struct idle_prof_thread *ipt)
+{
+#if defined(FIO_HAVE_CPU_AFFINITY)
+ fio_cpuset_exit(&ipt->cpu_mask);
+#endif
+}
+
static int set_cpu_affinity(struct idle_prof_thread *ipt)
{
#if defined(FIO_HAVE_CPU_AFFINITY)
- os_cpu_mask_t cpu_mask;
+ if (fio_cpuset_init(&ipt->cpu_mask)) {
+ log_err("fio: cpuset init failed\n");
+ return -1;
+ }
- memset(&cpu_mask, 0, sizeof(cpu_mask));
- fio_cpu_set(&cpu_mask, ipt->cpu);
+ fio_cpu_set(&ipt->cpu_mask, ipt->cpu);
- if (fio_setaffinity(gettid(), cpu_mask)) {
+ if (fio_setaffinity(gettid(), ipt->cpu_mask)) {
log_err("fio: fio_setaffinity failed\n");
+ fio_cpuset_exit(&ipt->cpu_mask);
return -1;
}
if (retval == -1) {
ipt->state = TD_EXITED;
pthread_mutex_unlock(&ipt->init_lock);
- return NULL;
+ goto do_exit;
}
ipt->state = TD_INITIALIZED;
/* exit if other threads failed to initialize */
if (ipc.status == IDLE_PROF_STATUS_ABORT) {
pthread_mutex_unlock(&ipt->start_lock);
- return NULL;
+ goto do_exit;
}
/* exit if we are doing calibration only */
if (ipc.status == IDLE_PROF_STATUS_CALI_STOP) {
pthread_mutex_unlock(&ipt->start_lock);
- return NULL;
+ goto do_exit;
}
fio_gettime(&ipt->tps, NULL);
ipt->state = TD_EXITED;
pthread_mutex_unlock(&ipt->start_lock);
+do_exit:
+ free_cpu_affinity(ipt);
return NULL;
}
void fio_idle_prof_init(void)
{
int i, ret;
- struct timeval tp;
struct timespec ts;
pthread_attr_t tattr;
+ pthread_condattr_t cattr;
struct idle_prof_thread *ipt;
ipc.nr_cpus = cpus_online();
if (ipc.opt == IDLE_PROF_OPT_NONE)
return;
+ ret = pthread_condattr_init(&cattr);
+ assert(ret == 0);
+#ifdef CONFIG_PTHREAD_CONDATTR_SETCLOCK
+ ret = pthread_condattr_setclock(&cattr, CLOCK_MONOTONIC);
+ assert(ret == 0);
+#endif
+
if ((ret = pthread_attr_init(&tattr))) {
log_err("fio: pthread_attr_init %s\n", strerror(ret));
return;
break;
}
- if ((ret = pthread_cond_init(&ipt->cond, NULL))) {
+ if ((ret = pthread_cond_init(&ipt->cond, &cattr))) {
ipc.status = IDLE_PROF_STATUS_ABORT;
log_err("fio: pthread_cond_init %s\n", strerror(ret));
break;
if ((ret = pthread_detach(ipt->thread))) {
/* log error and let the thread spin */
- log_err("fio: pthread_detatch %s\n", strerror(ret));
+ log_err("fio: pthread_detach %s\n", strerror(ret));
}
}
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;
+#ifdef CONFIG_PTHREAD_CONDATTR_SETCLOCK
+ clock_gettime(CLOCK_MONOTONIC, &ts);
+#else
+ clock_gettime(CLOCK_REALTIME, &ts);
+#endif
+ ts.tv_sec += 1;
pthread_cond_timedwait(&ipt->cond, &ipt->init_lock, &ts);
}
pthread_mutex_unlock(&ipt->init_lock);
{
int i;
uint64_t runt;
- struct timeval tp;
struct timespec ts;
struct idle_prof_thread *ipt;
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;
+ fio_gettime(&ts, NULL);
+ ts.tv_sec += 1;
/* timed wait in case a signal is not received */
pthread_cond_timedwait(&ipt->cond, &ipt->start_lock, &ts);
}
return p * 100.0;
}
-static void fio_idle_prof_cleanup(void)
+void fio_idle_prof_cleanup(void)
{
if (ipc.ipts) {
free(ipc.ipts);
fio_idle_prof_init();
fio_idle_prof_start();
fio_idle_prof_stop();
- show_idle_prof_stats(FIO_OUTPUT_NORMAL, NULL);
+ show_idle_prof_stats(FIO_OUTPUT_NORMAL, NULL, NULL);
return 1;
} else if (strcmp("system", args) == 0) {
ipc.opt = IDLE_PROF_OPT_SYSTEM;
#endif
}
-void show_idle_prof_stats(int output, struct json_object *parent)
+void show_idle_prof_stats(int output, struct json_object *parent,
+ struct buf_output *out)
{
int i, nr_cpus = ipc.nr_cpus;
struct json_object *tmp;
if (output == FIO_OUTPUT_NORMAL) {
if (ipc.opt > IDLE_PROF_OPT_CALI)
- log_info("\nCPU idleness:\n");
+ log_buf(out, "\nCPU idleness:\n");
else if (ipc.opt == IDLE_PROF_OPT_CALI)
- log_info("CPU idleness:\n");
+ log_buf(out, "CPU idleness:\n");
if (ipc.opt >= IDLE_PROF_OPT_SYSTEM)
- log_info(" system: %3.2f%%\n", fio_idle_prof_cpu_stat(-1));
+ log_buf(out, " 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));
+ log_buf(out, " 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");
+ log_buf(out, ", %3.2f%%", fio_idle_prof_cpu_stat(i));
+ log_buf(out, "\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);
+ log_buf(out, " unit work: mean=%3.2fus,", ipc.cali_mean);
+ log_buf(out, " 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 ((ipc.opt != IDLE_PROF_OPT_NONE) && (output & FIO_OUTPUT_JSON)) {
if (!parent)
return;
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();
}
}