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.62 by root, Mon Oct 23 22:45:18 2006 UTC

… …
9 9
10#include <pthread.h> 10#include <pthread.h>
11 11
12#include <stddef.h> 12#include <stddef.h>
13#include <errno.h> 13#include <errno.h>
14#include <sys/time.h>
15#include <sys/select.h>
14#include <sys/types.h> 16#include <sys/types.h>
15#include <sys/stat.h> 17#include <sys/stat.h>
16#include <limits.h> 18#include <limits.h>
17#include <unistd.h> 19#include <unistd.h>
18#include <fcntl.h> 20#include <fcntl.h>
… …
53 REQ_STAT, REQ_LSTAT, REQ_FSTAT, 55 REQ_STAT, REQ_LSTAT, REQ_FSTAT,
54 REQ_FSYNC, REQ_FDATASYNC, 56 REQ_FSYNC, REQ_FDATASYNC,
55 REQ_UNLINK, REQ_RMDIR, REQ_RENAME, 57 REQ_UNLINK, REQ_RMDIR, REQ_RENAME,
56 REQ_READDIR, 58 REQ_READDIR,
57 REQ_LINK, REQ_SYMLINK, 59 REQ_LINK, REQ_SYMLINK,
60 REQ_GROUP, REQ_NOP,
61 REQ_SLEEP,
58}; 62};
59 63
60#define AIO_CB_KLASS "IO::AIO::CB" 64#define AIO_REQ_KLASS "IO::AIO::REQ"
65#define AIO_GRP_KLASS "IO::AIO::GRP"
61 66
62typedef struct aio_cb 67typedef struct aio_cb
63{ 68{
64 struct aio_cb *grp_prev, *grp_next;
65 struct aio_grp *grp;
66
67 struct aio_cb *volatile next; 69 struct aio_cb *volatile next;
68
69 SV *self; /* the perl counterpart of this request, if any */
70 70
71 SV *data, *callback; 71 SV *data, *callback;
72 SV *fh, *fh2; 72 SV *fh, *fh2;
73 void *dataptr, *data2ptr; 73 void *dataptr, *data2ptr;
74 Stat_t *statdata; 74 Stat_t *statdata;
75 off_t offset; 75 off_t offset;
76 size_t length; 76 size_t length;
77 ssize_t result; 77 ssize_t result;
78 78
79 STRLEN dataoffset;
79 int type; 80 int type;
80 int fd, fd2; 81 int fd, fd2;
81 int errorno; 82 int errorno;
82 STRLEN dataoffset;
83 mode_t mode; /* open */ 83 mode_t mode; /* open */
84
84 unsigned char cancelled; 85 unsigned char flags;
86 unsigned char pri;
87
88 SV *self; /* the perl counterpart of this request, if any */
89 struct aio_cb *grp, *grp_prev, *grp_next, *grp_first;
85} aio_cb; 90} aio_cb;
91
92enum {
93 FLAG_CANCELLED = 0x01,
94};
86 95
87typedef aio_cb *aio_req; 96typedef aio_cb *aio_req;
88typedef aio_cb *aio_req_ornot; 97typedef aio_cb *aio_req_ornot;
98
99enum {
100 PRI_MIN = -4,
101 PRI_MAX = 4,
102
103 DEFAULT_PRI = 0,
104 PRI_BIAS = -PRI_MIN,
105};
106
107static int next_pri = DEFAULT_PRI + PRI_BIAS;
89 108
90static int started, wanted; 109static int started, wanted;
91static volatile int nreqs; 110static volatile int nreqs;
92static int max_outstanding = 1<<30; 111static int max_outstanding = 1<<30;
93static int respipe [2]; 112static int respipe [2];
… …
97static pthread_cond_t reqwait = PTHREAD_COND_INITIALIZER; 116static pthread_cond_t reqwait = PTHREAD_COND_INITIALIZER;
98 117
99static volatile aio_req reqs, reqe; /* queue start, queue end */ 118static volatile aio_req reqs, reqe; /* queue start, queue end */
100static volatile aio_req ress, rese; /* queue start, queue end */ 119static volatile aio_req ress, rese; /* queue start, queue end */
101 120
102typedef struct aio_grp 121static void req_invoke (aio_req req);
103{ 122static void req_free (aio_req req);
104 struct aio_cb *first, *last;
105 SV *callback;
106 int busycount;
107} aio_grp;
108 123
109static void aio_grp_begin (aio_grp *grp) 124/* must be called at most once */
125static SV *req_sv (aio_req req, const char *klass)
110{ 126{
111 ++grp->busycount; 127 if (!req->self)
112} 128 {
129 req->self = (SV *)newHV ();
130 sv_magic (req->self, 0, PERL_MAGIC_ext, (char *)req, 0);
131 }
113 132
133 return sv_2mortal (sv_bless (newRV_inc (req->self), gv_stashpv (klass, 1)));
134}
135
136static aio_req SvAIO_REQ (SV *sv)
137{
138 MAGIC *mg;
139
140 if (!sv_derived_from (sv, AIO_REQ_KLASS) || !SvROK (sv))
141 croak ("object of class " AIO_REQ_KLASS " expected");
142
143 mg = mg_find (SvRV (sv), PERL_MAGIC_ext);
144
145 return mg ? (aio_req)mg->mg_ptr : 0;
146}
147
114static void aio_grp_end (aio_grp *grp) 148static void aio_grp_feed (aio_req grp)
115{ 149{
116 --grp->busycount; 150 while (grp->length < grp->fd2 && !(grp->flags & FLAG_CANCELLED))
151 {
152 int old_len = grp->length;
117 153
118 if (grp->busycount) 154 if (grp->fh2 && SvOK (grp->fh2))
155 {
156 dSP;
157
158 ENTER;
159 SAVETMPS;
160 PUSHMARK (SP);
161 XPUSHs (req_sv (grp, AIO_GRP_KLASS));
162 PUTBACK;
163 call_sv (grp->fh2, G_VOID | G_EVAL);
164 SPAGAIN;
165 FREETMPS;
166 LEAVE;
167 }
168
169 /* stop if no progress has been made */
170 if (old_len == grp->length)
171 {
172 SvREFCNT_dec (grp->fh2);
173 grp->fh2 = 0;
174 break;
175 }
176 }
177}
178
179static void aio_grp_dec (aio_req grp)
180{
181 --grp->length;
182
183 /* call feeder, if applicable */
184 aio_grp_feed (grp);
185
186 /* finish, if done */
187 if (!grp->length && grp->fd)
188 {
189 req_invoke (grp);
190 req_free (grp);
191 }
192}
193
194static void poll_wait ()
195{
196 fd_set rfd;
197
198 while (nreqs)
199 {
200 aio_req req;
201 pthread_mutex_lock (&reslock);
202 req = ress;
203 pthread_mutex_unlock (&reslock);
204
205 if (req)
206 return;
207
208 FD_ZERO(&rfd);
209 FD_SET(respipe [0], &rfd);
210
211 select (respipe [0] + 1, &rfd, 0, 0, 0);
212 }
213}
214
215static void req_invoke (aio_req req)
216{
217 dSP;
218 int errorno = errno;
219
220 if (req->flags & FLAG_CANCELLED || !SvOK (req->callback))
119 return; 221 return;
120 222
121 SvREFCNT_dec (grp->callback); 223 errno = req->errorno;
122 grp->callback = 0;
123}
124 224
125static aio_grp *aio_grp_new () 225 ENTER;
126{ 226 SAVETMPS;
127 aio_grp *grp; 227 PUSHMARK (SP);
228 EXTEND (SP, 1);
128 229
129 Newz (0, grp, 1, aio_grp); 230 switch (req->type)
130 aio_grp_begin (grp); 231 {
232 case REQ_READDIR:
233 {
234 SV *rv = &PL_sv_undef;
131 235
132 return grp; 236 if (req->result >= 0)
133} 237 {
238 char *buf = req->data2ptr;
239 AV *av = newAV ();
134 240
135/* must be called at most once */ 241 while (req->result)
136static SV *req_sv (aio_req req) 242 {
137{ 243 SV *sv = newSVpv (buf, 0);
138 req->self = (SV *)newHV ();
139 sv_magic (req->self, 0, PERL_MAGIC_ext, (char *)req, 0);
140 244
141 return sv_bless (newRV_noinc (req->self), gv_stashpv (AIO_CB_KLASS, 1)); 245 av_push (av, sv);
142} 246 buf += SvCUR (sv) + 1;
247 req->result--;
248 }
143 249
144static aio_req SvAIO_REQ (SV *sv) 250 rv = sv_2mortal (newRV_noinc ((SV *)av));
145{ 251 }
146 if (!sv_derived_from (sv, AIO_CB_KLASS) || !SvROK (sv))
147 croak ("object of class " AIO_CB_KLASS " expected");
148 252
149 MAGIC *mg = mg_find (SvRV (sv), PERL_MAGIC_ext); 253 PUSHs (rv);
254 }
255 break;
150 256
151 return mg ? (aio_req)mg->mg_ptr : 0; 257 case REQ_OPEN:
258 {
259 /* convert fd to fh */
260 SV *fh;
261
262 PUSHs (sv_2mortal (newSViv (req->result)));
263 PUTBACK;
264 call_pv ("IO::AIO::_fd2fh", G_SCALAR | G_EVAL);
265 SPAGAIN;
266
267 fh = SvREFCNT_inc (POPs);
268
269 PUSHMARK (SP);
270 XPUSHs (sv_2mortal (fh));
271 }
272 break;
273
274 case REQ_GROUP:
275 req->fd = 2; /* mark group as finished */
276
277 if (req->data)
278 {
279 int i;
280 AV *av = (AV *)req->data;
281
282 EXTEND (SP, AvFILL (av) + 1);
283 for (i = 0; i <= AvFILL (av); ++i)
284 PUSHs (*av_fetch (av, i, 0));
285 }
286 break;
287
288 case REQ_NOP:
289 case REQ_SLEEP:
290 break;
291
292 default:
293 PUSHs (sv_2mortal (newSViv (req->result)));
294 break;
295 }
296
297
298 PUTBACK;
299 call_sv (req->callback, G_VOID | G_EVAL);
300 SPAGAIN;
301
302 FREETMPS;
303 LEAVE;
304
305 errno = errorno;
306
307 if (SvTRUE (ERRSV))
308 {
309 req_free (req);
310 croak (0);
311 }
152} 312}
153 313
154static void req_free (aio_req req) 314static void req_free (aio_req req)
155{ 315{
316 if (req->grp)
317 {
318 aio_req grp = req->grp;
319
320 /* unlink request */
321 if (req->grp_next) req->grp_next->grp_prev = req->grp_prev;
322 if (req->grp_prev) req->grp_prev->grp_next = req->grp_next;
323
324 if (grp->grp_first == req)
325 grp->grp_first = req->grp_next;
326
327 aio_grp_dec (grp);
328 }
329
156 if (req->self) 330 if (req->self)
157 { 331 {
158 sv_unmagic (req->self, PERL_MAGIC_ext); 332 sv_unmagic (req->self, PERL_MAGIC_ext);
159 SvREFCNT_dec (req->self); 333 SvREFCNT_dec (req->self);
160 } 334 }
161 335
162 if (req->data)
163 SvREFCNT_dec (req->data); 336 SvREFCNT_dec (req->data);
164
165 if (req->fh)
166 SvREFCNT_dec (req->fh); 337 SvREFCNT_dec (req->fh);
167
168 if (req->fh2)
169 SvREFCNT_dec (req->fh2); 338 SvREFCNT_dec (req->fh2);
170
171 if (req->statdata)
172 Safefree (req->statdata);
173
174 if (req->callback)
175 SvREFCNT_dec (req->callback); 339 SvREFCNT_dec (req->callback);
340 Safefree (req->statdata);
176 341
177 if (req->type == REQ_READDIR && req->result >= 0) 342 if (req->type == REQ_READDIR && req->result >= 0)
178 free (req->data2ptr); 343 free (req->data2ptr);
179 344
180 Safefree (req); 345 Safefree (req);
181} 346}
182 347
183static void 348static void req_cancel (aio_req req)
184poll_wait ()
185{ 349{
186 if (nreqs && !ress) 350 req->flags |= FLAG_CANCELLED;
187 {
188 fd_set rfd;
189 FD_ZERO(&rfd);
190 FD_SET(respipe [0], &rfd);
191 351
192 select (respipe [0] + 1, &rfd, 0, 0, 0); 352 if (req->type == REQ_GROUP)
193 } 353 {
194} 354 aio_req sub;
195 355
196static int 356 for (sub = req->grp_first; sub; sub = sub->grp_next)
197poll_cb () 357 req_cancel (sub);
358 }
359}
360
361static int poll_cb ()
198{ 362{
199 dSP; 363 dSP;
200 int count = 0; 364 int count = 0;
201 int do_croak = 0; 365 int do_croak = 0;
202 aio_req req; 366 aio_req req;
… …
224 pthread_mutex_unlock (&reslock); 388 pthread_mutex_unlock (&reslock);
225 389
226 if (!req) 390 if (!req)
227 break; 391 break;
228 392
229 nreqs--; 393 --nreqs;
230 394
231 if (req->type == REQ_QUIT) 395 if (req->type == REQ_QUIT)
232 started--; 396 started--;
397 else if (req->type == REQ_GROUP && req->length)
398 {
399 req->fd = 1; /* mark request as delayed */
400 continue;
401 }
233 else 402 else
234 { 403 {
235 int errorno = errno;
236 errno = req->errorno;
237
238 if (req->type == REQ_READ) 404 if (req->type == REQ_READ)
239 SvCUR_set (req->data, req->dataoffset + (req->result > 0 ? req->result : 0)); 405 SvCUR_set (req->data, req->dataoffset + (req->result > 0 ? req->result : 0));
240 406
241 if (req->data2ptr && (req->type == REQ_READ || req->type == REQ_WRITE)) 407 if (req->data2ptr && (req->type == REQ_READ || req->type == REQ_WRITE))
242 SvREADONLY_off (req->data); 408 SvREADONLY_off (req->data);
… …
246 PL_laststype = req->type == REQ_LSTAT ? OP_LSTAT : OP_STAT; 412 PL_laststype = req->type == REQ_LSTAT ? OP_LSTAT : OP_STAT;
247 PL_laststatval = req->result; 413 PL_laststatval = req->result;
248 PL_statcache = *(req->statdata); 414 PL_statcache = *(req->statdata);
249 } 415 }
250 416
251 ENTER; 417 req_invoke (req);
252 PUSHMARK (SP);
253 418
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++; 419 count++;
314 } 420 }
315 421
316 req_free (req); 422 req_free (req);
317 } 423 }
… …
319 return count; 425 return count;
320} 426}
321 427
322static void *aio_proc(void *arg); 428static void *aio_proc(void *arg);
323 429
324static void
325start_thread (void) 430static void start_thread (void)
326{ 431{
327 sigset_t fullsigset, oldsigset; 432 sigset_t fullsigset, oldsigset;
328 pthread_t tid; 433 pthread_t tid;
329 pthread_attr_t attr; 434 pthread_attr_t attr;
330 435
… …
339 started++; 444 started++;
340 445
341 sigprocmask (SIG_SETMASK, &oldsigset, 0); 446 sigprocmask (SIG_SETMASK, &oldsigset, 0);
342} 447}
343 448
344static void
345req_send (aio_req req) 449static void req_send (aio_req req)
346{ 450{
347 while (started < wanted && nreqs >= started) 451 while (started < wanted && nreqs >= started)
348 start_thread (); 452 start_thread ();
349 453
350 nreqs++; 454 ++nreqs;
351 455
352 pthread_mutex_lock (&reqlock); 456 pthread_mutex_lock (&reqlock);
353 457
354 req->next = 0; 458 req->next = 0;
355 459
… …
374 478
375 poll_wait (); 479 poll_wait ();
376 } 480 }
377} 481}
378 482
379static void 483static void end_thread (void)
380end_thread (void)
381{ 484{
382 aio_req req; 485 aio_req req;
383 Newz (0, req, 1, aio_cb); 486 Newz (0, req, 1, aio_cb);
384 req->type = REQ_QUIT; 487 req->type = REQ_QUIT;
385 488
… …
436 * normal read/write by using a mutex. slows down execution a lot, 539 * normal read/write by using a mutex. slows down execution a lot,
437 * but that's your problem, not mine. 540 * but that's your problem, not mine.
438 */ 541 */
439static pthread_mutex_t preadwritelock = PTHREAD_MUTEX_INITIALIZER; 542static pthread_mutex_t preadwritelock = PTHREAD_MUTEX_INITIALIZER;
440 543
441static ssize_t 544static 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{ 545{
444 ssize_t res; 546 ssize_t res;
445 off_t ooffset; 547 off_t ooffset;
446 548
447 pthread_mutex_lock (&preadwritelock); 549 pthread_mutex_lock (&preadwritelock);
… …
452 pthread_mutex_unlock (&preadwritelock); 554 pthread_mutex_unlock (&preadwritelock);
453 555
454 return res; 556 return res;
455} 557}
456 558
457static ssize_t
458pwrite (int fd, void *buf, size_t count, off_t offset) 559static ssize_t pwrite (int fd, void *buf, size_t count, off_t offset)
459{ 560{
460 ssize_t res; 561 ssize_t res;
461 off_t ooffset; 562 off_t ooffset;
462 563
463 pthread_mutex_lock (&preadwritelock); 564 pthread_mutex_lock (&preadwritelock);
… …
476#endif 577#endif
477 578
478#if !HAVE_READAHEAD 579#if !HAVE_READAHEAD
479# define readahead aio_readahead 580# define readahead aio_readahead
480 581
481static ssize_t
482readahead (int fd, off_t offset, size_t count) 582static ssize_t readahead (int fd, off_t offset, size_t count)
483{ 583{
484 char readahead_buf[4096]; 584 char readahead_buf[4096];
485 585
486 while (count > 0) 586 while (count > 0)
487 { 587 {
… …
499#if !HAVE_READDIR_R 599#if !HAVE_READDIR_R
500# define readdir_r aio_readdir_r 600# define readdir_r aio_readdir_r
501 601
502static pthread_mutex_t readdirlock = PTHREAD_MUTEX_INITIALIZER; 602static pthread_mutex_t readdirlock = PTHREAD_MUTEX_INITIALIZER;
503 603
504static int
505readdir_r (DIR *dirp, struct dirent *ent, struct dirent **res) 604static int readdir_r (DIR *dirp, struct dirent *ent, struct dirent **res)
506{ 605{
507 struct dirent *e; 606 struct dirent *e;
508 int errorno; 607 int errorno;
509 608
510 pthread_mutex_lock (&readdirlock); 609 pthread_mutex_lock (&readdirlock);
… …
526 return e ? 0 : -1; 625 return e ? 0 : -1;
527} 626}
528#endif 627#endif
529 628
530/* sendfile always needs emulation */ 629/* sendfile always needs emulation */
531static ssize_t
532sendfile_ (int ofd, int ifd, off_t offset, size_t count) 630static ssize_t sendfile_ (int ofd, int ifd, off_t offset, size_t count)
533{ 631{
534 ssize_t res; 632 ssize_t res;
535 633
536 if (!count) 634 if (!count)
537 return 0; 635 return 0;
… …
619 717
620 return res; 718 return res;
621} 719}
622 720
623/* read a full directory */ 721/* read a full directory */
624static int
625scandir_ (const char *path, void **namesp) 722static int scandir_ (const char *path, void **namesp)
626{ 723{
627 DIR *dirp = opendir (path); 724 DIR *dirp = opendir (path);
628 union 725 union
629 { 726 {
630 struct dirent d; 727 struct dirent d;
… …
684 return res; 781 return res;
685} 782}
686 783
687/*****************************************************************************/ 784/*****************************************************************************/
688 785
689static void *
690aio_proc (void *thr_arg) 786static void *aio_proc (void *thr_arg)
691{ 787{
692 aio_req req; 788 aio_req req;
693 int type; 789 int type;
694 790
695 do 791 do
… …
713 } 809 }
714 810
715 pthread_mutex_unlock (&reqlock); 811 pthread_mutex_unlock (&reqlock);
716 812
717 errno = 0; /* strictly unnecessary */ 813 errno = 0; /* strictly unnecessary */
814 type = req->type; /* remember type for QUIT check */
718 815
719 if (!req->cancelled) 816 if (!(req->flags & FLAG_CANCELLED))
720 switch (req->type) 817 switch (type)
721 { 818 {
722 case REQ_READ: req->result = pread (req->fd, req->dataptr, req->length, req->offset); break; 819 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; 820 case REQ_WRITE: req->result = pwrite (req->fd, req->dataptr, req->length, req->offset); break;
724 821
725 case REQ_READAHEAD: req->result = readahead (req->fd, req->offset, req->length); break; 822 case REQ_READAHEAD: req->result = readahead (req->fd, req->offset, req->length); break;
… …
739 836
740 case REQ_FDATASYNC: req->result = fdatasync (req->fd); break; 837 case REQ_FDATASYNC: req->result = fdatasync (req->fd); break;
741 case REQ_FSYNC: req->result = fsync (req->fd); break; 838 case REQ_FSYNC: req->result = fsync (req->fd); break;
742 case REQ_READDIR: req->result = scandir_ (req->dataptr, &req->data2ptr); break; 839 case REQ_READDIR: req->result = scandir_ (req->dataptr, &req->data2ptr); break;
743 840
841 case REQ_SLEEP:
842 {
843 struct timeval tv;
844
845 tv.tv_sec = req->fd;
846 tv.tv_usec = req->fd2;
847
848 req->result = select (0, 0, 0, 0, &tv);
849 }
850
851 case REQ_GROUP:
852 case REQ_NOP:
744 case REQ_QUIT: 853 case REQ_QUIT:
745 break; 854 break;
746 855
747 default: 856 default:
748 req->result = ENOSYS; 857 req->result = ENOSYS;
… …
832 atfork_parent (); 941 atfork_parent ();
833} 942}
834 943
835#define dREQ \ 944#define dREQ \
836 aio_req req; \ 945 aio_req req; \
946 int req_pri = next_pri; \
947 next_pri = DEFAULT_PRI + PRI_BIAS; \
837 \ 948 \
838 if (SvOK (callback) && !SvROK (callback)) \ 949 if (SvOK (callback) && !SvROK (callback)) \
839 croak ("callback must be undef or of reference type"); \ 950 croak ("callback must be undef or of reference type"); \
840 \ 951 \
841 Newz (0, req, 1, aio_cb); \ 952 Newz (0, req, 1, aio_cb); \
842 if (!req) \ 953 if (!req) \
843 croak ("out of memory during aio_req allocation"); \ 954 croak ("out of memory during aio_req allocation"); \
844 \ 955 \
845 req->callback = newSVsv (callback) 956 req->callback = newSVsv (callback); \
957 req->pri = req_pri
846 958
847#define REQ_SEND \ 959#define REQ_SEND \
848 req_send (req); \ 960 req_send (req); \
849 \ 961 \
850 if (GIMME_V != G_VOID) \ 962 if (GIMME_V != G_VOID) \
851 XPUSHs (req_sv (req)); 963 XPUSHs (req_sv (req, AIO_REQ_KLASS));
852 964
853MODULE = IO::AIO PACKAGE = IO::AIO 965MODULE = IO::AIO PACKAGE = IO::AIO
854 966
855PROTOTYPES: ENABLE 967PROTOTYPES: ENABLE
856 968
… …
1103 req->dataptr = SvPVbyte_nolen (req->data); 1215 req->dataptr = SvPVbyte_nolen (req->data);
1104 1216
1105 REQ_SEND; 1217 REQ_SEND;
1106} 1218}
1107 1219
1220void
1221aio_sleep (delay,callback=&PL_sv_undef)
1222 double delay
1223 SV * callback
1224 PPCODE:
1225{
1226 dREQ;
1227
1228 req->type = REQ_SLEEP;
1229 req->fd = delay < 0. ? 0 : delay;
1230 req->fd2 = delay < 0. ? 0 : 1000. * (delay - req->fd);
1231
1232 REQ_SEND;
1233}
1234
1235void
1236aio_group (callback=&PL_sv_undef)
1237 SV * callback
1238 PROTOTYPE: ;$
1239 PPCODE:
1240{
1241 dREQ;
1242
1243 req->type = REQ_GROUP;
1244 req_send (req);
1245
1246 XPUSHs (req_sv (req, AIO_GRP_KLASS));
1247}
1248
1249void
1250aio_nop (callback=&PL_sv_undef)
1251 SV * callback
1252 PPCODE:
1253{
1254 dREQ;
1255
1256 req->type = REQ_NOP;
1257
1258 REQ_SEND;
1259}
1260
1108#if 0 1261#if 0
1109 1262
1110# undocumented, because it does not cancel active requests
1111void 1263void
1112cancel_most_requests () 1264aio_pri (int pri = DEFAULT_PRI)
1113 PROTOTYPE: 1265 CODE:
1114 CODE: 1266 if (pri < PRI_MIN) pri = PRI_MIN;
1115{ 1267 if (pri > PRI_MAX) pri = PRI_MAX;
1116 aio_req *req; 1268 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 1269
1129#endif 1270#endif
1130 1271
1131void 1272void
1132flush () 1273flush ()
… …
1177 CODE: 1318 CODE:
1178 RETVAL = nreqs; 1319 RETVAL = nreqs;
1179 OUTPUT: 1320 OUTPUT:
1180 RETVAL 1321 RETVAL
1181 1322
1323PROTOTYPES: DISABLE
1324
1182MODULE = IO::AIO PACKAGE = IO::AIO::CB 1325MODULE = IO::AIO PACKAGE = IO::AIO::REQ
1183 1326
1184void 1327void
1185cancel (aio_req_ornot req) 1328cancel (aio_req_ornot req)
1186 PROTOTYPE: 1329 PROTOTYPE:
1187 CODE: 1330 CODE:
1188 req->cancelled = 1; 1331 req_cancel (req);
1189 1332
1333void
1334cb (aio_req_ornot req, SV *callback=&PL_sv_undef)
1335 CODE:
1336 SvREFCNT_dec (req->callback);
1337 req->callback = newSVsv (callback);
1338
1339MODULE = IO::AIO PACKAGE = IO::AIO::GRP
1340
1341void
1342add (aio_req grp, ...)
1343 PPCODE:
1344{
1345 int i;
1346 aio_req req;
1347
1348 if (grp->fd == 2)
1349 croak ("cannot add requests to IO::AIO::GRP after the group finished");
1350
1351 for (i = 1; i < items; ++i )
1352 {
1353 if (GIMME_V != G_VOID)
1354 XPUSHs (sv_2mortal (newSVsv (ST (i))));
1355
1356 req = SvAIO_REQ (ST (i));
1357
1358 if (req)
1359 {
1360 ++grp->length;
1361 req->grp = grp;
1362
1363 req->grp_prev = 0;
1364 req->grp_next = grp->grp_first;
1365
1366 if (grp->grp_first)
1367 grp->grp_first->grp_prev = req;
1368
1369 grp->grp_first = req;
1370 }
1371 }
1372}
1373
1374void
1375result (aio_req grp, ...)
1376 CODE:
1377{
1378 int i;
1379 AV *av = newAV ();
1380
1381 for (i = 1; i < items; ++i )
1382 av_push (av, newSVsv (ST (i)));
1383
1384 SvREFCNT_dec (grp->data);
1385 grp->data = (SV *)av;
1386}
1387
1388void
1389feed_limit (aio_req grp, int limit)
1390 CODE:
1391 grp->fd2 = limit;
1392 aio_grp_feed (grp);
1393
1394void
1395feed (aio_req grp, SV *callback=&PL_sv_undef)
1396 CODE:
1397{
1398 SvREFCNT_dec (grp->fh2);
1399 grp->fh2 = newSVsv (callback);
1400
1401 if (grp->fd2 <= 0)
1402 grp->fd2 = 2;
1403
1404 aio_grp_feed (grp);
1405}
1406

Diff Legend

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