74a6b31145167c00be9c6d9cadb974a3d69c43d5
[fio.git] / engines / syslet-rw.c
1 /*
2  * read/write() engine that uses syslet to be async
3  *
4  */
5 #include <stdio.h>
6 #include <stdlib.h>
7 #include <unistd.h>
8 #include <errno.h>
9 #include <assert.h>
10
11 #include "../fio.h"
12 #include "../os.h"
13
14 #ifdef FIO_HAVE_SYSLET
15
16 struct syslet_data {
17         struct io_u **events;
18         unsigned int nr_events;
19         
20         struct async_head_user ahu;
21         struct syslet_uatom **ring;
22
23         struct syslet_uatom *head, *tail;
24         struct syslet_uatom **event_map;
25         unsigned int event_map_idx;
26 };
27
28 static void fio_syslet_complete_atom(struct thread_data *td,
29                                      struct syslet_uatom *atom)
30 {
31         struct syslet_data *sd = td->io_ops->data;
32         struct io_u *io_u;
33         int i, end;
34
35         if (!sd->event_map_idx)
36                 return;
37
38         /*
39          * Find the start of the string of atoms for this sequence
40          */
41         for (end = sd->event_map_idx - 1; end >= 0; end--)
42                 if (atom == sd->event_map[end])
43                         break;
44
45         if (end < 0 || atom != sd->event_map[end]) {
46                 printf("didn't find atom\n");
47                 return;
48         }
49
50         //printf("end=%d, total %d\n", end, sd->event_map_idx);
51
52         /*
53          * now complete in right order
54          */
55         for (i = 0; i <= end; i++) {
56                 long ret;
57
58                 atom = sd->event_map[i];
59                 io_u = atom->private;
60                 ret = *atom->ret_ptr;
61                 if (ret > 0)
62                         io_u->resid = io_u->xfer_buflen - ret;
63                 else if (ret < 0)
64                         io_u->error = ret;
65
66                 assert(sd->nr_events < td->iodepth);
67                 sd->events[sd->nr_events++] = io_u;
68         }
69
70         /*
71          * Move later completions to the front, if we didn't complete all
72          */
73         if (end == (int) sd->event_map_idx - 1)
74                 sd->event_map_idx = 0;
75         else {
76                 int nr = sd->event_map_idx - end - 1;
77
78                 memmove(sd->event_map, &sd->event_map[end + 1], nr * sizeof(struct syslet_uatom *));
79                 sd->event_map_idx = nr;
80         }
81 }
82
83 /*
84  * Inspect the ring to see if we have completed events
85  */
86 static void fio_syslet_complete(struct thread_data *td)
87 {
88         struct syslet_data *sd = td->io_ops->data;
89
90         do {
91                 struct syslet_uatom *atom;
92
93                 atom = sd->ring[sd->ahu.user_ring_idx];
94                 if (!atom)
95                         break;
96
97                 sd->ring[sd->ahu.user_ring_idx] = NULL;
98                 if (++sd->ahu.user_ring_idx == td->iodepth)
99                         sd->ahu.user_ring_idx = 0;
100
101                 fio_syslet_complete_atom(td, atom);
102         } while (1);
103 }
104
105 static int fio_syslet_getevents(struct thread_data *td, int min,
106                                 int fio_unused max,
107                                 struct timespec fio_unused *t)
108 {
109         struct syslet_data *sd = td->io_ops->data;
110         long ret;
111
112         do {
113                 fio_syslet_complete(td);
114
115                 /*
116                  * do we have enough immediate completions?
117                  */
118                 if (sd->nr_events >= (unsigned int) min)
119                         break;
120
121                 /*
122                  * OK, we need to wait for some events...
123                  */
124                 ret = async_wait(1, sd->ahu.user_ring_idx, &sd->ahu);
125                 if (ret < 0)
126                         return -errno;
127         } while (1);
128
129         ret = sd->nr_events;
130         sd->nr_events = 0;
131         return ret;
132 }
133
134 static struct io_u *fio_syslet_event(struct thread_data *td, int event)
135 {
136         struct syslet_data *sd = td->io_ops->data;
137
138         return sd->events[event];
139 }
140
141 static void init_atom(struct syslet_uatom *atom, int nr, void *arg0,
142                       void *arg1, void *arg2, void *arg3, void *ret_ptr,
143                       unsigned long flags, void *priv)
144 {
145         atom->flags = flags;
146         atom->nr = nr;
147         atom->ret_ptr = ret_ptr;
148         atom->next = NULL;
149         atom->arg_ptr[0] = arg0;
150         atom->arg_ptr[1] = arg1;
151         atom->arg_ptr[2] = arg2;
152         atom->arg_ptr[3] = arg3;
153         atom->arg_ptr[4] = atom->arg_ptr[5] = NULL;
154         atom->private = priv;
155 }
156
157 /*
158  * Use seek atom for sync
159  */
160 static void fio_syslet_prep_sync(struct io_u *io_u, struct fio_file *f)
161 {
162         init_atom(&io_u->req.atom, __NR_fsync, &f->fd, NULL, NULL, NULL,
163                   &io_u->req.ret, 0, io_u);
164 }
165
166 static void fio_syslet_prep_rw(struct io_u *io_u, struct fio_file *f)
167 {
168         int nr;
169
170         /*
171          * prepare rw
172          */
173         if (io_u->ddir == DDIR_READ)
174                 nr = __NR_pread64;
175         else
176                 nr = __NR_pwrite64;
177
178         init_atom(&io_u->req.atom, nr, &f->fd, &io_u->xfer_buf,
179                   &io_u->xfer_buflen, &io_u->offset, &io_u->req.ret, 0, io_u);
180 }
181
182 static int fio_syslet_prep(struct thread_data fio_unused *td, struct io_u *io_u)
183 {
184         struct fio_file *f = io_u->file;
185
186         if (io_u->ddir == DDIR_SYNC)
187                 fio_syslet_prep_sync(io_u, f);
188         else
189                 fio_syslet_prep_rw(io_u, f);
190
191         return 0;
192 }
193
194 static void cachemiss_thread_start(void)
195 {
196         while (1)
197                 async_thread();
198 }
199
200 #define THREAD_STACK_SIZE (16384)
201
202 static unsigned long thread_stack_alloc()
203 {
204         return (unsigned long)malloc(THREAD_STACK_SIZE) + THREAD_STACK_SIZE;
205 }
206
207 static int fio_syslet_commit(struct thread_data *td)
208 {
209         struct syslet_data *sd = td->io_ops->data;
210         struct syslet_uatom *done;
211
212         if (!sd->head)
213                 return 0;
214
215         if (!sd->ahu.new_thread_stack)
216                 sd->ahu.new_thread_stack = thread_stack_alloc();
217
218         /*
219          * On sync completion, the atom is returned. So on NULL return
220          * it's queued asynchronously.
221          */
222         done = async_exec(sd->head, &sd->ahu);
223
224         sd->head = sd->tail = NULL;
225
226         if (done)
227                 fio_syslet_complete_atom(td, done);
228
229         return 0;
230 }
231
232 static int fio_syslet_queue(struct thread_data *td, struct io_u *io_u)
233 {
234         struct syslet_data *sd = td->io_ops->data;
235
236         if (sd->tail) {
237                 sd->tail->next = &io_u->req.atom;
238                 sd->tail = &io_u->req.atom;
239         } else
240                 sd->head = sd->tail = &io_u->req.atom;
241
242         sd->event_map[sd->event_map_idx++] = sd->tail;
243         return FIO_Q_QUEUED;
244 }
245
246 static int async_head_init(struct syslet_data *sd, unsigned int depth)
247 {
248         unsigned long ring_size;
249
250         memset(&sd->ahu, 0, sizeof(struct async_head_user));
251
252         ring_size = sizeof(struct syslet_uatom *) * depth;
253         sd->ring = malloc(ring_size);
254         memset(sd->ring, 0, ring_size);
255
256         sd->ahu.user_ring_idx = 0;
257         sd->ahu.completion_ring = sd->ring;
258         sd->ahu.ring_size_bytes = ring_size;
259         sd->ahu.head_stack = thread_stack_alloc();
260         sd->ahu.head_eip = (unsigned long)cachemiss_thread_start;
261         sd->ahu.new_thread_eip = (unsigned long)cachemiss_thread_start;
262
263         return 0;
264 }
265
266 static void async_head_exit(struct syslet_data *sd)
267 {
268         free(sd->ring);
269 }
270
271 static void fio_syslet_cleanup(struct thread_data *td)
272 {
273         struct syslet_data *sd = td->io_ops->data;
274
275         if (sd) {
276                 async_head_exit(sd);
277                 free(sd->events);
278                 free(sd->event_map);
279                 free(sd);
280                 td->io_ops->data = NULL;
281         }
282 }
283
284 static int fio_syslet_init(struct thread_data *td)
285 {
286         struct syslet_data *sd;
287
288
289         sd = malloc(sizeof(*sd));
290         memset(sd, 0, sizeof(*sd));
291         sd->events = malloc(sizeof(struct io_u *) * td->iodepth);
292         memset(sd->events, 0, sizeof(struct io_u *) * td->iodepth);
293         sd->event_map = malloc(sizeof(struct syslet_uatom *) * td->iodepth);
294         memset(sd->event_map, 0, sizeof(struct syslet_uatom *) * td->iodepth);
295
296         /*
297          * This will handily fail for kernels where syslet isn't available
298          */
299         if (async_head_init(sd, td->iodepth)) {
300                 free(sd->events);
301                 free(sd);
302                 return 1;
303         }
304
305         td->io_ops->data = sd;
306         return 0;
307 }
308
309 static struct ioengine_ops ioengine = {
310         .name           = "syslet-rw",
311         .version        = FIO_IOOPS_VERSION,
312         .init           = fio_syslet_init,
313         .prep           = fio_syslet_prep,
314         .queue          = fio_syslet_queue,
315         .commit         = fio_syslet_commit,
316         .getevents      = fio_syslet_getevents,
317         .event          = fio_syslet_event,
318         .cleanup        = fio_syslet_cleanup,
319 };
320
321 #else /* FIO_HAVE_SYSLET */
322
323 /*
324  * When we have a proper configure system in place, we simply wont build
325  * and install this io engine. For now install a crippled version that
326  * just complains and fails to load.
327  */
328 static int fio_syslet_init(struct thread_data fio_unused *td)
329 {
330         fprintf(stderr, "fio: syslet not available\n");
331         return 1;
332 }
333
334 static struct ioengine_ops ioengine = {
335         .name           = "syslet-rw",
336         .version        = FIO_IOOPS_VERSION,
337         .init           = fio_syslet_init,
338 };
339
340 #endif /* FIO_HAVE_SYSLET */
341
342 static void fio_init fio_syslet_register(void)
343 {
344         register_ioengine(&ioengine);
345 }
346
347 static void fio_exit fio_syslet_unregister(void)
348 {
349         unregister_ioengine(&ioengine);
350 }