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.48 by root, Sun Oct 22 10:33:19 2006 UTC vs.
Revision 1.56 by root, Mon Oct 23 14:49:51 2006 UTC

… …
55 REQ_STAT, REQ_LSTAT, REQ_FSTAT, 55 REQ_STAT, REQ_LSTAT, REQ_FSTAT,
56 REQ_FSYNC, REQ_FDATASYNC, 56 REQ_FSYNC, REQ_FDATASYNC,
57 REQ_UNLINK, REQ_RMDIR, REQ_RENAME, 57 REQ_UNLINK, REQ_RMDIR, REQ_RENAME,
58 REQ_READDIR, 58 REQ_READDIR,
59 REQ_LINK, REQ_SYMLINK, 59 REQ_LINK, REQ_SYMLINK,
60 REQ_GROUP, REQ_NOP,
60 REQ_SLEEP, 61 REQ_SLEEP,
61 REQ_GROUP,
62}; 62};
63 63
64#define AIO_REQ_KLASS "IO::AIO::REQ" 64#define AIO_REQ_KLASS "IO::AIO::REQ"
65#define AIO_GRP_KLASS "IO::AIO::GRP" 65#define AIO_GRP_KLASS "IO::AIO::GRP"
66 66
67typedef struct aio_cb 67typedef struct aio_cb
68{ 68{
69 struct aio_cb *grp, *grp_prev, *grp_next;
70
71 struct aio_cb *volatile next; 69 struct aio_cb *volatile next;
70
71 struct aio_cb *grp, *grp_prev, *grp_next, *grp_first;
72 72
73 SV *self; /* the perl counterpart of this request, if any */ 73 SV *self; /* the perl counterpart of this request, if any */
74 74
75 SV *data, *callback; 75 SV *data, *callback;
76 SV *fh, *fh2; 76 SV *fh, *fh2;
… …
101static pthread_cond_t reqwait = PTHREAD_COND_INITIALIZER; 101static pthread_cond_t reqwait = PTHREAD_COND_INITIALIZER;
102 102
103static volatile aio_req reqs, reqe; /* queue start, queue end */ 103static volatile aio_req reqs, reqe; /* queue start, queue end */
104static volatile aio_req ress, rese; /* queue start, queue end */ 104static volatile aio_req ress, rese; /* queue start, queue end */
105 105
106static void req_invoke (aio_req req);
106static void req_free (aio_req req); 107static void req_free (aio_req req);
107 108
108/* must be called at most once */ 109/* must be called at most once */
109static SV *req_sv (aio_req req, const char *klass) 110static SV *req_sv (aio_req req, const char *klass)
110{ 111{
112 if (!req->self)
113 {
111 req->self = (SV *)newHV (); 114 req->self = (SV *)newHV ();
112 sv_magic (req->self, 0, PERL_MAGIC_ext, (char *)req, 0); 115 sv_magic (req->self, 0, PERL_MAGIC_ext, (char *)req, 0);
116 }
113 117
114 return sv_2mortal (sv_bless (newRV_inc (req->self), gv_stashpv (klass, 1))); 118 return sv_2mortal (sv_bless (newRV_inc (req->self), gv_stashpv (klass, 1)));
115} 119}
116 120
117static aio_req SvAIO_REQ (SV *sv) 121static aio_req SvAIO_REQ (SV *sv)
118{ 122{
123 MAGIC *mg;
124
119 if (!sv_derived_from (sv, AIO_REQ_KLASS) || !SvROK (sv)) 125 if (!sv_derived_from (sv, AIO_REQ_KLASS) || !SvROK (sv))
120 croak ("object of class " AIO_REQ_KLASS " expected"); 126 croak ("object of class " AIO_REQ_KLASS " expected");
121 127
122 MAGIC *mg = mg_find (SvRV (sv), PERL_MAGIC_ext); 128 mg = mg_find (SvRV (sv), PERL_MAGIC_ext);
123 129
124 return mg ? (aio_req)mg->mg_ptr : 0; 130 return mg ? (aio_req)mg->mg_ptr : 0;
131}
132
133static void aio_grp_feed (aio_req grp)
134{
135 while (grp->length < grp->fd2)
136 {
137 int old_len = grp->length;
138
139 if (grp->fh2 && SvOK (grp->fh2))
140 {
141 dSP;
142
143 ENTER;
144 SAVETMPS;
145 PUSHMARK (SP);
146 XPUSHs (req_sv (grp, AIO_GRP_KLASS));
147 PUTBACK;
148 call_sv (grp->fh2, G_VOID | G_EVAL);
149 SPAGAIN;
150 FREETMPS;
151 LEAVE;
152 }
153
154 /* stop if no progress has been made */
155 if (old_len == grp->length)
156 {
157 SvREFCNT_dec (grp->fh2);
158 grp->fh2 = 0;
159 break;
160 }
161 }
162}
163
164static void aio_grp_dec (aio_req grp)
165{
166 --grp->length;
167
168 /* call feeder, if applicable */
169 aio_grp_feed (grp);
170
171 /* finish, if done */
172 if (!grp->length && grp->fd)
173 {
174 req_invoke (grp);
175 req_free (grp);
176 }
125} 177}
126 178
127static void poll_wait () 179static void poll_wait ()
128{ 180{
129 if (nreqs && !ress) 181 if (nreqs && !ress)
… …
145 return; 197 return;
146 198
147 errno = req->errorno; 199 errno = req->errorno;
148 200
149 ENTER; 201 ENTER;
202 SAVETMPS;
150 PUSHMARK (SP); 203 PUSHMARK (SP);
151 EXTEND (SP, 1); 204 EXTEND (SP, 1);
152 205
153 switch (req->type) 206 switch (req->type)
154 { 207 {
… …
193 XPUSHs (sv_2mortal (fh)); 246 XPUSHs (sv_2mortal (fh));
194 } 247 }
195 break; 248 break;
196 249
197 case REQ_GROUP: 250 case REQ_GROUP:
251 req->fd = 2; /* mark group as finished */
252
198 if (req->data) 253 if (req->data)
199 { 254 {
200 int i; 255 int i;
201 AV *av = (AV *)req->data; 256 AV *av = (AV *)req->data;
202 257
… …
204 for (i = 0; i <= AvFILL (av); ++i) 259 for (i = 0; i <= AvFILL (av); ++i)
205 PUSHs (*av_fetch (av, i, 0)); 260 PUSHs (*av_fetch (av, i, 0));
206 } 261 }
207 break; 262 break;
208 263
264 case REQ_NOP:
209 case REQ_SLEEP: 265 case REQ_SLEEP:
210 break; 266 break;
211 267
212 default: 268 default:
213 PUSHs (sv_2mortal (newSViv (req->result))); 269 PUSHs (sv_2mortal (newSViv (req->result)));
… …
217 273
218 PUTBACK; 274 PUTBACK;
219 call_sv (req->callback, G_VOID | G_EVAL); 275 call_sv (req->callback, G_VOID | G_EVAL);
220 SPAGAIN; 276 SPAGAIN;
221 277
278 FREETMPS;
279 LEAVE;
280
281 errno = errorno;
282
222 if (SvTRUE (ERRSV)) 283 if (SvTRUE (ERRSV))
223 { 284 {
224 req_free (req); 285 req_free (req);
225 croak (0); 286 croak (0);
226 } 287 }
227
228 LEAVE;
229
230 errno = errorno;
231} 288}
232 289
233static void req_free (aio_req req) 290static void req_free (aio_req req)
234{ 291{
235 if (req->grp) 292 if (req->grp)
236 { 293 {
237 aio_req grp = req->grp; 294 aio_req grp = req->grp;
238 295
239 /* unlink request */ 296 /* unlink request */
240 req->grp_next->grp_prev = req->grp_prev; 297 if (req->grp_next) req->grp_next->grp_prev = req->grp_prev;
241 req->grp_prev->grp_next = req->grp_next; 298 if (req->grp_prev) req->grp_prev->grp_next = req->grp_next;
242 299
243 if (grp->grp_next == grp && grp->fd) 300 if (grp->grp_first == req)
244 { 301 grp->grp_first = req->grp_next;
245 req_invoke (grp); 302
246 req_free (grp); 303 aio_grp_dec (grp);
247 }
248 } 304 }
249 305
250 if (req->self) 306 if (req->self)
251 { 307 {
252 sv_unmagic (req->self, PERL_MAGIC_ext); 308 sv_unmagic (req->self, PERL_MAGIC_ext);
253 SvREFCNT_dec (req->self); 309 SvREFCNT_dec (req->self);
254 } 310 }
255 311
256 if (req->data)
257 SvREFCNT_dec (req->data); 312 SvREFCNT_dec (req->data);
258
259 if (req->fh)
260 SvREFCNT_dec (req->fh); 313 SvREFCNT_dec (req->fh);
261
262 if (req->fh2)
263 SvREFCNT_dec (req->fh2); 314 SvREFCNT_dec (req->fh2);
264
265 if (req->statdata)
266 Safefree (req->statdata);
267
268 if (req->callback)
269 SvREFCNT_dec (req->callback); 315 SvREFCNT_dec (req->callback);
316 Safefree (req->statdata);
270 317
271 if (req->type == REQ_READDIR && req->result >= 0) 318 if (req->type == REQ_READDIR && req->result >= 0)
272 free (req->data2ptr); 319 free (req->data2ptr);
273 320
274 Safefree (req); 321 Safefree (req);
… …
280 327
281 if (req->type == REQ_GROUP) 328 if (req->type == REQ_GROUP)
282 { 329 {
283 aio_req sub; 330 aio_req sub;
284 331
285 for (sub = req->grp_next; sub != req; sub = sub->grp_next) 332 for (sub = req->grp_first; sub; sub = sub->grp_next)
286 req_cancel (sub); 333 req_cancel (sub);
287 } 334 }
288} 335}
289 336
290static int poll_cb () 337static int poll_cb ()
… …
317 pthread_mutex_unlock (&reslock); 364 pthread_mutex_unlock (&reslock);
318 365
319 if (!req) 366 if (!req)
320 break; 367 break;
321 368
322 nreqs--; 369 --nreqs;
323 370
324 if (req->type == REQ_QUIT) 371 if (req->type == REQ_QUIT)
325 started--; 372 started--;
326 else if (req->type == REQ_GROUP && req->grp_next != req) 373 else if (req->type == REQ_GROUP && req->length)
327 { 374 {
328 req->fd = 1; /* mark request as delayed */ 375 req->fd = 1; /* mark request as delayed */
329 continue; 376 continue;
330 } 377 }
331 else 378 else
… …
378static void req_send (aio_req req) 425static void req_send (aio_req req)
379{ 426{
380 while (started < wanted && nreqs >= started) 427 while (started < wanted && nreqs >= started)
381 start_thread (); 428 start_thread ();
382 429
383 nreqs++; 430 ++nreqs;
384 431
385 pthread_mutex_lock (&reqlock); 432 pthread_mutex_lock (&reqlock);
386 433
387 req->next = 0; 434 req->next = 0;
388 435
… …
740 pthread_mutex_unlock (&reqlock); 787 pthread_mutex_unlock (&reqlock);
741 788
742 errno = 0; /* strictly unnecessary */ 789 errno = 0; /* strictly unnecessary */
743 790
744 if (!req->cancelled) 791 if (!req->cancelled)
745 switch (req->type) 792 switch (type = req->type) /* remember type for QUIT check */
746 { 793 {
747 case REQ_READ: req->result = pread (req->fd, req->dataptr, req->length, req->offset); break; 794 case REQ_READ: req->result = pread (req->fd, req->dataptr, req->length, req->offset); break;
748 case REQ_WRITE: req->result = pwrite (req->fd, req->dataptr, req->length, req->offset); break; 795 case REQ_WRITE: req->result = pwrite (req->fd, req->dataptr, req->length, req->offset); break;
749 796
750 case REQ_READAHEAD: req->result = readahead (req->fd, req->offset, req->length); break; 797 case REQ_READAHEAD: req->result = readahead (req->fd, req->offset, req->length); break;
… …
774 tv.tv_usec = req->fd2; 821 tv.tv_usec = req->fd2;
775 822
776 req->result = select (0, 0, 0, 0, &tv); 823 req->result = select (0, 0, 0, 0, &tv);
777 } 824 }
778 825
826 case REQ_GROUP:
827 case REQ_NOP:
779 case REQ_QUIT: 828 case REQ_QUIT:
780 break; 829 break;
781 830
782 default: 831 default:
783 req->result = ENOSYS; 832 req->result = ENOSYS;
… …
1161 PROTOTYPE: ;$ 1210 PROTOTYPE: ;$
1162 PPCODE: 1211 PPCODE:
1163{ 1212{
1164 dREQ; 1213 dREQ;
1165 req->type = REQ_GROUP; 1214 req->type = REQ_GROUP;
1166 req->grp_next = req;
1167 req->grp_prev = req;
1168
1169 req_send (req); 1215 req_send (req);
1170 XPUSHs (req_sv (req, AIO_GRP_KLASS)); 1216 XPUSHs (req_sv (req, AIO_GRP_KLASS));
1217}
1218
1219void
1220aio_nop (callback=&PL_sv_undef)
1221 SV * callback
1222 PPCODE:
1223{
1224 dREQ;
1225
1226 req->type = REQ_NOP;
1227
1228 REQ_SEND;
1171} 1229}
1172 1230
1173void 1231void
1174flush () 1232flush ()
1175 PROTOTYPE: 1233 PROTOTYPE:
… …
1229cancel (aio_req_ornot req) 1287cancel (aio_req_ornot req)
1230 PROTOTYPE: 1288 PROTOTYPE:
1231 CODE: 1289 CODE:
1232 req_cancel (req); 1290 req_cancel (req);
1233 1291
1292void
1293cb (aio_req req, SV *callback=&PL_sv_undef)
1294 CODE:
1295 SvREFCNT_dec (req->callback);
1296 req->callback = newSVsv (callback);
1297
1234MODULE = IO::AIO PACKAGE = IO::AIO::GRP 1298MODULE = IO::AIO PACKAGE = IO::AIO::GRP
1235 1299
1236void 1300void
1237add (aio_req grp, ...) 1301add (aio_req grp, ...)
1238 PPCODE: 1302 PPCODE:
1239{ 1303{
1240 int i; 1304 int i;
1305 aio_req req;
1306
1307 if (grp->fd == 2)
1308 croak ("cannot add requests to IO::AIO::GRP after the group finished");
1241 1309
1242 for (i = 1; i < items; ++i ) 1310 for (i = 1; i < items; ++i )
1243 { 1311 {
1244 if (GIMME_V != G_VOID) 1312 if (GIMME_V != G_VOID)
1245 XPUSHs (sv_2mortal (newSVsv (ST (i)))); 1313 XPUSHs (sv_2mortal (newSVsv (ST (i))));
1246 1314
1247 aio_req req = SvAIO_REQ (ST (i)); 1315 req = SvAIO_REQ (ST (i));
1248 1316
1249 if (req) 1317 if (req)
1250 { 1318 {
1251 req->grp_prev = grp; 1319 ++grp->length;
1252 req->grp_next = grp->grp_next;
1253 grp->grp_next->grp_prev = req;
1254 grp->grp_next = req;
1255
1256 req->grp = grp; 1320 req->grp = grp;
1321
1322 req->grp_prev = 0;
1323 req->grp_next = grp->grp_first;
1324
1325 if (grp->grp_first)
1326 grp->grp_first->grp_prev = req;
1327
1328 grp->grp_first = req;
1257 } 1329 }
1258 } 1330 }
1259} 1331}
1260 1332
1261void 1333void
1262result (aio_req grp, ...) 1334result (aio_req grp, ...)
1335 CODE:
1336{
1337 int i;
1338 AV *av = newAV ();
1339
1340 for (i = 1; i < items; ++i )
1341 av_push (av, newSVsv (ST (i)));
1342
1343 SvREFCNT_dec (grp->data);
1344 grp->data = (SV *)av;
1345}
1346
1347void
1348feed_limit (aio_req grp, int limit)
1263 CODE: 1349 CODE:
1264{ 1350 grp->fd2 = limit;
1265 int i; 1351 aio_grp_feed (grp);
1266 AV *av = newAV ();
1267 1352
1268 if (grp->data) 1353void
1354feed (aio_req grp, SV *callback=&PL_sv_undef)
1355 CODE:
1356{
1269 SvREFCNT_dec (grp->data); 1357 SvREFCNT_dec (grp->fh2);
1358 grp->fh2 = newSVsv (callback);
1270 1359
1271 for (i = 1; i < items; ++i ) 1360 if (grp->fd2 <= 0)
1272 av_push (av, newSVsv (ST (i))); 1361 grp->fd2 = 2;
1273 1362
1274 grp->data = (SV *)av; 1363 aio_grp_feed (grp);
1275} 1364}
1276 1365

Diff Legend

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