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.44 by root, Sat Oct 21 23:20:29 2006 UTC vs.
Revision 1.46 by root, Sun Oct 22 00:49:29 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_SLEEP,
58 REQ_GROUP, 61 REQ_GROUP,
59}; 62};
60 63
61#define AIO_REQ_KLASS "IO::AIO::REQ" 64#define AIO_REQ_KLASS "IO::AIO::REQ"
62#define AIO_GRP_KLASS "IO::AIO::GRP" 65#define AIO_GRP_KLASS "IO::AIO::GRP"
… …
85 unsigned char cancelled; 88 unsigned char cancelled;
86} aio_cb; 89} aio_cb;
87 90
88typedef aio_cb *aio_req; 91typedef aio_cb *aio_req;
89typedef aio_cb *aio_req_ornot; 92typedef aio_cb *aio_req_ornot;
90typedef aio_cb *aio_group;
91 93
92static int started, wanted; 94static int started, wanted;
93static volatile int nreqs; 95static volatile int nreqs;
94static int max_outstanding = 1<<30; 96static int max_outstanding = 1<<30;
95static int respipe [2]; 97static int respipe [2];
… …
99static pthread_cond_t reqwait = PTHREAD_COND_INITIALIZER; 101static pthread_cond_t reqwait = PTHREAD_COND_INITIALIZER;
100 102
101static volatile aio_req reqs, reqe; /* queue start, queue end */ 103static volatile aio_req reqs, reqe; /* queue start, queue end */
102static volatile aio_req ress, rese; /* queue start, queue end */ 104static volatile aio_req ress, rese; /* queue start, queue end */
103 105
106static void req_free (aio_req req);
107
104/* must be called at most once */ 108/* must be called at most once */
105static SV *req_sv (aio_req req, const char *klass) 109static SV *req_sv (aio_req req, const char *klass)
106{ 110{
107 req->self = (SV *)newHV (); 111 req->self = (SV *)newHV ();
108 sv_magic (req->self, 0, PERL_MAGIC_ext, (char *)req, 0); 112 sv_magic (req->self, 0, PERL_MAGIC_ext, (char *)req, 0);
109 113
110 return sv_2mortal (sv_bless (newRV_noinc (req->self), gv_stashpv (klass, 1))); 114 return sv_2mortal (sv_bless (newRV_inc (req->self), gv_stashpv (klass, 1)));
111} 115}
112 116
113static aio_req SvAIO_REQ (SV *sv, const char *klass) 117static aio_req SvAIO_REQ (SV *sv)
114{ 118{
115 if (!sv_derived_from (sv, klass) || !SvROK (sv)) 119 if (!sv_derived_from (sv, AIO_REQ_KLASS) || !SvROK (sv))
116 croak ("object of class %s expected", klass); 120 croak ("object of class " AIO_REQ_KLASS " expected");
117 121
118 MAGIC *mg = mg_find (SvRV (sv), PERL_MAGIC_ext); 122 MAGIC *mg = mg_find (SvRV (sv), PERL_MAGIC_ext);
119 123
120 return mg ? (aio_req)mg->mg_ptr : 0; 124 return mg ? (aio_req)mg->mg_ptr : 0;
121} 125}
122 126
123static void req_free (aio_req req) 127static void poll_wait ()
124{
125 if (req->self)
126 {
127 sv_unmagic (req->self, PERL_MAGIC_ext);
128 SvREFCNT_dec (req->self);
129 }
130
131 if (req->data)
132 SvREFCNT_dec (req->data);
133
134 if (req->fh)
135 SvREFCNT_dec (req->fh);
136
137 if (req->fh2)
138 SvREFCNT_dec (req->fh2);
139
140 if (req->statdata)
141 Safefree (req->statdata);
142
143 if (req->callback)
144 SvREFCNT_dec (req->callback);
145
146 if (req->type == REQ_READDIR && req->result >= 0)
147 free (req->data2ptr);
148
149 Safefree (req);
150}
151
152static void
153poll_wait ()
154{ 128{
155 if (nreqs && !ress) 129 if (nreqs && !ress)
156 { 130 {
157 fd_set rfd; 131 fd_set rfd;
158 FD_ZERO(&rfd); 132 FD_ZERO(&rfd);
… …
160 134
161 select (respipe [0] + 1, &rfd, 0, 0, 0); 135 select (respipe [0] + 1, &rfd, 0, 0, 0);
162 } 136 }
163} 137}
164 138
165static int 139static void req_invoke (aio_req req)
166poll_cb () 140{
141 dSP;
142 int errorno = errno;
143
144 if (req->cancelled || !SvOK (req->callback))
145 return;
146
147 errno = req->errorno;
148
149 ENTER;
150 PUSHMARK (SP);
151
152 switch (req->type)
153 {
154 case REQ_READDIR:
155 {
156 SV *rv = &PL_sv_undef;
157
158 if (req->result >= 0)
159 {
160 char *buf = req->data2ptr;
161 AV *av = newAV ();
162
163 while (req->result)
164 {
165 SV *sv = newSVpv (buf, 0);
166
167 av_push (av, sv);
168 buf += SvCUR (sv) + 1;
169 req->result--;
170 }
171
172 rv = sv_2mortal (newRV_noinc ((SV *)av));
173 }
174
175 XPUSHs (rv);
176 }
177 break;
178
179 case REQ_OPEN:
180 {
181 /* convert fd to fh */
182 SV *fh;
183
184 XPUSHs (sv_2mortal (newSViv (req->result)));
185 PUTBACK;
186 call_pv ("IO::AIO::_fd2fh", G_SCALAR | G_EVAL);
187 SPAGAIN;
188
189 fh = SvREFCNT_inc (POPs);
190
191 PUSHMARK (SP);
192 XPUSHs (sv_2mortal (fh));
193 }
194 break;
195
196 case REQ_SLEEP:
197 case REQ_GROUP:
198 break;
199
200 default:
201 XPUSHs (sv_2mortal (newSViv (req->result)));
202 break;
203 }
204
205
206 PUTBACK;
207 call_sv (req->callback, G_VOID | G_EVAL);
208 SPAGAIN;
209
210 if (SvTRUE (ERRSV))
211 {
212 req_free (req);
213 croak (0);
214 }
215
216 LEAVE;
217
218 errno = errorno;
219}
220
221static void req_free (aio_req req)
222{
223 if (req->grp)
224 {
225 aio_req grp = req->grp;
226
227 /* unlink request */
228 req->grp_next->grp_prev = req->grp_prev;
229 req->grp_prev->grp_next = req->grp_next;
230
231 if (grp->grp_next == grp && grp->fd)
232 {
233 req_invoke (grp);
234 req_free (grp);
235 }
236 }
237
238 if (req->self)
239 {
240 sv_unmagic (req->self, PERL_MAGIC_ext);
241 SvREFCNT_dec (req->self);
242 }
243
244 if (req->data)
245 SvREFCNT_dec (req->data);
246
247 if (req->fh)
248 SvREFCNT_dec (req->fh);
249
250 if (req->fh2)
251 SvREFCNT_dec (req->fh2);
252
253 if (req->statdata)
254 Safefree (req->statdata);
255
256 if (req->callback)
257 SvREFCNT_dec (req->callback);
258
259 if (req->type == REQ_READDIR && req->result >= 0)
260 free (req->data2ptr);
261
262 Safefree (req);
263}
264
265static void req_cancel (aio_req req)
266{
267 req->cancelled = 1;
268
269 if (req->type == REQ_GROUP)
270 {
271 aio_req sub;
272
273 for (sub = req->grp_next; sub != req; sub = sub->grp_next)
274 req_cancel (sub);
275 }
276}
277
278static int poll_cb ()
167{ 279{
168 dSP; 280 dSP;
169 int count = 0; 281 int count = 0;
170 int do_croak = 0; 282 int do_croak = 0;
171 aio_req req; 283 aio_req req;
… …
197 309
198 nreqs--; 310 nreqs--;
199 311
200 if (req->type == REQ_QUIT) 312 if (req->type == REQ_QUIT)
201 started--; 313 started--;
314 else if (req->type == REQ_GROUP && req->grp_next != req)
315 {
316 req->fd = 1; /* mark request as delayed */
317 continue;
318 }
202 else 319 else
203 { 320 {
204 int errorno = errno;
205 errno = req->errorno;
206
207 if (req->type == REQ_READ) 321 if (req->type == REQ_READ)
208 SvCUR_set (req->data, req->dataoffset + (req->result > 0 ? req->result : 0)); 322 SvCUR_set (req->data, req->dataoffset + (req->result > 0 ? req->result : 0));
209 323
210 if (req->data2ptr && (req->type == REQ_READ || req->type == REQ_WRITE)) 324 if (req->data2ptr && (req->type == REQ_READ || req->type == REQ_WRITE))
211 SvREADONLY_off (req->data); 325 SvREADONLY_off (req->data);
… …
215 PL_laststype = req->type == REQ_LSTAT ? OP_LSTAT : OP_STAT; 329 PL_laststype = req->type == REQ_LSTAT ? OP_LSTAT : OP_STAT;
216 PL_laststatval = req->result; 330 PL_laststatval = req->result;
217 PL_statcache = *(req->statdata); 331 PL_statcache = *(req->statdata);
218 } 332 }
219 333
220 ENTER; 334 req_invoke (req);
221 PUSHMARK (SP);
222 335
223 if (req->type == REQ_READDIR)
224 {
225 SV *rv = &PL_sv_undef;
226
227 if (req->result >= 0)
228 {
229 char *buf = req->data2ptr;
230 AV *av = newAV ();
231
232 while (req->result)
233 {
234 SV *sv = newSVpv (buf, 0);
235
236 av_push (av, sv);
237 buf += SvCUR (sv) + 1;
238 req->result--;
239 }
240
241 rv = sv_2mortal (newRV_noinc ((SV *)av));
242 }
243
244 XPUSHs (rv);
245 }
246 else
247 {
248 XPUSHs (sv_2mortal (newSViv (req->result)));
249
250 if (req->type == REQ_OPEN)
251 {
252 /* convert fd to fh */
253 SV *fh;
254
255 PUTBACK;
256 call_pv ("IO::AIO::_fd2fh", G_SCALAR | G_EVAL);
257 SPAGAIN;
258
259 fh = SvREFCNT_inc (POPs);
260
261 PUSHMARK (SP);
262 XPUSHs (sv_2mortal (fh));
263 }
264 }
265
266 if (SvOK (req->callback) && !req->cancelled)
267 {
268 PUTBACK;
269 call_sv (req->callback, G_VOID | G_EVAL);
270 SPAGAIN;
271
272 if (SvTRUE (ERRSV))
273 {
274 req_free (req);
275 croak (0);
276 }
277 }
278
279 LEAVE;
280
281 errno = errorno;
282 count++; 336 count++;
283 } 337 }
284 338
285 req_free (req); 339 req_free (req);
286 } 340 }
… …
288 return count; 342 return count;
289} 343}
290 344
291static void *aio_proc(void *arg); 345static void *aio_proc(void *arg);
292 346
293static void
294start_thread (void) 347static void start_thread (void)
295{ 348{
296 sigset_t fullsigset, oldsigset; 349 sigset_t fullsigset, oldsigset;
297 pthread_t tid; 350 pthread_t tid;
298 pthread_attr_t attr; 351 pthread_attr_t attr;
299 352
… …
308 started++; 361 started++;
309 362
310 sigprocmask (SIG_SETMASK, &oldsigset, 0); 363 sigprocmask (SIG_SETMASK, &oldsigset, 0);
311} 364}
312 365
313static void
314req_send (aio_req req) 366static void req_send (aio_req req)
315{ 367{
316 while (started < wanted && nreqs >= started) 368 while (started < wanted && nreqs >= started)
317 start_thread (); 369 start_thread ();
318 370
319 nreqs++; 371 nreqs++;
… …
343 395
344 poll_wait (); 396 poll_wait ();
345 } 397 }
346} 398}
347 399
348static void 400static void end_thread (void)
349end_thread (void)
350{ 401{
351 aio_req req; 402 aio_req req;
352 Newz (0, req, 1, aio_cb); 403 Newz (0, req, 1, aio_cb);
353 req->type = REQ_QUIT; 404 req->type = REQ_QUIT;
354 405
… …
405 * normal read/write by using a mutex. slows down execution a lot, 456 * normal read/write by using a mutex. slows down execution a lot,
406 * but that's your problem, not mine. 457 * but that's your problem, not mine.
407 */ 458 */
408static pthread_mutex_t preadwritelock = PTHREAD_MUTEX_INITIALIZER; 459static pthread_mutex_t preadwritelock = PTHREAD_MUTEX_INITIALIZER;
409 460
410static ssize_t 461static ssize_t pread (int fd, void *buf, size_t count, off_t offset)
411pread (int fd, void *buf, size_t count, off_t offset)
412{ 462{
413 ssize_t res; 463 ssize_t res;
414 off_t ooffset; 464 off_t ooffset;
415 465
416 pthread_mutex_lock (&preadwritelock); 466 pthread_mutex_lock (&preadwritelock);
… …
421 pthread_mutex_unlock (&preadwritelock); 471 pthread_mutex_unlock (&preadwritelock);
422 472
423 return res; 473 return res;
424} 474}
425 475
426static ssize_t
427pwrite (int fd, void *buf, size_t count, off_t offset) 476static ssize_t pwrite (int fd, void *buf, size_t count, off_t offset)
428{ 477{
429 ssize_t res; 478 ssize_t res;
430 off_t ooffset; 479 off_t ooffset;
431 480
432 pthread_mutex_lock (&preadwritelock); 481 pthread_mutex_lock (&preadwritelock);
… …
445#endif 494#endif
446 495
447#if !HAVE_READAHEAD 496#if !HAVE_READAHEAD
448# define readahead aio_readahead 497# define readahead aio_readahead
449 498
450static ssize_t
451readahead (int fd, off_t offset, size_t count) 499static ssize_t readahead (int fd, off_t offset, size_t count)
452{ 500{
453 char readahead_buf[4096]; 501 char readahead_buf[4096];
454 502
455 while (count > 0) 503 while (count > 0)
456 { 504 {
… …
468#if !HAVE_READDIR_R 516#if !HAVE_READDIR_R
469# define readdir_r aio_readdir_r 517# define readdir_r aio_readdir_r
470 518
471static pthread_mutex_t readdirlock = PTHREAD_MUTEX_INITIALIZER; 519static pthread_mutex_t readdirlock = PTHREAD_MUTEX_INITIALIZER;
472 520
473static int
474readdir_r (DIR *dirp, struct dirent *ent, struct dirent **res) 521static int readdir_r (DIR *dirp, struct dirent *ent, struct dirent **res)
475{ 522{
476 struct dirent *e; 523 struct dirent *e;
477 int errorno; 524 int errorno;
478 525
479 pthread_mutex_lock (&readdirlock); 526 pthread_mutex_lock (&readdirlock);
… …
495 return e ? 0 : -1; 542 return e ? 0 : -1;
496} 543}
497#endif 544#endif
498 545
499/* sendfile always needs emulation */ 546/* sendfile always needs emulation */
500static ssize_t
501sendfile_ (int ofd, int ifd, off_t offset, size_t count) 547static ssize_t sendfile_ (int ofd, int ifd, off_t offset, size_t count)
502{ 548{
503 ssize_t res; 549 ssize_t res;
504 550
505 if (!count) 551 if (!count)
506 return 0; 552 return 0;
… …
588 634
589 return res; 635 return res;
590} 636}
591 637
592/* read a full directory */ 638/* read a full directory */
593static int
594scandir_ (const char *path, void **namesp) 639static int scandir_ (const char *path, void **namesp)
595{ 640{
596 DIR *dirp = opendir (path); 641 DIR *dirp = opendir (path);
597 union 642 union
598 { 643 {
599 struct dirent d; 644 struct dirent d;
… …
653 return res; 698 return res;
654} 699}
655 700
656/*****************************************************************************/ 701/*****************************************************************************/
657 702
658static void *
659aio_proc (void *thr_arg) 703static void *aio_proc (void *thr_arg)
660{ 704{
661 aio_req req; 705 aio_req req;
662 int type; 706 int type;
663 707
664 do 708 do
… …
707 case REQ_SYMLINK: req->result = symlink (req->data2ptr, req->dataptr); break; 751 case REQ_SYMLINK: req->result = symlink (req->data2ptr, req->dataptr); break;
708 752
709 case REQ_FDATASYNC: req->result = fdatasync (req->fd); break; 753 case REQ_FDATASYNC: req->result = fdatasync (req->fd); break;
710 case REQ_FSYNC: req->result = fsync (req->fd); break; 754 case REQ_FSYNC: req->result = fsync (req->fd); break;
711 case REQ_READDIR: req->result = scandir_ (req->dataptr, &req->data2ptr); break; 755 case REQ_READDIR: req->result = scandir_ (req->dataptr, &req->data2ptr); break;
756
757 case REQ_SLEEP:
758 {
759 struct timeval tv;
760
761 tv.tv_sec = req->fd;
762 tv.tv_usec = req->fd2;
763
764 req->result = select (0, 0, 0, 0, &tv);
765 }
712 766
713 case REQ_QUIT: 767 case REQ_QUIT:
714 break; 768 break;
715 769
716 default: 770 default:
… …
1073 1127
1074 REQ_SEND; 1128 REQ_SEND;
1075} 1129}
1076 1130
1077void 1131void
1132aio_sleep (delay,callback=&PL_sv_undef)
1133 double delay
1134 SV * callback
1135 PPCODE:
1136{
1137 dREQ;
1138
1139 req->type = REQ_SLEEP;
1140 req->fd = delay < 0. ? 0 : delay;
1141 req->fd2 = delay < 0. ? 0 : 1000. * (delay - req->fd);
1142
1143 REQ_SEND;
1144}
1145
1146void
1078aio_group (callback=&PL_sv_undef) 1147aio_group (callback=&PL_sv_undef)
1079 SV * callback 1148 SV * callback
1080 PROTOTYPE: ;& 1149 PROTOTYPE: ;$
1081 PPCODE: 1150 PPCODE:
1082{ 1151{
1083 dREQ; 1152 dREQ;
1084 req->type = REQ_GROUP; 1153 req->type = REQ_GROUP;
1154 req->grp_next = req;
1155 req->grp_prev = req;
1156
1157 req_send (req);
1085 XPUSHs (req_sv (req, AIO_GRP_KLASS)); 1158 XPUSHs (req_sv (req, AIO_GRP_KLASS));
1086} 1159}
1087 1160
1088void 1161void
1089flush () 1162flush ()
… …
1140 1213
1141void 1214void
1142cancel (aio_req_ornot req) 1215cancel (aio_req_ornot req)
1143 PROTOTYPE: 1216 PROTOTYPE:
1144 CODE: 1217 CODE:
1145 req->cancelled = 1; 1218 req_cancel (req);
1146 1219
1220MODULE = IO::AIO PACKAGE = IO::AIO::GRP
1221
1222void
1223add (aio_req grp, ...)
1224 PROTOTYPE: $;@
1225 PPCODE:
1226{
1227 int i;
1228
1229 for (i = 1; i < items; ++i )
1230 {
1231 if (GIMME_V != G_VOID)
1232 XPUSHs (sv_2mortal (newSVsv (ST (i))));
1233
1234 aio_req req = SvAIO_REQ (ST (i));
1235 printf ("req = %p\n", req);//D
1236
1237 if (req)
1238 {
1239 req->grp_prev = grp;
1240 req->grp_next = grp->grp_next;
1241 grp->grp_next->grp_prev = req;
1242 grp->grp_next = req;
1243
1244 req->grp = grp;
1245 }
1246 }
1247}
1248

Diff Legend

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