[fio.git] / engines / fio-engine-posixaio.c

/*
 * posix aio io engine
 *
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <assert.h>
#include "fio.h"
#include "os.h"

struct posixaio_data {
	struct io_u **aio_events;
};

static int fill_timespec(struct timespec *ts)
{
#ifdef _POSIX_TIMERS
	if (!clock_gettime(CLOCK_MONOTONIC, ts))
		return 0;

	perror("clock_gettime");
#endif
	return 1;
}

static unsigned long long ts_utime_since_now(struct timespec *t)
{
	long long sec, nsec;
	struct timespec now;

	if (fill_timespec(&now))
		return 0;
	
	sec = now.tv_sec - t->tv_sec;
	nsec = now.tv_nsec - t->tv_nsec;
	if (sec > 0 && nsec < 0) {
		sec--;
		nsec += 1000000000;
	}

	sec *= 1000000;
	nsec /= 1000;
	return sec + nsec;
}

static int fio_posixaio_sync(struct thread_data fio_unused *td,
			     struct fio_file *f)
{
	return fsync(f->fd);
}

static int fio_posixaio_cancel(struct thread_data fio_unused *td,
			       struct io_u *io_u)
{
	struct fio_file *f = io_u->file;
	int r = aio_cancel(f->fd, &io_u->aiocb);

	if (r == 1 || r == AIO_CANCELED)
		return 0;

	return 1;
}

static int fio_posixaio_prep(struct thread_data fio_unused *td,
			     struct io_u *io_u)
{
	struct aiocb *aiocb = &io_u->aiocb;
	struct fio_file *f = io_u->file;

	aiocb->aio_fildes = f->fd;
	aiocb->aio_buf = io_u->buf;
	aiocb->aio_nbytes = io_u->buflen;
	aiocb->aio_offset = io_u->offset;

	io_u->seen = 0;
	return 0;
}

static int fio_posixaio_getevents(struct thread_data *td, int min, int max,
				  struct timespec *t)
{
	struct posixaio_data *pd = td->io_ops->data;
	struct list_head *entry;
	struct timespec start;
	int r, have_timeout = 0;

	if (t && !fill_timespec(&start))
		have_timeout = 1;

	r = 0;
restart:
	list_for_each(entry, &td->io_u_busylist) {
		struct io_u *io_u = list_entry(entry, struct io_u, list);
		int err;

		if (io_u->seen)
			continue;

		err = aio_error(&io_u->aiocb);
		switch (err) {
			default:
				io_u->error = err;
			case ECANCELED:
			case 0:
				pd->aio_events[r++] = io_u;
				io_u->seen = 1;
				break;
			case EINPROGRESS:
				break;
		}

		if (r >= max)
			break;
	}

	if (r >= min)
		return r;

	if (have_timeout) {
		unsigned long long usec;

		usec = (t->tv_sec * 1000000) + (t->tv_nsec / 1000);
		if (ts_utime_since_now(&start) > usec)
			return r;
	}

	/*
	 * hrmpf, we need to wait for more. we should use aio_suspend, for
	 * now just sleep a little and recheck status of busy-and-not-seen
	 */
	usleep(1000);
	goto restart;
}

static struct io_u *fio_posixaio_event(struct thread_data *td, int event)
{
	struct posixaio_data *pd = td->io_ops->data;

	return pd->aio_events[event];
}

static int fio_posixaio_queue(struct thread_data fio_unused *td,
			      struct io_u *io_u)
{
	struct aiocb *aiocb = &io_u->aiocb;
	int ret;

	if (io_u->ddir == DDIR_READ)
		ret = aio_read(aiocb);
	else
		ret = aio_write(aiocb);

	if (ret)
		io_u->error = errno;
		
	return io_u->error;
}

static void fio_posixaio_cleanup(struct thread_data *td)
{
	struct posixaio_data *pd = td->io_ops->data;

	if (pd) {
		free(pd->aio_events);
		free(pd);
		td->io_ops->data = NULL;
	}
}

static int fio_posixaio_init(struct thread_data *td)
{
	struct posixaio_data *pd = malloc(sizeof(*pd));

	pd->aio_events = malloc(td->iodepth * sizeof(struct io_u *));

	td->io_ops->data = pd;
	return 0;
}

struct ioengine_ops ioengine = {
	.name		= "posixaio",
	.version	= FIO_IOOPS_VERSION,
	.init		= fio_posixaio_init,
	.prep		= fio_posixaio_prep,
	.queue		= fio_posixaio_queue,
	.cancel		= fio_posixaio_cancel,
	.getevents	= fio_posixaio_getevents,
	.event		= fio_posixaio_event,
	.cleanup	= fio_posixaio_cleanup,
	.sync		= fio_posixaio_sync,
};
Commit	Line	Data
2866c82d JA	1	/*
	2	* posix aio io engine
	3	*
	4	*/
	5	#include <stdio.h>
	6	#include <stdlib.h>
	7	#include <unistd.h>
	8	#include <errno.h>
	9	#include <assert.h>
	10	#include "fio.h"
	11	#include "os.h"
	12
	13	struct posixaio_data {
	14	struct io_u **aio_events;
	15	};
	16
	17	static int fill_timespec(struct timespec *ts)
	18	{
	19	#ifdef _POSIX_TIMERS
	20	if (!clock_gettime(CLOCK_MONOTONIC, ts))
	21	return 0;
	22
	23	perror("clock_gettime");
	24	#endif
	25	return 1;
	26	}
	27
	28	static unsigned long long ts_utime_since_now(struct timespec *t)
	29	{
	30	long long sec, nsec;
	31	struct timespec now;
	32
	33	if (fill_timespec(&now))
	34	return 0;
	35
	36	sec = now.tv_sec - t->tv_sec;
	37	nsec = now.tv_nsec - t->tv_nsec;
	38	if (sec > 0 && nsec < 0) {
	39	sec--;
	40	nsec += 1000000000;
	41	}
	42
	43	sec *= 1000000;
	44	nsec /= 1000;
	45	return sec + nsec;
	46	}
	47
