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.43 by root, Sat Oct 21 23:06:04 2006 UTC vs.
Revision 1.63 by root, Mon Oct 23 23:48:31 2006 UTC

1#if __linux
2# define _GNU_SOURCE
3#endif
4
1#define _REENTRANT 1 5#define _REENTRANT 1
6
2#include <errno.h> 7#include <errno.h>
3 8
4#include "EXTERN.h" 9#include "EXTERN.h"
5#include "perl.h" 10#include "perl.h"
6#include "XSUB.h" 11#include "XSUB.h"
… …
9 14
10#include <pthread.h> 15#include <pthread.h>
11 16
12#include <stddef.h> 17#include <stddef.h>
13#include <errno.h> 18#include <errno.h>
19#include <sys/time.h>
20#include <sys/select.h>
14#include <sys/types.h> 21#include <sys/types.h>
15#include <sys/stat.h> 22#include <sys/stat.h>
16#include <limits.h> 23#include <limits.h>
17#include <unistd.h> 24#include <unistd.h>
18#include <fcntl.h> 25#include <fcntl.h>
… …
53 REQ_STAT, REQ_LSTAT, REQ_FSTAT, 60 REQ_STAT, REQ_LSTAT, REQ_FSTAT,
54 REQ_FSYNC, REQ_FDATASYNC, 61 REQ_FSYNC, REQ_FDATASYNC,
55 REQ_UNLINK, REQ_RMDIR, REQ_RENAME, 62 REQ_UNLINK, REQ_RMDIR, REQ_RENAME,
56 REQ_READDIR, 63 REQ_READDIR,
57 REQ_LINK, REQ_SYMLINK, 64 REQ_LINK, REQ_SYMLINK,
65 REQ_GROUP, REQ_NOP,
66 REQ_SLEEP,
58}; 67};
59 68
60#define AIO_CB_KLASS "IO::AIO::CB" 69#define AIO_REQ_KLASS "IO::AIO::REQ"
70#define AIO_GRP_KLASS "IO::AIO::GRP"
61 71
62typedef struct aio_cb 72typedef struct aio_cb
63{ 73{
64 struct aio_cb *grp_prev, *grp_next;
65 struct aio_grp *grp;
66
67 struct aio_cb *volatile next; 74 struct aio_cb *volatile next;
68
69 SV *self; /* the perl counterpart of this request, if any */
70 75
71 SV *data, *callback; 76 SV *data, *callback;
72 SV *fh, *fh2; 77 SV *fh, *fh2;
73 void *dataptr, *data2ptr; 78 void *dataptr, *data2ptr;
74 Stat_t *statdata; 79 Stat_t *statdata;
75 off_t offset; 80 off_t offset;
76 size_t length; 81 size_t length;
77 ssize_t result; 82 ssize_t result;
78 83
84 STRLEN dataoffset;
79 int type; 85 int type;
80 int fd, fd2; 86 int fd, fd2;
81 int errorno; 87 int errorno;
82 STRLEN dataoffset;
83 mode_t mode; /* open */ 88 mode_t mode; /* open */
89
84 unsigned char cancelled; 90 unsigned char flags;
91 unsigned char pri;
92
93 SV *self; /* the perl counterpart of this request, if any */
94 struct aio_cb *grp, *grp_prev, *grp_next, *grp_first;
85} aio_cb; 95} aio_cb;
96
97enum {
98 FLAG_CANCELLED = 0x01,
99};
86 100
87typedef aio_cb *aio_req; 101typedef aio_cb *aio_req;
88typedef aio_cb *aio_req_ornot; 102typedef aio_cb *aio_req_ornot;
103
104enum {
105 PRI_MIN = -4,
106 PRI_MAX = 4,
107
108 DEFAULT_PRI = 0,
109 PRI_BIAS = -PRI_MIN,
110};
111
112static int next_pri = DEFAULT_PRI + PRI_BIAS;
89 113
90static int started, wanted; 114static int started, wanted;
91static volatile int nreqs; 115static volatile int nreqs;
92static int max_outstanding = 1<<30; 116static int max_outstanding = 1<<30;
93static int respipe [2]; 117static int respipe [2];
94 118
119#if __linux && defined (PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP)
120# define AIO_MUTEX_INIT PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
121#else
122# define AIO_MUTEX_INIT PTHREAD_MUTEX_INITIALIZER
123#endif
124
95static pthread_mutex_t reslock = PTHREAD_MUTEX_INITIALIZER; 125static pthread_mutex_t reslock = AIO_MUTEX_INIT;
96static pthread_mutex_t reqlock = PTHREAD_MUTEX_INITIALIZER; 126static pthread_mutex_t reqlock = AIO_MUTEX_INIT;
97static pthread_cond_t reqwait = PTHREAD_COND_INITIALIZER; 127static pthread_cond_t reqwait = PTHREAD_COND_INITIALIZER;
98 128
99static volatile aio_req reqs, reqe; /* queue start, queue end */ 129static volatile aio_req reqs, reqe; /* queue start, queue end */
100static volatile aio_req ress, rese; /* queue start, queue end */ 130static volatile aio_req ress, rese; /* queue start, queue end */
101 131
102typedef struct aio_grp 132static void req_invoke (aio_req req);
103{ 133static void req_free (aio_req req);
104 struct aio_cb *first, *last;
105 SV *callback;
106 int busycount;
107} aio_grp;
108 134
109static void aio_grp_begin (aio_grp *grp) 135/* must be called at most once */
136static SV *req_sv (aio_req req, const char *klass)
110{ 137{
111 ++grp->busycount; 138 if (!req->self)
112} 139 {
140 req->self = (SV *)newHV ();
141 sv_magic (req->self, 0, PERL_MAGIC_ext, (char *)req, 0);
142 }
113 143
144 return sv_2mortal (sv_bless (newRV_inc (req->self), gv_stashpv (klass, 1)));
145}
146
147static aio_req SvAIO_REQ (SV *sv)
148{
149 MAGIC *mg;
150
151 if (!sv_derived_from (sv, AIO_REQ_KLASS) || !SvROK (sv))
152 croak ("object of class " AIO_REQ_KLASS " expected");
153
154 mg = mg_find (SvRV (sv), PERL_MAGIC_ext);
155
156 return mg ? (aio_req)mg->mg_ptr : 0;
157}
158
114static void aio_grp_end (aio_grp *grp) 159static void aio_grp_feed (aio_req grp)
115{ 160{
116 --grp->busycount; 161 while (grp->length < grp->fd2 && !(grp->flags & FLAG_CANCELLED))
162 {
163 int old_len = grp->length;
117 164
118 if (grp->busycount) 165 if (grp->fh2 && SvOK (grp->fh2))
166 {
167 dSP;
168
169 ENTER;
170 SAVETMPS;
171 PUSHMARK (SP);
172 XPUSHs (req_sv (grp, AIO_GRP_KLASS));
173 PUTBACK;
174 call_sv (grp->fh2, G_VOID | G_EVAL);
175 SPAGAIN;
176 FREETMPS;
177 LEAVE;
178 }
179
180 /* stop if no progress has been made */
181 if (old_len == grp->length)
182 {
183 SvREFCNT_dec (grp->fh2);
184 grp->fh2 = 0;
185 break;
186 }
187 }
188}
189
190static void aio_grp_dec (aio_req grp)
191{
192 --grp->length;
193
194 /* call feeder, if applicable */
195 aio_grp_feed (grp);
196
197 /* finish, if done */
198 if (!grp->length && grp->fd)
199 {
200 req_invoke (grp);
201 req_free (grp);
202 }
203}
204
205static void poll_wait ()
206{
207 fd_set rfd;
208
209 while (nreqs)
210 {
211 aio_req req;
212 pthread_mutex_lock (&reslock);
213 req = ress;
214 pthread_mutex_unlock (&reslock);
215
216 if (req)
217 return;
218
219 FD_ZERO(&rfd);
220 FD_SET(respipe [0], &rfd);
221
222 select (respipe [0] + 1, &rfd, 0, 0, 0);
223 }
224}
225
226static void req_invoke (aio_req req)
227{
228 dSP;
229 int errorno = errno;
230
231 if (req->flags & FLAG_CANCELLED || !SvOK (req->callback))
119 return; 232 return;
120 233
121 SvREFCNT_dec (grp->callback); 234 errno = req->errorno;
122 grp->callback = 0;
123}
124 235
125static aio_grp *aio_grp_new () 236 ENTER;
126{ 237 SAVETMPS;
127 aio_grp *grp; 238 PUSHMARK (SP);
239 EXTEND (SP, 1);
128 240
129 Newz (0, grp, 1, aio_grp); 241 switch (req->type)
130 aio_grp_begin (grp); 242 {
243 case REQ_READDIR:
244 {
245 SV *rv = &PL_sv_undef;
131 246
132 return grp; 247 if (req->result >= 0)
133} 248 {
249 char *buf = req->data2ptr;
250 AV *av = newAV ();
134 251
135/* must be called at most once */ 252 while (req->result)
136static SV *req_sv (aio_req req) 253 {
137{ 254 SV *sv = newSVpv (buf, 0);
138 req->self = (SV *)newHV ();
139 sv_magic (req->self, 0, PERL_MAGIC_ext, (char *)req, 0);
140 255
141 return sv_bless (newRV_noinc (req->self), gv_stashpv (AIO_CB_KLASS, 1)); 256 av_push (av, sv);
142} 257 buf += SvCUR (sv) + 1;
258 req->result--;
259 }
143 260
144static aio_req SvAIO_REQ (SV *sv) 261 rv = sv_2mortal (newRV_noinc ((SV *)av));
145{ 262 }
146 if (!sv_derived_from (sv, AIO_CB_KLASS) || !SvROK (sv))
147 croak ("object of class " AIO_CB_KLASS " expected");
148 263
149 MAGIC *mg = mg_find (SvRV (sv), PERL_MAGIC_ext); 264 PUSHs (rv);
265 }
266 break;
150 267
151 return mg ? (aio_req)mg->mg_ptr : 0; 268 case REQ_OPEN:
269 {
270 /* convert fd to fh */
271 SV *fh;
272
273 PUSHs (sv_2mortal (newSViv (req->result)));
274 PUTBACK;
275 call_pv ("IO::AIO::_fd2fh", G_SCALAR | G_EVAL);
276 SPAGAIN;
277
278 fh = SvREFCNT_inc (POPs);
279
280 PUSHMARK (SP);
281 XPUSHs (sv_2mortal (fh));
282 }
283 break;
284
285 case REQ_GROUP:
286 req->fd = 2; /* mark group as finished */
287
288 if (req->data)
289 {
290 int i;
291 AV *av = (AV *)req->data;
292
293 EXTEND (SP, AvFILL (av) + 1);
294 for (i = 0; i <= AvFILL (av); ++i)
295 PUSHs (*av_fetch (av, i, 0));
296 }
297 break;
298
299 case REQ_NOP:
300 case REQ_SLEEP:
301 break;
302
303 default:
304 PUSHs (sv_2mortal (newSViv (req->result)));
305 break;
306 }
307
308
309 PUTBACK;
310 call_sv (req->callback, G_VOID | G_EVAL);
311 SPAGAIN;
312
313 FREETMPS;
314 LEAVE;
315
316 errno = errorno;
317
318 if (SvTRUE (ERRSV))
319 {
320 req_free (req);
321 croak (0);
322 }
152} 323}
153 324
154static void req_free (aio_req req) 325static void req_free (aio_req req)
155{ 326{
327 if (req->grp)
328 {
329 aio_req grp = req->grp;
330
331 /* unlink request */
332 if (req->grp_next) req->grp_next->grp_prev = req->grp_prev;
333 if (req->grp_prev) req->grp_prev->grp_next = req->grp_next;
334
335 if (grp->grp_first == req)
336 grp->grp_first = req->grp_next;
337
338 aio_grp_dec (grp);
339 }
340
156 if (req->self) 341 if (req->self)
157 { 342 {
158 sv_unmagic (req->self, PERL_MAGIC_ext); 343 sv_unmagic (req->self, PERL_MAGIC_ext);
159 SvREFCNT_dec (req->self); 344 SvREFCNT_dec (req->self);
160 } 345 }
161 346
162 if (req->data)
163 SvREFCNT_dec (req->data); 347 SvREFCNT_dec (req->data);
164
165 if (req->fh)
166 SvREFCNT_dec (req->fh); 348 SvREFCNT_dec (req->fh);
167
168 if (req->fh2)
169 SvREFCNT_dec (req->fh2); 349 SvREFCNT_dec (req->fh2);
170
171 if (req->statdata)
172 Safefree (req->statdata);
173
174 if (req->callback)
175 SvREFCNT_dec (req->callback); 350 SvREFCNT_dec (req->callback);
351 Safefree (req->statdata);
176 352
177 if (req->type == REQ_READDIR && req->result >= 0) 353 if (req->type == REQ_READDIR && req->result >= 0)
178 free (req->data2ptr); 354 free (req->data2ptr);
179 355
180 Safefree (req); 356 Safefree (req);
181} 357}
182 358
183static void 359static void req_cancel (aio_req req)
184poll_wait ()
185{ 360{
186 if (nreqs && !ress) 361 req->flags |= FLAG_CANCELLED;
187 {
188 fd_set rfd;
189 FD_ZERO(&rfd);
190 FD_SET(respipe [0], &rfd);
191 362
192 select (respipe [0] + 1, &rfd, 0, 0, 0); 363 if (req->type == REQ_GROUP)
193 } 364 {
194} 365 aio_req sub;
195 366
196static int 367 for (sub = req->grp_first; sub; sub = sub->grp_next)
197poll_cb () 368 req_cancel (sub);
369 }
370}
371
372static int poll_cb ()
198{ 373{
199 dSP; 374 dSP;
200 int count = 0; 375 int count = 0;
201 int do_croak = 0; 376 int do_croak = 0;
202 aio_req req; 377 aio_req req;
… …
224 pthread_mutex_unlock (&reslock); 399 pthread_mutex_unlock (&reslock);
225 400
226 if (!req) 401 if (!req)
227 break; 402 break;
228 403
229 nreqs--; 404 --nreqs;
230 405
231 if (req->type == REQ_QUIT) 406 if (req->type == REQ_QUIT)
232 started--; 407 started--;
408 else if (req->type == REQ_GROUP && req->length)
409 {
410 req->fd = 1; /* mark request as delayed */
411 continue;
412 }
233 else 413 else
234 { 414 {
235 int errorno = errno;
236 errno = req->errorno;
237
238 if (req->type == REQ_READ) 415 if (req->type == REQ_READ)
239 SvCUR_set (req->data, req->dataoffset + (req->result > 0 ? req->result : 0)); 416 SvCUR_set (req->data, req->dataoffset + (req->result > 0 ? req->result : 0));
240 417
241 if (req->data2ptr && (req->type == REQ_READ || req->type == REQ_WRITE)) 418 if (req->data2ptr && (req->type == REQ_READ || req->type == REQ_WRITE))
242 SvREADONLY_off (req->data); 419 SvREADONLY_off (req->data);
… …
246 PL_laststype = req->type == REQ_LSTAT ? OP_LSTAT : OP_STAT; 423 PL_laststype = req->type == REQ_LSTAT ? OP_LSTAT : OP_STAT;
247 PL_laststatval = req->result; 424 PL_laststatval = req->result;
248 PL_statcache = *(req->statdata); 425 PL_statcache = *(req->statdata);
249 } 426 }
250 427
251 ENTER; 428 req_invoke (req);
252 PUSHMARK (SP);
253 429
254 if (req->type == REQ_READDIR)
255 {
256 SV *rv = &PL_sv_undef;
257
258 if (req->result >= 0)
259 {
260 char *buf = req->data2ptr;
261 AV *av = newAV ();
262
263 while (req->result)
264 {
265 SV *sv = newSVpv (buf, 0);
266
267 av_push (av, sv);
268 buf += SvCUR (sv) + 1;
269 req->result--;
270 }
271
272 rv = sv_2mortal (newRV_noinc ((SV *)av));
273 }
274
275 XPUSHs (rv);
276 }
277 else
278 {
279 XPUSHs (sv_2mortal (newSViv (req->result)));
280
281 if (req->type == REQ_OPEN)
282 {
283 /* convert fd to fh */
284 SV *fh;
285
286 PUTBACK;
287 call_pv ("IO::AIO::_fd2fh", G_SCALAR | G_EVAL);
288 SPAGAIN;
289
290 fh = SvREFCNT_inc (POPs);
291
292 PUSHMARK (SP);
293 XPUSHs (sv_2mortal (fh));
294 }
295 }
296
297 if (SvOK (req->callback) && !req->cancelled)
298 {
299 PUTBACK;
300 call_sv (req->callback, G_VOID | G_EVAL);
301 SPAGAIN;
302
303 if (SvTRUE (ERRSV))
304 {
305 req_free (req);
306 croak (0);
307 }
308 }
309
310 LEAVE;
311
312 errno = errorno;
313 count++; 430 count++;
314 } 431 }
315 432
316 req_free (req); 433 req_free (req);
317 } 434 }
… …
319 return count; 436 return count;
320} 437}
321 438
322static void *aio_proc(void *arg); 439static void *aio_proc(void *arg);
323 440
324static void
325start_thread (void) 441static void start_thread (void)
326{ 442{
327 sigset_t fullsigset, oldsigset; 443 sigset_t fullsigset, oldsigset;
328 pthread_t tid; 444 pthread_t tid;
329 pthread_attr_t attr; 445 pthread_attr_t attr;
330 446
… …
339 started++; 455 started++;
340 456
341 sigprocmask (SIG_SETMASK, &oldsigset, 0); 457 sigprocmask (SIG_SETMASK, &oldsigset, 0);
342} 458}
343 459
344static void
345req_send (aio_req req) 460static void req_send (aio_req req)
346{ 461{
347 while (started < wanted && nreqs >= started) 462 while (started < wanted && nreqs >= started)
348 start_thread (); 463 start_thread ();
349 464
350 nreqs++; 465 ++nreqs;
351 466
352 pthread_mutex_lock (&reqlock); 467 pthread_mutex_lock (&reqlock);
353 468
354 req->next = 0; 469 req->next = 0;
355 470
… …
374 489
375 poll_wait (); 490 poll_wait ();
376 } 491 }
377} 492}
378 493
379static void 494static void end_thread (void)
380end_thread (void)
381{ 495{
382 aio_req req; 496 aio_req req;
383 Newz (0, req, 1, aio_cb); 497 Newz (0, req, 1, aio_cb);
384 req->type = REQ_QUIT; 498 req->type = REQ_QUIT;
385 499
… …
436 * normal read/write by using a mutex. slows down execution a lot, 550 * normal read/write by using a mutex. slows down execution a lot,
437 * but that's your problem, not mine. 551 * but that's your problem, not mine.
438 */ 552 */
439static pthread_mutex_t preadwritelock = PTHREAD_MUTEX_INITIALIZER; 553static pthread_mutex_t preadwritelock = PTHREAD_MUTEX_INITIALIZER;
440 554
441static ssize_t 555static ssize_t pread (int fd, void *buf, size_t count, off_t offset)
442pread (int fd, void *buf, size_t count, off_t offset)
443{ 556{
444 ssize_t res; 557 ssize_t res;
445 off_t ooffset; 558 off_t ooffset;
446 559
447 pthread_mutex_lock (&preadwritelock); 560 pthread_mutex_lock (&preadwritelock);
… …
452 pthread_mutex_unlock (&preadwritelock); 565 pthread_mutex_unlock (&preadwritelock);
453 566
454 return res; 567 return res;
455} 568}
456 569
457static ssize_t
458pwrite (int fd, void *buf, size_t count, off_t offset) 570static ssize_t pwrite (int fd, void *buf, size_t count, off_t offset)
459{ 571{
460 ssize_t res; 572 ssize_t res;
461 off_t ooffset; 573 off_t ooffset;
462 574
463 pthread_mutex_lock (&preadwritelock); 575 pthread_mutex_lock (&preadwritelock);
… …
476#endif 588#endif
477 589
478#if !HAVE_READAHEAD 590#if !HAVE_READAHEAD
479# define readahead aio_readahead 591# define readahead aio_readahead
480 592
481static ssize_t
482readahead (int fd, off_t offset, size_t count) 593static ssize_t readahead (int fd, off_t offset, size_t count)
483{ 594{
484 char readahead_buf[4096]; 595 char readahead_buf[4096];
485 596
486 while (count > 0) 597 while (count > 0)
487 { 598 {
… …
499#if !HAVE_READDIR_R 610#if !HAVE_READDIR_R
500# define readdir_r aio_readdir_r 611# define readdir_r aio_readdir_r
501 612
502static pthread_mutex_t readdirlock = PTHREAD_MUTEX_INITIALIZER; 613static pthread_mutex_t readdirlock = PTHREAD_MUTEX_INITIALIZER;
503 614
504static int
505readdir_r (DIR *dirp, struct dirent *ent, struct dirent **res) 615static int readdir_r (DIR *dirp, struct dirent *ent, struct dirent **res)
506{ 616{
507 struct dirent *e; 617 struct dirent *e;
508 int errorno; 618 int errorno;
509 619
510 pthread_mutex_lock (&readdirlock); 620 pthread_mutex_lock (&readdirlock);
… …
526 return e ? 0 : -1; 636 return e ? 0 : -1;
527} 637}
528#endif 638#endif
529 639
530/* sendfile always needs emulation */ 640/* sendfile always needs emulation */
531static ssize_t
532sendfile_ (int ofd, int ifd, off_t offset, size_t count) 641static ssize_t sendfile_ (int ofd, int ifd, off_t offset, size_t count)
533{ 642{
534 ssize_t res; 643 ssize_t res;
535 644
536 if (!count) 645 if (!count)
537 return 0; 646 return 0;
… …
619 728
620 return res; 729 return res;
621} 730}
622 731
623/* read a full directory */ 732/* read a full directory */
624static int
625scandir_ (const char *path, void **namesp) 733static int scandir_ (const char *path, void **namesp)
626{ 734{
627 DIR *dirp = opendir (path); 735 DIR *dirp = opendir (path);
628 union 736 union
629 { 737 {
630 struct dirent d; 738 struct dirent d;
… …
684 return res; 792 return res;
685} 793}
686 794
687/*****************************************************************************/ 795/*****************************************************************************/
688 796
689static void *
690aio_proc (void *thr_arg) 797static void *aio_proc (void *thr_arg)
691{ 798{
692 aio_req req; 799 aio_req req;
693 int type; 800 int type;
694 801
695 do 802 do
… …
713 } 820 }
714 821
715 pthread_mutex_unlock (&reqlock); 822 pthread_mutex_unlock (&reqlock);
716 823
717 errno = 0; /* strictly unnecessary */ 824 errno = 0; /* strictly unnecessary */
825 type = req->type; /* remember type for QUIT check */
718 826
719 if (!req->cancelled) 827 if (!(req->flags & FLAG_CANCELLED))
720 switch (req->type) 828 switch (type)
721 { 829 {
722 case REQ_READ: req->result = pread (req->fd, req->dataptr, req->length, req->offset); break; 830 case REQ_READ: req->result = pread (req->fd, req->dataptr, req->length, req->offset); break;
723 case REQ_WRITE: req->result = pwrite (req->fd, req->dataptr, req->length, req->offset); break; 831 case REQ_WRITE: req->result = pwrite (req->fd, req->dataptr, req->length, req->offset); break;
724 832
725 case REQ_READAHEAD: req->result = readahead (req->fd, req->offset, req->length); break; 833 case REQ_READAHEAD: req->result = readahead (req->fd, req->offset, req->length); break;
… …
739 847
740 case REQ_FDATASYNC: req->result = fdatasync (req->fd); break; 848 case REQ_FDATASYNC: req->result = fdatasync (req->fd); break;
741 case REQ_FSYNC: req->result = fsync (req->fd); break; 849 case REQ_FSYNC: req->result = fsync (req->fd); break;
742 case REQ_READDIR: req->result = scandir_ (req->dataptr, &req->data2ptr); break; 850 case REQ_READDIR: req->result = scandir_ (req->dataptr, &req->data2ptr); break;
743 851
852 case REQ_SLEEP:
853 {
854 struct timeval tv;
855
856 tv.tv_sec = req->fd;
857 tv.tv_usec = req->fd2;
858
859 req->result = select (0, 0, 0, 0, &tv);
860 }
861
862 case REQ_GROUP:
863 case REQ_NOP:
744 case REQ_QUIT: 864 case REQ_QUIT:
745 break; 865 break;
746 866
747 default: 867 default:
748 req->result = ENOSYS; 868 req->result = ENOSYS;
… …
832 atfork_parent (); 952 atfork_parent ();
833} 953}
834 954
835#define dREQ \ 955#define dREQ \
836 aio_req req; \ 956 aio_req req; \
957 int req_pri = next_pri; \
958 next_pri = DEFAULT_PRI + PRI_BIAS; \
837 \ 959 \
838 if (SvOK (callback) && !SvROK (callback)) \ 960 if (SvOK (callback) && !SvROK (callback)) \
839 croak ("callback must be undef or of reference type"); \ 961 croak ("callback must be undef or of reference type"); \
840 \ 962 \
841 Newz (0, req, 1, aio_cb); \ 963 Newz (0, req, 1, aio_cb); \
842 if (!req) \ 964 if (!req) \
843 croak ("out of memory during aio_req allocation"); \ 965 croak ("out of memory during aio_req allocation"); \
844 \ 966 \
845 req->callback = newSVsv (callback) 967 req->callback = newSVsv (callback); \
968 req->pri = req_pri
846 969
847#define REQ_SEND \ 970#define REQ_SEND \
848 req_send (req); \ 971 req_send (req); \
849 \ 972 \
850 if (GIMME_V != G_VOID) \ 973 if (GIMME_V != G_VOID) \
851 XPUSHs (req_sv (req)); 974 XPUSHs (req_sv (req, AIO_REQ_KLASS));
852 975
853MODULE = IO::AIO PACKAGE = IO::AIO 976MODULE = IO::AIO PACKAGE = IO::AIO
854 977
855PROTOTYPES: ENABLE 978PROTOTYPES: ENABLE
856 979
… …
1103 req->dataptr = SvPVbyte_nolen (req->data); 1226 req->dataptr = SvPVbyte_nolen (req->data);
1104 1227
1105 REQ_SEND; 1228 REQ_SEND;
1106} 1229}
1107 1230
1231void
1232aio_sleep (delay,callback=&PL_sv_undef)
1233 double delay
1234 SV * callback
1235 PPCODE:
1236{
1237 dREQ;
1238
1239 req->type = REQ_SLEEP;
1240 req->fd = delay < 0. ? 0 : delay;
1241 req->fd2 = delay < 0. ? 0 : 1000. * (delay - req->fd);
1242
1243 REQ_SEND;
1244}
1245
1246void
1247aio_group (callback=&PL_sv_undef)
1248 SV * callback
1249 PROTOTYPE: ;$
1250 PPCODE:
1251{
1252 dREQ;
1253
1254 req->type = REQ_GROUP;
1255 req_send (req);
1256
1257 XPUSHs (req_sv (req, AIO_GRP_KLASS));
1258}
1259
1260void
1261aio_nop (callback=&PL_sv_undef)
1262 SV * callback
1263 PPCODE:
1264{
1265 dREQ;
1266
1267 req->type = REQ_NOP;
1268
1269 REQ_SEND;
1270}
1271
1108#if 0 1272#if 0
1109 1273
1110# undocumented, because it does not cancel active requests
1111void 1274void
1112cancel_most_requests () 1275aio_pri (int pri = DEFAULT_PRI)
1113 PROTOTYPE: 1276 CODE:
1114 CODE: 1277 if (pri < PRI_MIN) pri = PRI_MIN;
1115{ 1278 if (pri > PRI_MAX) pri = PRI_MAX;
1116 aio_req *req; 1279 next_pri = pri + PRI_BIAS;
1117
1118 pthread_mutex_lock (&reqlock);
1119 for (req = reqs; req; req = req->next)
1120 req->flags |= 1;
1121 pthread_mutex_unlock (&reqlock);
1122
1123 pthread_mutex_lock (&reslock);
1124 for (req = ress; req; req = req->next)
1125 req->flags |= 1;
1126 pthread_mutex_unlock (&reslock);
1127}
1128 1280
1129#endif 1281#endif
1130 1282
1131void 1283void
1132flush () 1284flush ()
… …
1177 CODE: 1329 CODE:
1178 RETVAL = nreqs; 1330 RETVAL = nreqs;
1179 OUTPUT: 1331 OUTPUT:
1180 RETVAL 1332 RETVAL
1181 1333
1334PROTOTYPES: DISABLE
1335
1182MODULE = IO::AIO PACKAGE = IO::AIO::CB 1336MODULE = IO::AIO PACKAGE = IO::AIO::REQ
1183 1337
1184void 1338void
1185cancel (aio_req_ornot req) 1339cancel (aio_req_ornot req)
1186 PROTOTYPE: 1340 PROTOTYPE:
1187 CODE: 1341 CODE:
1188 req->cancelled = 1; 1342 req_cancel (req);
1189 1343
1344void
1345cb (aio_req_ornot req, SV *callback=&PL_sv_undef)
1346 CODE:
1347 SvREFCNT_dec (req->callback);
1348 req->callback = newSVsv (callback);
1349
1350MODULE = IO::AIO PACKAGE = IO::AIO::GRP
1351
1352void
1353add (aio_req grp, ...)
1354 PPCODE:
1355{
1356 int i;
1357 aio_req req;
1358
1359 if (grp->fd == 2)
1360 croak ("cannot add requests to IO::AIO::GRP after the group finished");
1361
1362 for (i = 1; i < items; ++i )
1363 {
1364 if (GIMME_V != G_VOID)
1365 XPUSHs (sv_2mortal (newSVsv (ST (i))));
1366
1367 req = SvAIO_REQ (ST (i));
1368
1369 if (req)
1370 {
1371 ++grp->length;
1372 req->grp = grp;
1373
1374 req->grp_prev = 0;
1375 req->grp_next = grp->grp_first;
1376
1377 if (grp->grp_first)
1378 grp->grp_first->grp_prev = req;
1379
1380 grp->grp_first = req;
1381 }
1382 }
1383}
1384
1385void
1386result (aio_req grp, ...)
1387 CODE:
1388{
1389 int i;
1390 AV *av = newAV ();
1391
1392 for (i = 1; i < items; ++i )
1393 av_push (av, newSVsv (ST (i)));
1394
1395 SvREFCNT_dec (grp->data);
1396 grp->data = (SV *)av;
1397}
1398
1399void
1400feed_limit (aio_req grp, int limit)
1401 CODE:
1402 grp->fd2 = limit;
1403 aio_grp_feed (grp);
1404
1405void
1406feed (aio_req grp, SV *callback=&PL_sv_undef)
1407 CODE:
1408{
1409 SvREFCNT_dec (grp->fh2);
1410 grp->fh2 = newSVsv (callback);
1411
1412 if (grp->fd2 <= 0)
1413 grp->fd2 = 2;
1414
1415 aio_grp_feed (grp);
1416}
1417

Diff Legend

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