/*
* wait for any pending requests, and then free all ram associated with
* an operation. returns the last error the operation hit (zero means none)
*/
static int finish_oper(struct thread_info *t, struct io_oper *oper)
{
unsigned long last_err;
io_oper_wait(t, oper);
last_err = oper->last_err;
if (oper->num_pending > 0) {
fprintf(stderr, "oper num_pending is %d\n", oper->num_pending);
}
close(oper->fd);
free(oper);
return last_err;
}
/* this is the meat of the state machine. There is a list of
* active operations structs, and as each one finishes the required
* io it is moved to a list of finished operations. Once they have
* all finished whatever stage they were in, they are given the chance
* to restart and pick a different stage (read/write/random read etc)
*
* various timings are printed in between the stages, along with
* thread synchronization if there are more than one threads.
*/
int worker(struct thread_info *t)
{
struct io_oper *oper;
char *this_stage = NULL;
struct timeval stage_time;
int status = 0;
int iteration = 0;
int cnt;
aio_setup(&t->io_ctx, 512);
restart:
if (num_threads > 1) {
pthread_mutex_lock(&stage_mutex);
threads_starting++;
if (threads_starting == num_threads) {
threads_ending = 0;
gettimeofday(&global_stage_start_time, NULL);
pthread_cond_broadcast(&stage_cond);
}
while (threads_starting != num_threads)
pthread_cond_wait(&stage_cond, &stage_mutex);
pthread_mutex_unlock(&stage_mutex);
}
if (t->active_opers) {
this_stage = stage_name(t->active_opers->rw);
gettimeofday(&stage_time, NULL);
t->stage_mb_trans = 0;
}
cnt = 0;
/* first we send everything through aio */
while(t->active_opers && (cnt < iterations || iterations == RUN_FOREVER)) {
if (stonewall && threads_ending) {
oper = t->active_opers;
oper->stonewalled = 1;
oper_list_del(oper, &t->active_opers);
oper_list_add(oper, &t->finished_opers);
} else {
run_active_list(t, io_iter, max_io_submit);
}
cnt++;
}
if (latency_stats)
print_latency(t);
if (completion_latency_stats)
print_completion_latency(t);
/* then we wait for all the operations to finish */
oper = t->finished_opers;
do {
if (!oper)
break;
io_oper_wait(t, oper);
oper = oper->next;
} while(oper != t->finished_opers);
/* then we do an fsync to get the timing for any future operations
* right, and check to see if any of these need to get restarted
*/
oper = t->finished_opers;
while(oper) {
if (fsync_stages)
fsync(oper->fd);
t->stage_mb_trans += oper_mb_trans(oper);
if (restart_oper(oper)) {
oper_list_del(oper, &t->finished_opers);
oper_list_add(oper, &t->active_opers);
oper = t->finished_opers;
continue;
}
oper = oper->next;
if (oper == t->finished_opers)
break;
}
if (t->stage_mb_trans && t->num_files > 0) {
double seconds = time_since_now(&stage_time);
fprintf(stderr, "thread %llu %s totals (%.2f MB/s) %.2f MB in %.2fs\n",
(unsigned long long)(t - global_thread_info), this_stage,
t->stage_mb_trans/seconds, t->stage_mb_trans, seconds);
}
if (num_threads > 1) {
pthread_mutex_lock(&stage_mutex);
threads_ending++;
if (threads_ending == num_threads) {
threads_starting = 0;
pthread_cond_broadcast(&stage_cond);
global_thread_throughput(t, this_stage);
}
while(threads_ending != num_threads)
pthread_cond_wait(&stage_cond, &stage_mutex);
pthread_mutex_unlock(&stage_mutex);
}
/* someone got restarted, go back to the beginning */
if (t->active_opers && (cnt < iterations || iterations == RUN_FOREVER)) {
iteration++;
goto restart;
}
/* finally, free all the ram */
while(t->finished_opers) {
oper = t->finished_opers;
oper_list_del(oper, &t->finished_opers);
status = finish_oper(t, oper);
}
if (t->num_global_pending) {
fprintf(stderr, "global num pending is %d\n", t->num_global_pending);
}
io_queue_release(t->io_ctx);
return status;
}