7a16dd02 JA	48	static int fio_posixaio_sync(struct thread_data fio_unused *td,
7a16dd02 JA	49	struct fio_file *f)
2866c82d	50	{
53cdc686	51	return fsync(f->fd);
2866c82d JA	52	}
2866c82d JA	53
7a16dd02 JA	54	static int fio_posixaio_cancel(struct thread_data fio_unused *td,
7a16dd02 JA	55	struct io_u *io_u)
2866c82d	56	{
53cdc686 JA	57	struct fio_file *f = io_u->file;
53cdc686 JA	58	int r = aio_cancel(f->fd, &io_u->aiocb);
2866c82d JA	59
	60	if (r == 1 \|\| r == AIO_CANCELED)
	61	return 0;
	62
	63	return 1;
	64	}
	65
7a16dd02 JA	66	static int fio_posixaio_prep(struct thread_data fio_unused *td,
7a16dd02 JA	67	struct io_u *io_u)
2866c82d JA	68	{
2866c82d JA	69	struct aiocb *aiocb = &io_u->aiocb;
53cdc686	70	struct fio_file *f = io_u->file;
2866c82d	71
53cdc686	72	aiocb->aio_fildes = f->fd;
2866c82d JA	73	aiocb->aio_buf = io_u->buf;
	74	aiocb->aio_nbytes = io_u->buflen;
	75	aiocb->aio_offset = io_u->offset;
	76
	77	io_u->seen = 0;
	78	return 0;
	79	}
	80
	81	static int fio_posixaio_getevents(struct thread_data *td, int min, int max,
	82	struct timespec *t)
	83	{
	84	struct posixaio_data *pd = td->io_ops->data;
	85	struct list_head *entry;
	86	struct timespec start;
	87	int r, have_timeout = 0;
	88
	89	if (t && !fill_timespec(&start))
	90	have_timeout = 1;
	91
	92	r = 0;
	93	restart:
	94	list_for_each(entry, &td->io_u_busylist) {
	95	struct io_u *io_u = list_entry(entry, struct io_u, list);
	96	int err;
	97
	98	if (io_u->seen)
	99	continue;
	100
	101	err = aio_error(&io_u->aiocb);
	102	switch (err) {
	103	default:
	104	io_u->error = err;
	105	case ECANCELED:
	106	case 0:
	107	pd->aio_events[r++] = io_u;
	108	io_u->seen = 1;
	109	break;
	110	case EINPROGRESS:
	111	break;
	112	}
	113
	114	if (r >= max)
	115	break;
	116	}
	117
	118	if (r >= min)
	119	return r;
	120
	121	if (have_timeout) {
	122	unsigned long long usec;
	123
	124	usec = (t->tv_sec * 1000000) + (t->tv_nsec / 1000);
	125	if (ts_utime_since_now(&start) > usec)
	126	return r;
	127	}
	128
	129	/*
	130	* hrmpf, we need to wait for more. we should use aio_suspend, for
	131	* now just sleep a little and recheck status of busy-and-not-seen
	132	*/
	133	usleep(1000);
	134	goto restart;
	135	}
	136
137	static struct io_u fio_posixaio_event(struct thread_data td, int event)
138	{
139	struct posixaio_data *pd = td->io_ops->data;
140
141	return pd->aio_events[event];
142	}
143
144	static int fio_posixaio_queue(struct thread_data fio_unused *td,
145	struct io_u *io_u)
146	{
147	struct aiocb *aiocb = &io_u->aiocb;
148	int ret;
149
150	if (io_u->ddir == DDIR_READ)
151	ret = aio_read(aiocb);
152	else
153	ret = aio_write(aiocb);
154
155	if (ret)
156	io_u->error = errno;
157
158	return io_u->error;
159	}
160
161	static void fio_posixaio_cleanup(struct thread_data *td)
162	{
163	struct posixaio_data *pd = td->io_ops->data;
164
165	if (pd) {
166	free(pd->aio_events);
167	free(pd);
168	td->io_ops->data = NULL;
169	}
170	}
171
172	static int fio_posixaio_init(struct thread_data *td)
173	{
174	struct posixaio_data pd = malloc(sizeof(pd));
175
176	pd->aio_events = malloc(td->iodepth * sizeof(struct io_u *));
177
178	td->io_ops->data = pd;
179	return 0;
180	}
181
182	struct ioengine_ops ioengine = {
183	.name = "posixaio",
184	.version = FIO_IOOPS_VERSION,
185	.init = fio_posixaio_init,
186	.prep = fio_posixaio_prep,
187	.queue = fio_posixaio_queue,
188	.cancel = fio_posixaio_cancel,
189	.getevents = fio_posixaio_getevents,
190	.event = fio_posixaio_event,
191	.cleanup = fio_posixaio_cleanup,
192	.sync = fio_posixaio_sync,
193	};