ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/IO-AIO/AIO.xs
(Generate patch)

Comparing IO-AIO/AIO.xs (file contents):
Revision 1.2 by root, Sun Jul 10 18:16:49 2005 UTC vs.
Revision 1.59 by root, Mon Oct 23 18:56:27 2006 UTC

1#define PERL_NO_GET_CONTEXT 1#define _REENTRANT 1
2#include <errno.h>
2 3
3#include "EXTERN.h" 4#include "EXTERN.h"
4#include "perl.h" 5#include "perl.h"
5#include "XSUB.h" 6#include "XSUB.h"
6 7
8#include "autoconf/config.h"
9
10#include <pthread.h>
11
12#include <stddef.h>
13#include <errno.h>
14#include <sys/time.h>
15#include <sys/select.h>
7#include <sys/types.h> 16#include <sys/types.h>
8#include <sys/stat.h> 17#include <sys/stat.h>
18#include <limits.h>
9#include <unistd.h> 19#include <unistd.h>
10#include <fcntl.h> 20#include <fcntl.h>
11#include <signal.h> 21#include <signal.h>
12#include <sched.h> 22#include <sched.h>
13#include <endian.h>
14 23
15#include <pthread.h> 24#if HAVE_SENDFILE
25# if __linux
26# include <sys/sendfile.h>
27# elif __freebsd
16#include <sys/syscall.h> 28# include <sys/socket.h>
29# include <sys/uio.h>
30# elif __hpux
31# include <sys/socket.h>
32# elif __solaris /* not yet */
33# include <sys/sendfile.h>
34# else
35# error sendfile support requested but not available
36# endif
37#endif
17 38
18typedef void *InputStream; /* hack, but 5.6.1 is simply toooo old ;) */ 39/* used for struct dirent, AIX doesn't provide it */
19typedef void *OutputStream; /* hack, but 5.6.1 is simply toooo old ;) */ 40#ifndef NAME_MAX
20typedef void *InOutStream; /* hack, but 5.6.1 is simply toooo old ;) */ 41# define NAME_MAX 4096
42#endif
21 43
22#if __i386 || __amd64
23# define STACKSIZE ( 256 * sizeof (long))
24#elif __ia64 44#if __ia64
25# define STACKSIZE (8192 * sizeof (long)) 45# define STACKSIZE 65536
26#else 46#else
27# define STACKSIZE ( 512 * sizeof (long)) 47# define STACKSIZE 8192
28#endif 48#endif
29 49
30enum { 50enum {
31 REQ_QUIT, 51 REQ_QUIT,
32 REQ_OPEN, REQ_CLOSE, 52 REQ_OPEN, REQ_CLOSE,
33 REQ_READ, REQ_WRITE, REQ_READAHEAD, 53 REQ_READ, REQ_WRITE, REQ_READAHEAD,
54 REQ_SENDFILE,
34 REQ_STAT, REQ_LSTAT, REQ_FSTAT, REQ_UNLINK, 55 REQ_STAT, REQ_LSTAT, REQ_FSTAT,
35 REQ_FSYNC, REQ_FDATASYNC, 56 REQ_FSYNC, REQ_FDATASYNC,
57 REQ_UNLINK, REQ_RMDIR, REQ_RENAME,
58 REQ_READDIR,
59 REQ_LINK, REQ_SYMLINK,
60 REQ_GROUP, REQ_NOP,
61 REQ_SLEEP,
36}; 62};
37 63
64#define AIO_REQ_KLASS "IO::AIO::REQ"
65#define AIO_GRP_KLASS "IO::AIO::GRP"
66
38typedef struct aio_cb { 67typedef struct aio_cb
68{
39 struct aio_cb *next; 69 struct aio_cb *volatile next;
40 70
41 int type; 71 struct aio_cb *grp, *grp_prev, *grp_next, *grp_first;
42 72
43 int fd; 73 SV *self; /* the perl counterpart of this request, if any */
74
75 SV *data, *callback;
76 SV *fh, *fh2;
77 void *dataptr, *data2ptr;
78 Stat_t *statdata;
44 off_t offset; 79 off_t offset;
45 size_t length; 80 size_t length;
46 ssize_t result; 81 ssize_t result;
82
83 int type;
84 int fd, fd2;
85 int errorno;
86 STRLEN dataoffset;
47 mode_t mode; /* open */ 87 mode_t mode; /* open */
48 int errorno; 88 unsigned char pri;
49 SV *data, *callback; 89 unsigned char flags;
50 void *dataptr;
51 STRLEN dataoffset;
52
53 Stat_t *statdata;
54} aio_cb; 90} aio_cb;
55 91
92enum {
93 FLAG_CANCELLED = 0x01,
94};
95
56typedef aio_cb *aio_req; 96typedef aio_cb *aio_req;
97typedef aio_cb *aio_req_ornot;
57 98
58static int started; 99static int started, wanted;
59static int nreqs; 100static volatile int nreqs;
101static int max_outstanding = 1<<30;
60static int reqpipe[2], respipe[2]; 102static int respipe [2];
61 103
104static pthread_mutex_t reslock = PTHREAD_MUTEX_INITIALIZER;
105static pthread_mutex_t reqlock = PTHREAD_MUTEX_INITIALIZER;
106static pthread_cond_t reqwait = PTHREAD_COND_INITIALIZER;
107
62static aio_req qs, qe; /* queue start, queue end */ 108static volatile aio_req reqs, reqe; /* queue start, queue end */
109static volatile aio_req ress, rese; /* queue start, queue end */
63 110
64static void *aio_proc(void *arg); 111static void req_invoke (aio_req req);
112static void req_free (aio_req req);
65 113
66static void 114/* must be called at most once */
67start_thread (void) 115static SV *req_sv (aio_req req, const char *klass)
68{ 116{
69 sigset_t fullsigset, oldsigset; 117 if (!req->self)
70 pthread_t tid;
71 pthread_attr_t attr;
72
73 pthread_attr_init (&attr);
74 pthread_attr_setstacksize (&attr, STACKSIZE);
75 pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
76
77 sigfillset (&fullsigset);
78 sigprocmask (SIG_SETMASK, &fullsigset, &oldsigset);
79
80 if (pthread_create (&tid, &attr, aio_proc, 0) == 0)
81 started++;
82
83 sigprocmask (SIG_SETMASK, &oldsigset, 0);
84}
85
86static void
87send_reqs (void)
88{
89 /* this write is atomic */
90 while (qs && write (reqpipe[1], &qs, sizeof qs) == sizeof qs)
91 { 118 {
92 qs = qs->next; 119 req->self = (SV *)newHV ();
93 if (!qs) qe = 0; 120 sv_magic (req->self, 0, PERL_MAGIC_ext, (char *)req, 0);
94 } 121 }
95}
96 122
97static void 123 return sv_2mortal (sv_bless (newRV_inc (req->self), gv_stashpv (klass, 1)));
98send_req (aio_req req) 124}
99{
100 nreqs++;
101 req->next = 0;
102 125
103 if (qe) 126static aio_req SvAIO_REQ (SV *sv)
104 { 127{
105 qe->next = req; 128 MAGIC *mg;
106 qe = req; 129
130 if (!sv_derived_from (sv, AIO_REQ_KLASS) || !SvROK (sv))
131 croak ("object of class " AIO_REQ_KLASS " expected");
132
133 mg = mg_find (SvRV (sv), PERL_MAGIC_ext);
134
135 return mg ? (aio_req)mg->mg_ptr : 0;
136}
137
138static void aio_grp_feed (aio_req grp)
139{
140 while (grp->length < grp->fd2 && !(grp->flags & FLAG_CANCELLED))
107 } 141 {
108 else 142 int old_len = grp->length;
109 qe = qs = req;
110 143
111 send_reqs (); 144 if (grp->fh2 && SvOK (grp->fh2))
112} 145 {
146 dSP;
113 147
114static void 148 ENTER;
115end_thread (void) 149 SAVETMPS;
116{ 150 PUSHMARK (SP);
117 aio_req req; 151 XPUSHs (req_sv (grp, AIO_GRP_KLASS));
118 New (0, req, 1, aio_cb); 152 PUTBACK;
119 req->type = REQ_QUIT; 153 call_sv (grp->fh2, G_VOID | G_EVAL);
154 SPAGAIN;
155 FREETMPS;
156 LEAVE;
157 }
120 158
121 send_req (req); 159 /* stop if no progress has been made */
122} 160 if (old_len == grp->length)
123 161 {
124static void 162 SvREFCNT_dec (grp->fh2);
125read_write (pTHX_ 163 grp->fh2 = 0;
126 int dowrite, int fd, off_t offset, size_t length, 164 break;
127 SV *data, STRLEN dataoffset, SV *callback) 165 }
128{
129 aio_req req;
130 STRLEN svlen;
131 char *svptr = SvPV (data, svlen);
132
133 SvUPGRADE (data, SVt_PV);
134 SvPOK_on (data);
135
136 if (dataoffset < 0)
137 dataoffset += svlen;
138
139 if (dataoffset < 0 || dataoffset > svlen)
140 croak ("data offset outside of string");
141
142 if (dowrite)
143 { 166 }
144 /* write: check length and adjust. */ 167}
145 if (length < 0 || length + dataoffset > svlen) 168
146 length = svlen - dataoffset; 169static void aio_grp_dec (aio_req grp)
170{
171 --grp->length;
172
173 /* call feeder, if applicable */
174 aio_grp_feed (grp);
175
176 /* finish, if done */
177 if (!grp->length && grp->fd)
147 } 178 {
148 else 179 req_invoke (grp);
180 req_free (grp);
149 { 181 }
150 /* read: grow scalar as necessary */ 182}
151 svptr = SvGROW (data, length + dataoffset); 183
184static void poll_wait ()
185{
186 if (nreqs && !ress)
152 } 187 {
153
154 if (length < 0)
155 croak ("length must not be negative");
156
157 Newz (0, req, 1, aio_cb);
158
159 if (!req)
160 croak ("out of memory during aio_req allocation");
161
162 req->type = dowrite ? REQ_WRITE : REQ_READ;
163 req->fd = fd;
164 req->offset = offset;
165 req->length = length;
166 req->data = SvREFCNT_inc (data);
167 req->dataptr = (char *)svptr + dataoffset;
168 req->callback = SvREFCNT_inc (callback);
169
170 send_req (req);
171}
172
173static void
174poll_wait ()
175{
176 fd_set rfd; 188 fd_set rfd;
177 FD_ZERO(&rfd); 189 FD_ZERO(&rfd);
178 FD_SET(respipe[0], &rfd); 190 FD_SET(respipe [0], &rfd);
179 191
180 select (respipe[0] + 1, &rfd, 0, 0, 0); 192 select (respipe [0] + 1, &rfd, 0, 0, 0);
193 }
181} 194}
182 195
183static int 196static void req_invoke (aio_req req)
184poll_cb (pTHX) 197{
198 dSP;
199 int errorno = errno;
200
201 if (req->flags & FLAG_CANCELLED || !SvOK (req->callback))
202 return;
203
204 errno = req->errorno;
205
206 ENTER;
207 SAVETMPS;
208 PUSHMARK (SP);
209 EXTEND (SP, 1);
210
211 switch (req->type)
212 {
213 case REQ_READDIR:
214 {
215 SV *rv = &PL_sv_undef;
216
217 if (req->result >= 0)
218 {
219 char *buf = req->data2ptr;
220 AV *av = newAV ();
221
222 while (req->result)
223 {
224 SV *sv = newSVpv (buf, 0);
225
226 av_push (av, sv);
227 buf += SvCUR (sv) + 1;
228 req->result--;
229 }
230
231 rv = sv_2mortal (newRV_noinc ((SV *)av));
232 }
233
234 PUSHs (rv);
235 }
236 break;
237
238 case REQ_OPEN:
239 {
240 /* convert fd to fh */
241 SV *fh;
242
243 PUSHs (sv_2mortal (newSViv (req->result)));
244 PUTBACK;
245 call_pv ("IO::AIO::_fd2fh", G_SCALAR | G_EVAL);
246 SPAGAIN;
247
248 fh = SvREFCNT_inc (POPs);
249
250 PUSHMARK (SP);
251 XPUSHs (sv_2mortal (fh));
252 }
253 break;
254
255 case REQ_GROUP:
256 req->fd = 2; /* mark group as finished */
257
258 if (req->data)
259 {
260 int i;
261 AV *av = (AV *)req->data;
262
263 EXTEND (SP, AvFILL (av) + 1);
264 for (i = 0; i <= AvFILL (av); ++i)
265 PUSHs (*av_fetch (av, i, 0));
266 }
267 break;
268
269 case REQ_NOP:
270 case REQ_SLEEP:
271 break;
272
273 default:
274 PUSHs (sv_2mortal (newSViv (req->result)));
275 break;
276 }
277
278
279 PUTBACK;
280 call_sv (req->callback, G_VOID | G_EVAL);
281 SPAGAIN;
282
283 FREETMPS;
284 LEAVE;
285
286 errno = errorno;
287
288 if (SvTRUE (ERRSV))
289 {
290 req_free (req);
291 croak (0);
292 }
293}
294
295static void req_free (aio_req req)
296{
297 if (req->grp)
298 {
299 aio_req grp = req->grp;
300
301 /* unlink request */
302 if (req->grp_next) req->grp_next->grp_prev = req->grp_prev;
303 if (req->grp_prev) req->grp_prev->grp_next = req->grp_next;
304
305 if (grp->grp_first == req)
306 grp->grp_first = req->grp_next;
307
308 aio_grp_dec (grp);
309 }
310
311 if (req->self)
312 {
313 sv_unmagic (req->self, PERL_MAGIC_ext);
314 SvREFCNT_dec (req->self);
315 }
316
317 SvREFCNT_dec (req->data);
318 SvREFCNT_dec (req->fh);
319 SvREFCNT_dec (req->fh2);
320 SvREFCNT_dec (req->callback);
321 Safefree (req->statdata);
322
323 if (req->type == REQ_READDIR && req->result >= 0)
324 free (req->data2ptr);
325
326 Safefree (req);
327}
328
329static void req_cancel (aio_req req)
330{
331 req->flags |= FLAG_CANCELLED;
332
333 if (req->type == REQ_GROUP)
334 {
335 aio_req sub;
336
337 for (sub = req->grp_first; sub; sub = sub->grp_next)
338 req_cancel (sub);
339 }
340}
341
342static int poll_cb ()
185{ 343{
186 dSP; 344 dSP;
187 int count = 0; 345 int count = 0;
346 int do_croak = 0;
188 aio_req req; 347 aio_req req;
189 348
190 while (read (respipe[0], (void *)&req, sizeof (req)) == sizeof (req)) 349 for (;;)
191 { 350 {
351 pthread_mutex_lock (&reslock);
352 req = ress;
353
354 if (req)
355 {
356 ress = req->next;
357
358 if (!ress)
359 {
360 /* read any signals sent by the worker threads */
361 char buf [32];
362 while (read (respipe [0], buf, 32) == 32)
363 ;
364
365 rese = 0;
366 }
367 }
368
369 pthread_mutex_unlock (&reslock);
370
371 if (!req)
372 break;
373
192 nreqs--; 374 --nreqs;
193 375
194 if (req->type == REQ_QUIT) 376 if (req->type == REQ_QUIT)
195 started--; 377 started--;
378 else if (req->type == REQ_GROUP && req->length)
379 {
380 req->fd = 1; /* mark request as delayed */
381 continue;
382 }
196 else 383 else
197 { 384 {
198 int errorno = errno;
199 errno = req->errorno;
200
201 if (req->type == REQ_READ) 385 if (req->type == REQ_READ)
202 SvCUR_set (req->data, req->dataoffset 386 SvCUR_set (req->data, req->dataoffset + (req->result > 0 ? req->result : 0));
203 + req->result > 0 ? req->result : 0);
204 387
388 if (req->data2ptr && (req->type == REQ_READ || req->type == REQ_WRITE))
389 SvREADONLY_off (req->data);
390
205 if (req->data) 391 if (req->statdata)
206 SvREFCNT_dec (req->data);
207
208 if (req->type == REQ_STAT || req->type == REQ_LSTAT || req->type == REQ_FSTAT)
209 { 392 {
210 PL_laststype = req->type == REQ_LSTAT ? OP_LSTAT : OP_STAT; 393 PL_laststype = req->type == REQ_LSTAT ? OP_LSTAT : OP_STAT;
211 PL_laststatval = req->result; 394 PL_laststatval = req->result;
212 PL_statcache = *(req->statdata); 395 PL_statcache = *(req->statdata);
213
214 Safefree (req->statdata);
215 } 396 }
216 397
217 PUSHMARK (SP); 398 req_invoke (req);
218 XPUSHs (sv_2mortal (newSViv (req->result)));
219 399
220 if (req->type == REQ_OPEN)
221 {
222 /* convert fd to fh */
223 SV *fh;
224
225 PUTBACK;
226 call_pv ("IO::AIO::_fd2fh", G_SCALAR | G_EVAL);
227 SPAGAIN;
228
229 fh = POPs;
230
231 PUSHMARK (SP);
232 XPUSHs (fh);
233 }
234
235 PUTBACK;
236 call_sv (req->callback, G_VOID | G_EVAL);
237 SPAGAIN;
238
239 if (req->callback)
240 SvREFCNT_dec (req->callback);
241
242 errno = errorno;
243 count++; 400 count++;
244 } 401 }
245 402
246 Safefree (req); 403 req_free (req);
247 } 404 }
248
249 if (qs)
250 send_reqs ();
251 405
252 return count; 406 return count;
253} 407}
254 408
255static void * 409static void *aio_proc(void *arg);
256aio_proc (void *thr_arg) 410
411static void start_thread (void)
412{
413 sigset_t fullsigset, oldsigset;
414 pthread_t tid;
415 pthread_attr_t attr;
416
417 pthread_attr_init (&attr);
418 pthread_attr_setstacksize (&attr, STACKSIZE);
419 pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
420
421 sigfillset (&fullsigset);
422 sigprocmask (SIG_SETMASK, &fullsigset, &oldsigset);
423
424 if (pthread_create (&tid, &attr, aio_proc, 0) == 0)
425 started++;
426
427 sigprocmask (SIG_SETMASK, &oldsigset, 0);
428}
429
430static void req_send (aio_req req)
431{
432 while (started < wanted && nreqs >= started)
433 start_thread ();
434
435 ++nreqs;
436
437 pthread_mutex_lock (&reqlock);
438
439 req->next = 0;
440
441 if (reqe)
442 {
443 reqe->next = req;
444 reqe = req;
445 }
446 else
447 reqe = reqs = req;
448
449 pthread_cond_signal (&reqwait);
450 pthread_mutex_unlock (&reqlock);
451
452 if (nreqs > max_outstanding)
453 for (;;)
454 {
455 poll_cb ();
456
457 if (nreqs <= max_outstanding)
458 break;
459
460 poll_wait ();
461 }
462}
463
464static void end_thread (void)
257{ 465{
258 aio_req req; 466 aio_req req;
467 Newz (0, req, 1, aio_cb);
468 req->type = REQ_QUIT;
259 469
260 /* then loop */ 470 req_send (req);
261 while (read (reqpipe[0], (void *)&req, sizeof (req)) == sizeof (req)) 471}
472
473static void min_parallel (int nthreads)
474{
475 if (wanted < nthreads)
476 wanted = nthreads;
477}
478
479static void max_parallel (int nthreads)
480{
481 int cur = started;
482
483 if (wanted > nthreads)
484 wanted = nthreads;
485
486 while (cur > wanted)
487 {
488 end_thread ();
489 cur--;
262 { 490 }
491
492 while (started > wanted)
493 {
494 poll_wait ();
495 poll_cb ();
496 }
497}
498
499static void create_pipe ()
500{
501 if (pipe (respipe))
502 croak ("unable to initialize result pipe");
503
504 if (fcntl (respipe [0], F_SETFL, O_NONBLOCK))
505 croak ("cannot set result pipe to nonblocking mode");
506
507 if (fcntl (respipe [1], F_SETFL, O_NONBLOCK))
508 croak ("cannot set result pipe to nonblocking mode");
509}
510
511/*****************************************************************************/
512/* work around various missing functions */
513
514#if !HAVE_PREADWRITE
515# define pread aio_pread
516# define pwrite aio_pwrite
517
518/*
519 * make our pread/pwrite safe against themselves, but not against
520 * normal read/write by using a mutex. slows down execution a lot,
521 * but that's your problem, not mine.
522 */
523static pthread_mutex_t preadwritelock = PTHREAD_MUTEX_INITIALIZER;
524
525static ssize_t pread (int fd, void *buf, size_t count, off_t offset)
526{
527 ssize_t res;
528 off_t ooffset;
529
530 pthread_mutex_lock (&preadwritelock);
531 ooffset = lseek (fd, 0, SEEK_CUR);
532 lseek (fd, offset, SEEK_SET);
533 res = read (fd, buf, count);
534 lseek (fd, ooffset, SEEK_SET);
535 pthread_mutex_unlock (&preadwritelock);
536
537 return res;
538}
539
540static ssize_t pwrite (int fd, void *buf, size_t count, off_t offset)
541{
542 ssize_t res;
543 off_t ooffset;
544
545 pthread_mutex_lock (&preadwritelock);
546 ooffset = lseek (fd, 0, SEEK_CUR);
547 lseek (fd, offset, SEEK_SET);
548 res = write (fd, buf, count);
549 lseek (fd, offset, SEEK_SET);
550 pthread_mutex_unlock (&preadwritelock);
551
552 return res;
553}
554#endif
555
556#if !HAVE_FDATASYNC
557# define fdatasync fsync
558#endif
559
560#if !HAVE_READAHEAD
561# define readahead aio_readahead
562
563static ssize_t readahead (int fd, off_t offset, size_t count)
564{
565 char readahead_buf[4096];
566
567 while (count > 0)
568 {
569 size_t len = count < sizeof (readahead_buf) ? count : sizeof (readahead_buf);
570
571 pread (fd, readahead_buf, len, offset);
572 offset += len;
573 count -= len;
574 }
575
576 errno = 0;
577}
578#endif
579
580#if !HAVE_READDIR_R
581# define readdir_r aio_readdir_r
582
583static pthread_mutex_t readdirlock = PTHREAD_MUTEX_INITIALIZER;
584
585static int readdir_r (DIR *dirp, struct dirent *ent, struct dirent **res)
586{
587 struct dirent *e;
588 int errorno;
589
590 pthread_mutex_lock (&readdirlock);
591
592 e = readdir (dirp);
593 errorno = errno;
594
595 if (e)
596 {
597 *res = ent;
598 strcpy (ent->d_name, e->d_name);
599 }
600 else
601 *res = 0;
602
603 pthread_mutex_unlock (&readdirlock);
604
605 errno = errorno;
606 return e ? 0 : -1;
607}
608#endif
609
610/* sendfile always needs emulation */
611static ssize_t sendfile_ (int ofd, int ifd, off_t offset, size_t count)
612{
613 ssize_t res;
614
615 if (!count)
616 return 0;
617
618#if HAVE_SENDFILE
619# if __linux
620 res = sendfile (ofd, ifd, &offset, count);
621
622# elif __freebsd
623 /*
624 * Of course, the freebsd sendfile is a dire hack with no thoughts
625 * wasted on making it similar to other I/O functions.
626 */
627 {
628 off_t sbytes;
629 res = sendfile (ifd, ofd, offset, count, 0, &sbytes, 0);
630
631 if (res < 0 && sbytes)
632 /* maybe only on EAGAIN only: as usual, the manpage leaves you guessing */
633 res = sbytes;
634 }
635
636# elif __hpux
637 res = sendfile (ofd, ifd, offset, count, 0, 0);
638
639# elif __solaris
640 {
641 struct sendfilevec vec;
642 size_t sbytes;
643
644 vec.sfv_fd = ifd;
645 vec.sfv_flag = 0;
646 vec.sfv_off = offset;
647 vec.sfv_len = count;
648
649 res = sendfilev (ofd, &vec, 1, &sbytes);
650
651 if (res < 0 && sbytes)
652 res = sbytes;
653 }
654
655# endif
656#else
657 res = -1;
658 errno = ENOSYS;
659#endif
660
661 if (res < 0
662 && (errno == ENOSYS || errno == EINVAL || errno == ENOTSOCK
663#if __solaris
664 || errno == EAFNOSUPPORT || errno == EPROTOTYPE
665#endif
666 )
667 )
668 {
669 /* emulate sendfile. this is a major pain in the ass */
670 char buf[4096];
671 res = 0;
672
673 while (count)
674 {
675 ssize_t cnt;
676
677 cnt = pread (ifd, buf, count > 4096 ? 4096 : count, offset);
678
679 if (cnt <= 0)
680 {
681 if (cnt && !res) res = -1;
682 break;
683 }
684
685 cnt = write (ofd, buf, cnt);
686
687 if (cnt <= 0)
688 {
689 if (cnt && !res) res = -1;
690 break;
691 }
692
693 offset += cnt;
694 res += cnt;
695 count -= cnt;
696 }
697 }
698
699 return res;
700}
701
702/* read a full directory */
703static int scandir_ (const char *path, void **namesp)
704{
705 DIR *dirp = opendir (path);
706 union
707 {
708 struct dirent d;
709 char b [offsetof (struct dirent, d_name) + NAME_MAX + 1];
710 } u;
711 struct dirent *entp;
712 char *name, *names;
713 int memlen = 4096;
714 int memofs = 0;
715 int res = 0;
716 int errorno;
717
718 if (!dirp)
719 return -1;
720
721 names = malloc (memlen);
722
723 for (;;)
724 {
725 errno = 0, readdir_r (dirp, &u.d, &entp);
726
727 if (!entp)
728 break;
729
730 name = entp->d_name;
731
732 if (name [0] != '.' || (name [1] && (name [1] != '.' || name [2])))
733 {
734 int len = strlen (name) + 1;
735
736 res++;
737
738 while (memofs + len > memlen)
739 {
740 memlen *= 2;
741 names = realloc (names, memlen);
742 if (!names)
743 break;
744 }
745
746 memcpy (names + memofs, name, len);
747 memofs += len;
748 }
749 }
750
751 errorno = errno;
752 closedir (dirp);
753
754 if (errorno)
755 {
756 free (names);
757 errno = errorno;
758 res = -1;
759 }
760
761 *namesp = (void *)names;
762 return res;
763}
764
765/*****************************************************************************/
766
767static void *aio_proc (void *thr_arg)
768{
769 aio_req req;
770 int type;
771
772 do
773 {
774 pthread_mutex_lock (&reqlock);
775
776 for (;;)
777 {
778 req = reqs;
779
780 if (reqs)
781 {
782 reqs = reqs->next;
783 if (!reqs) reqe = 0;
784 }
785
786 if (req)
787 break;
788
789 pthread_cond_wait (&reqwait, &reqlock);
790 }
791
792 pthread_mutex_unlock (&reqlock);
793
263 errno = 0; /* strictly unnecessary */ 794 errno = 0; /* strictly unnecessary */
264 795
265 switch (req->type) 796 if (!(req->flags & FLAG_CANCELLED))
797 switch (type = req->type) /* remember type for QUIT check */
798 {
799 case REQ_READ: req->result = pread (req->fd, req->dataptr, req->length, req->offset); break;
800 case REQ_WRITE: req->result = pwrite (req->fd, req->dataptr, req->length, req->offset); break;
801
802 case REQ_READAHEAD: req->result = readahead (req->fd, req->offset, req->length); break;
803 case REQ_SENDFILE: req->result = sendfile_ (req->fd, req->fd2, req->offset, req->length); break;
804
805 case REQ_STAT: req->result = stat (req->dataptr, req->statdata); break;
806 case REQ_LSTAT: req->result = lstat (req->dataptr, req->statdata); break;
807 case REQ_FSTAT: req->result = fstat (req->fd , req->statdata); break;
808
809 case REQ_OPEN: req->result = open (req->dataptr, req->fd, req->mode); break;
810 case REQ_CLOSE: req->result = close (req->fd); break;
811 case REQ_UNLINK: req->result = unlink (req->dataptr); break;
812 case REQ_RMDIR: req->result = rmdir (req->dataptr); break;
813 case REQ_RENAME: req->result = rename (req->data2ptr, req->dataptr); break;
814 case REQ_LINK: req->result = link (req->data2ptr, req->dataptr); break;
815 case REQ_SYMLINK: req->result = symlink (req->data2ptr, req->dataptr); break;
816
817 case REQ_FDATASYNC: req->result = fdatasync (req->fd); break;
818 case REQ_FSYNC: req->result = fsync (req->fd); break;
819 case REQ_READDIR: req->result = scandir_ (req->dataptr, &req->data2ptr); break;
820
821 case REQ_SLEEP:
822 {
823 struct timeval tv;
824
825 tv.tv_sec = req->fd;
826 tv.tv_usec = req->fd2;
827
828 req->result = select (0, 0, 0, 0, &tv);
829 }
830
831 case REQ_GROUP:
832 case REQ_NOP:
833 case REQ_QUIT:
834 break;
835
836 default:
837 req->result = ENOSYS;
838 break;
839 }
840
841 req->errorno = errno;
842
843 pthread_mutex_lock (&reslock);
844
845 req->next = 0;
846
847 if (rese)
266 { 848 {
267 case REQ_READ: req->result = pread64 (req->fd, req->dataptr, req->length, req->offset); break; 849 rese->next = req;
268 case REQ_WRITE: req->result = pwrite64 (req->fd, req->dataptr, req->length, req->offset); break; 850 rese = req;
269#if SYS_readahead 851 }
270 case REQ_READAHEAD: req->result = readahead (req->fd, req->offset, req->length); break; 852 else
271#else 853 {
272 case REQ_READAHEAD: req->result = -1; errno = ENOSYS; break; 854 rese = ress = req;
855
856 /* write a dummy byte to the pipe so fh becomes ready */
857 write (respipe [1], &respipe, 1);
858 }
859
860 pthread_mutex_unlock (&reslock);
861 }
862 while (type != REQ_QUIT);
863
864 return 0;
865}
866
867/*****************************************************************************/
868
869static void atfork_prepare (void)
870{
871 pthread_mutex_lock (&reqlock);
872 pthread_mutex_lock (&reslock);
873#if !HAVE_PREADWRITE
874 pthread_mutex_lock (&preadwritelock);
273#endif 875#endif
876#if !HAVE_READDIR_R
877 pthread_mutex_lock (&readdirlock);
878#endif
879}
274 880
275 case REQ_STAT: req->result = stat (req->dataptr, req->statdata); break; 881static void atfork_parent (void)
276 case REQ_LSTAT: req->result = lstat (req->dataptr, req->statdata); break; 882{
277 case REQ_FSTAT: req->result = fstat (req->fd , req->statdata); break; 883#if !HAVE_READDIR_R
884 pthread_mutex_unlock (&readdirlock);
885#endif
886#if !HAVE_PREADWRITE
887 pthread_mutex_unlock (&preadwritelock);
888#endif
889 pthread_mutex_unlock (&reslock);
890 pthread_mutex_unlock (&reqlock);
891}
278 892
279 case REQ_OPEN: req->result = open (req->dataptr, req->fd, req->mode); break; 893static void atfork_child (void)
280 case REQ_CLOSE: req->result = close (req->fd); break; 894{
281 case REQ_UNLINK: req->result = unlink (req->dataptr); break; 895 aio_req prv;
282 896
283 case REQ_FSYNC: req->result = fsync (req->fd); break; 897 started = 0;
284 case REQ_FDATASYNC: req->result = fdatasync (req->fd); break;
285 898
286 case REQ_QUIT: 899 while (reqs)
287 write (respipe[1], (void *)&req, sizeof (req));
288 return 0;
289
290 default:
291 req->result = ENOSYS;
292 break;
293 }
294
295 req->errorno = errno;
296 write (respipe[1], (void *)&req, sizeof (req));
297 } 900 {
901 prv = reqs;
902 reqs = prv->next;
903 req_free (prv);
904 }
298 905
299 return 0; 906 reqs = reqe = 0;
300} 907
908 while (ress)
909 {
910 prv = ress;
911 ress = prv->next;
912 req_free (prv);
913 }
914
915 ress = rese = 0;
301 916
917 close (respipe [0]);
918 close (respipe [1]);
919 create_pipe ();
920
921 atfork_parent ();
922}
923
924#define dREQ \
925 aio_req req; \
926 \
927 if (SvOK (callback) && !SvROK (callback)) \
928 croak ("callback must be undef or of reference type"); \
929 \
930 Newz (0, req, 1, aio_cb); \
931 if (!req) \
932 croak ("out of memory during aio_req allocation"); \
933 \
934 req->callback = newSVsv (callback)
935
936#define REQ_SEND \
937 req_send (req); \
938 \
939 if (GIMME_V != G_VOID) \
940 XPUSHs (req_sv (req, AIO_REQ_KLASS));
941
302MODULE = IO::AIO PACKAGE = IO::AIO 942MODULE = IO::AIO PACKAGE = IO::AIO
303 943
944PROTOTYPES: ENABLE
945
304BOOT: 946BOOT:
305{ 947{
306 if (pipe (reqpipe) || pipe (respipe)) 948 HV *stash = gv_stashpv ("IO::AIO", 1);
307 croak ("unable to initialize request or result pipe"); 949 newCONSTSUB (stash, "EXDEV", newSViv (EXDEV));
950 newCONSTSUB (stash, "O_RDONLY", newSViv (O_RDONLY));
951 newCONSTSUB (stash, "O_WRONLY", newSViv (O_WRONLY));
308 952
309 if (fcntl (reqpipe[1], F_SETFL, O_NONBLOCK)) 953 create_pipe ();
310 croak ("cannot set result pipe to nonblocking mode"); 954 pthread_atfork (atfork_prepare, atfork_parent, atfork_child);
311
312 if (fcntl (respipe[0], F_SETFL, O_NONBLOCK))
313 croak ("cannot set result pipe to nonblocking mode");
314} 955}
315 956
316void 957void
317min_parallel(nthreads) 958min_parallel (nthreads)
318 int nthreads 959 int nthreads
319 PROTOTYPE: $ 960 PROTOTYPE: $
320 CODE:
321 while (nthreads > started)
322 start_thread ();
323 961
324void 962void
325max_parallel(nthreads) 963max_parallel (nthreads)
326 int nthreads 964 int nthreads
327 PROTOTYPE: $ 965 PROTOTYPE: $
966
967int
968max_outstanding (nreqs)
969 int nreqs
970 PROTOTYPE: $
328 CODE: 971 CODE:
329{ 972 RETVAL = max_outstanding;
330 int cur = started; 973 max_outstanding = nreqs;
331 while (cur > nthreads)
332 {
333 end_thread ();
334 cur--;
335 }
336 974
337 while (started > nthreads)
338 {
339 poll_wait ();
340 poll_cb (aTHX);
341 }
342}
343
344void 975void
345aio_open(pathname,flags,mode,callback) 976aio_open (pathname,flags,mode,callback=&PL_sv_undef)
346 SV * pathname 977 SV * pathname
347 int flags 978 int flags
348 int mode 979 int mode
349 SV * callback 980 SV * callback
350 PROTOTYPE: $$$$ 981 PROTOTYPE: $$$;$
351 CODE: 982 PPCODE:
352{ 983{
353 aio_req req; 984 dREQ;
354
355 Newz (0, req, 1, aio_cb);
356
357 if (!req)
358 croak ("out of memory during aio_req allocation");
359 985
360 req->type = REQ_OPEN; 986 req->type = REQ_OPEN;
361 req->data = newSVsv (pathname); 987 req->data = newSVsv (pathname);
362 req->dataptr = SvPV_nolen (req->data); 988 req->dataptr = SvPVbyte_nolen (req->data);
363 req->fd = flags; 989 req->fd = flags;
364 req->mode = mode; 990 req->mode = mode;
365 req->callback = SvREFCNT_inc (callback);
366 991
367 send_req (req); 992 REQ_SEND;
368} 993}
369 994
370void 995void
371aio_close(fh,callback) 996aio_close (fh,callback=&PL_sv_undef)
372 InputStream fh 997 SV * fh
373 SV * callback 998 SV * callback
374 PROTOTYPE: $$ 999 PROTOTYPE: $;$
375 ALIAS: 1000 ALIAS:
376 aio_close = REQ_CLOSE 1001 aio_close = REQ_CLOSE
377 aio_fsync = REQ_FSYNC 1002 aio_fsync = REQ_FSYNC
378 aio_fdatasync = REQ_FDATASYNC 1003 aio_fdatasync = REQ_FDATASYNC
379 CODE: 1004 PPCODE:
1005{
1006 dREQ;
1007
1008 req->type = ix;
1009 req->fh = newSVsv (fh);
1010 req->fd = PerlIO_fileno (IoIFP (sv_2io (fh)));
1011
1012 REQ_SEND (req);
1013}
1014
1015void
1016aio_read (fh,offset,length,data,dataoffset,callback=&PL_sv_undef)
1017 SV * fh
1018 UV offset
1019 UV length
1020 SV * data
1021 UV dataoffset
1022 SV * callback
1023 ALIAS:
1024 aio_read = REQ_READ
1025 aio_write = REQ_WRITE
1026 PROTOTYPE: $$$$$;$
1027 PPCODE:
380{ 1028{
381 aio_req req; 1029 aio_req req;
1030 STRLEN svlen;
1031 char *svptr = SvPVbyte (data, svlen);
382 1032
383 Newz (0, req, 1, aio_cb); 1033 SvUPGRADE (data, SVt_PV);
1034 SvPOK_on (data);
384 1035
385 if (!req) 1036 if (dataoffset < 0)
386 croak ("out of memory during aio_req allocation"); 1037 dataoffset += svlen;
387 1038
388 req->type = ix; 1039 if (dataoffset < 0 || dataoffset > svlen)
389 req->fd = PerlIO_fileno (fh); 1040 croak ("data offset outside of string");
390 req->callback = SvREFCNT_inc (callback);
391 1041
392 send_req (req); 1042 if (ix == REQ_WRITE)
393} 1043 {
394 1044 /* write: check length and adjust. */
395void 1045 if (length < 0 || length + dataoffset > svlen)
396aio_read(fh,offset,length,data,dataoffset,callback) 1046 length = svlen - dataoffset;
397 InputStream fh 1047 }
398 UV offset 1048 else
399 IV length 1049 {
400 SV * data 1050 /* read: grow scalar as necessary */
401 IV dataoffset 1051 svptr = SvGROW (data, length + dataoffset);
402 SV * callback 1052 }
403 PROTOTYPE: $$$$$$
404 CODE:
405 read_write (aTHX_ 0, PerlIO_fileno (fh), offset, length, data, dataoffset, callback);
406
407void
408aio_write(fh,offset,length,data,dataoffset,callback)
409 OutputStream fh
410 UV offset
411 IV length
412 SV * data
413 IV dataoffset
414 SV * callback
415 PROTOTYPE: $$$$$$
416 CODE:
417 read_write (aTHX_ 1, PerlIO_fileno (fh), offset, length, data, dataoffset, callback);
418
419void
420aio_readahead(fh,offset,length,callback)
421 InputStream fh
422 UV offset
423 IV length
424 SV * callback
425 PROTOTYPE: $$$$
426 CODE:
427{
428 aio_req req;
429 1053
430 if (length < 0) 1054 if (length < 0)
431 croak ("length must not be negative"); 1055 croak ("length must not be negative");
432 1056
433 Newz (0, req, 1, aio_cb); 1057 {
1058 dREQ;
434 1059
435 if (!req) 1060 req->type = ix;
436 croak ("out of memory during aio_req allocation"); 1061 req->fh = newSVsv (fh);
1062 req->fd = PerlIO_fileno (ix == REQ_READ ? IoIFP (sv_2io (fh))
1063 : IoOFP (sv_2io (fh)));
1064 req->offset = offset;
1065 req->length = length;
1066 req->data = SvREFCNT_inc (data);
1067 req->dataptr = (char *)svptr + dataoffset;
1068
1069 if (!SvREADONLY (data))
1070 {
1071 SvREADONLY_on (data);
1072 req->data2ptr = (void *)data;
1073 }
1074
1075 REQ_SEND;
1076 }
1077}
1078
1079void
1080aio_sendfile (out_fh,in_fh,in_offset,length,callback=&PL_sv_undef)
1081 SV * out_fh
1082 SV * in_fh
1083 UV in_offset
1084 UV length
1085 SV * callback
1086 PROTOTYPE: $$$$;$
1087 PPCODE:
1088{
1089 dREQ;
1090
1091 req->type = REQ_SENDFILE;
1092 req->fh = newSVsv (out_fh);
1093 req->fd = PerlIO_fileno (IoIFP (sv_2io (out_fh)));
1094 req->fh2 = newSVsv (in_fh);
1095 req->fd2 = PerlIO_fileno (IoIFP (sv_2io (in_fh)));
1096 req->offset = in_offset;
1097 req->length = length;
1098
1099 REQ_SEND;
1100}
1101
1102void
1103aio_readahead (fh,offset,length,callback=&PL_sv_undef)
1104 SV * fh
1105 UV offset
1106 IV length
1107 SV * callback
1108 PROTOTYPE: $$$;$
1109 PPCODE:
1110{
1111 dREQ;
437 1112
438 req->type = REQ_READAHEAD; 1113 req->type = REQ_READAHEAD;
1114 req->fh = newSVsv (fh);
439 req->fd = PerlIO_fileno (fh); 1115 req->fd = PerlIO_fileno (IoIFP (sv_2io (fh)));
440 req->offset = offset; 1116 req->offset = offset;
441 req->length = length; 1117 req->length = length;
442 req->callback = SvREFCNT_inc (callback);
443 1118
444 send_req (req); 1119 REQ_SEND;
445} 1120}
446 1121
447void 1122void
448aio_stat(fh_or_path,callback) 1123aio_stat (fh_or_path,callback=&PL_sv_undef)
449 SV * fh_or_path 1124 SV * fh_or_path
450 SV * callback 1125 SV * callback
451 PROTOTYPE: $$
452 ALIAS: 1126 ALIAS:
1127 aio_stat = REQ_STAT
453 aio_lstat = 1 1128 aio_lstat = REQ_LSTAT
454 CODE: 1129 PPCODE:
455{ 1130{
456 aio_req req; 1131 dREQ;
457
458 Newz (0, req, 1, aio_cb);
459
460 if (!req)
461 croak ("out of memory during aio_req allocation");
462 1132
463 New (0, req->statdata, 1, Stat_t); 1133 New (0, req->statdata, 1, Stat_t);
464
465 if (!req->statdata) 1134 if (!req->statdata)
1135 {
1136 req_free (req);
466 croak ("out of memory during aio_req->statdata allocation"); 1137 croak ("out of memory during aio_req->statdata allocation");
1138 }
467 1139
468 if (SvPOK (fh_or_path)) 1140 if (SvPOK (fh_or_path))
469 { 1141 {
470 req->type = ix ? REQ_LSTAT : REQ_STAT; 1142 req->type = ix;
471 req->data = newSVsv (fh_or_path); 1143 req->data = newSVsv (fh_or_path);
472 req->dataptr = SvPV_nolen (req->data); 1144 req->dataptr = SvPVbyte_nolen (req->data);
473 } 1145 }
474 else 1146 else
475 { 1147 {
476 req->type = REQ_FSTAT; 1148 req->type = REQ_FSTAT;
1149 req->fh = newSVsv (fh_or_path);
477 req->fd = PerlIO_fileno (IoIFP (sv_2io (fh_or_path))); 1150 req->fd = PerlIO_fileno (IoIFP (sv_2io (fh_or_path)));
478 } 1151 }
479 1152
480 req->callback = SvREFCNT_inc (callback); 1153 REQ_SEND;
481
482 send_req (req);
483} 1154}
484 1155
485void 1156void
486aio_unlink(pathname,callback) 1157aio_unlink (pathname,callback=&PL_sv_undef)
487 SV * pathname 1158 SV * pathname
488 SV * callback 1159 SV * callback
1160 ALIAS:
1161 aio_unlink = REQ_UNLINK
1162 aio_rmdir = REQ_RMDIR
1163 aio_readdir = REQ_READDIR
1164 PPCODE:
1165{
1166 dREQ;
1167
1168 req->type = ix;
1169 req->data = newSVsv (pathname);
1170 req->dataptr = SvPVbyte_nolen (req->data);
1171
1172 REQ_SEND;
1173}
1174
1175void
1176aio_link (oldpath,newpath,callback=&PL_sv_undef)
1177 SV * oldpath
1178 SV * newpath
1179 SV * callback
1180 ALIAS:
1181 aio_link = REQ_LINK
1182 aio_symlink = REQ_SYMLINK
1183 aio_rename = REQ_RENAME
1184 PPCODE:
1185{
1186 dREQ;
1187
1188 req->type = ix;
1189 req->fh = newSVsv (oldpath);
1190 req->data2ptr = SvPVbyte_nolen (req->fh);
1191 req->data = newSVsv (newpath);
1192 req->dataptr = SvPVbyte_nolen (req->data);
1193
1194 REQ_SEND;
1195}
1196
1197void
1198aio_sleep (delay,callback=&PL_sv_undef)
1199 double delay
1200 SV * callback
1201 PPCODE:
1202{
1203 dREQ;
1204
1205 req->type = REQ_SLEEP;
1206 req->fd = delay < 0. ? 0 : delay;
1207 req->fd2 = delay < 0. ? 0 : 1000. * (delay - req->fd);
1208
1209 REQ_SEND;
1210}
1211
1212void
1213aio_group (callback=&PL_sv_undef)
1214 SV * callback
489 PROTOTYPE: $$ 1215 PROTOTYPE: ;$
1216 PPCODE:
1217{
1218 dREQ;
1219 req->type = REQ_GROUP;
1220 req_send (req);
1221 XPUSHs (req_sv (req, AIO_GRP_KLASS));
1222}
1223
1224void
1225aio_nop (callback=&PL_sv_undef)
1226 SV * callback
1227 PPCODE:
1228{
1229 dREQ;
1230
1231 req->type = REQ_NOP;
1232
1233 REQ_SEND;
1234}
1235
1236void
1237flush ()
1238 PROTOTYPE:
490 CODE: 1239 CODE:
491{ 1240 while (nreqs)
492 aio_req req; 1241 {
493 1242 poll_wait ();
494 Newz (0, req, 1, aio_cb); 1243 poll_cb ();
495 1244 }
496 if (!req) 1245
497 croak ("out of memory during aio_req allocation"); 1246void
498 1247poll()
499 req->type = REQ_UNLINK; 1248 PROTOTYPE:
500 req->data = newSVsv (pathname); 1249 CODE:
501 req->dataptr = SvPV_nolen (req->data); 1250 if (nreqs)
502 req->callback = SvREFCNT_inc (callback); 1251 {
503 1252 poll_wait ();
504 send_req (req); 1253 poll_cb ();
505} 1254 }
506 1255
507int 1256int
508poll_fileno() 1257poll_fileno()
509 PROTOTYPE: 1258 PROTOTYPE:
510 CODE: 1259 CODE:
511 RETVAL = respipe[0]; 1260 RETVAL = respipe [0];
512 OUTPUT: 1261 OUTPUT:
513 RETVAL 1262 RETVAL
514 1263
515int 1264int
516poll_cb(...) 1265poll_cb(...)
517 PROTOTYPE: 1266 PROTOTYPE:
518 CODE: 1267 CODE:
519 RETVAL = poll_cb (aTHX); 1268 RETVAL = poll_cb ();
520 OUTPUT: 1269 OUTPUT:
521 RETVAL 1270 RETVAL
522 1271
523void 1272void
524poll_wait() 1273poll_wait()
525 PROTOTYPE: 1274 PROTOTYPE:
526 CODE: 1275 CODE:
1276 if (nreqs)
527 poll_wait (); 1277 poll_wait ();
528 1278
529int 1279int
530nreqs() 1280nreqs()
531 PROTOTYPE: 1281 PROTOTYPE:
532 CODE: 1282 CODE:
533 RETVAL = nreqs; 1283 RETVAL = nreqs;
534 OUTPUT: 1284 OUTPUT:
535 RETVAL 1285 RETVAL
536 1286
1287PROTOTYPES: DISABLE
1288
1289MODULE = IO::AIO PACKAGE = IO::AIO::REQ
1290
1291void
1292cancel (aio_req_ornot req)
1293 PROTOTYPE:
1294 CODE:
1295 req_cancel (req);
1296
1297void
1298cb (aio_req_ornot req, SV *callback=&PL_sv_undef)
1299 CODE:
1300 SvREFCNT_dec (req->callback);
1301 req->callback = newSVsv (callback);
1302
1303MODULE = IO::AIO PACKAGE = IO::AIO::GRP
1304
1305void
1306add (aio_req grp, ...)
1307 PPCODE:
1308{
1309 int i;
1310 aio_req req;
1311
1312 if (grp->fd == 2)
1313 croak ("cannot add requests to IO::AIO::GRP after the group finished");
1314
1315 for (i = 1; i < items; ++i )
1316 {
1317 if (GIMME_V != G_VOID)
1318 XPUSHs (sv_2mortal (newSVsv (ST (i))));
1319
1320 req = SvAIO_REQ (ST (i));
1321
1322 if (req)
1323 {
1324 ++grp->length;
1325 req->grp = grp;
1326
1327 req->grp_prev = 0;
1328 req->grp_next = grp->grp_first;
1329
1330 if (grp->grp_first)
1331 grp->grp_first->grp_prev = req;
1332
1333 grp->grp_first = req;
1334 }
1335 }
1336}
1337
1338void
1339result (aio_req grp, ...)
1340 CODE:
1341{
1342 int i;
1343 AV *av = newAV ();
1344
1345 for (i = 1; i < items; ++i )
1346 av_push (av, newSVsv (ST (i)));
1347
1348 SvREFCNT_dec (grp->data);
1349 grp->data = (SV *)av;
1350}
1351
1352void
1353feed_limit (aio_req grp, int limit)
1354 CODE:
1355 grp->fd2 = limit;
1356 aio_grp_feed (grp);
1357
1358void
1359feed (aio_req grp, SV *callback=&PL_sv_undef)
1360 CODE:
1361{
1362 SvREFCNT_dec (grp->fh2);
1363 grp->fh2 = newSVsv (callback);
1364
1365 if (grp->fd2 <= 0)
1366 grp->fd2 = 2;
1367
1368 aio_grp_feed (grp);
1369}
1370

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines