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.47 by root, Sun Oct 22 10:10:23 2006 UTC vs.
Revision 1.52 by root, Sun Oct 22 22:14:54 2006 UTC

… …
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)
… …
120 croak ("object of class " AIO_REQ_KLASS " expected"); 124 croak ("object of class " AIO_REQ_KLASS " expected");
121 125
122 MAGIC *mg = mg_find (SvRV (sv), PERL_MAGIC_ext); 126 MAGIC *mg = mg_find (SvRV (sv), PERL_MAGIC_ext);
123 127
124 return mg ? (aio_req)mg->mg_ptr : 0; 128 return mg ? (aio_req)mg->mg_ptr : 0;
129}
130
131static void aio_grp_feed (aio_req grp)
132{
133 while (grp->length < grp->fd2)
134 {
135 int old_len = grp->length;
136
137 if (grp->fh2 && SvOK (grp->fh2))
138 {
139 dSP;
140
141 ENTER;
142 SAVETMPS;
143 PUSHMARK (SP);
144 XPUSHs (req_sv (grp, AIO_GRP_KLASS));
145 PUTBACK;
146 call_sv (grp->fh2, G_VOID | G_EVAL);
147 SPAGAIN;
148 FREETMPS;
149 LEAVE;
150 }
151
152 /* stop if no progress has been made */
153 if (old_len == grp->length)
154 {
155 SvREFCNT_dec (grp->fh2);
156 grp->fh2 = 0;
157 break;
158 }
159 }
160}
161
162static void aio_grp_dec (aio_req grp)
163{
164 --grp->length;
165
166 /* call feeder, if applicable */
167 aio_grp_feed (grp);
168
169 /* finish, if done */
170 if (!grp->length && grp->fd)
171 {
172 req_invoke (grp);
173 req_free (grp);
174 }
125} 175}
126 176
127static void poll_wait () 177static void poll_wait ()
128{ 178{
129 if (nreqs && !ress) 179 if (nreqs && !ress)
… …
145 return; 195 return;
146 196
147 errno = req->errorno; 197 errno = req->errorno;
148 198
149 ENTER; 199 ENTER;
200 SAVETMPS;
150 PUSHMARK (SP); 201 PUSHMARK (SP);
202 EXTEND (SP, 1);
151 203
152 switch (req->type) 204 switch (req->type)
153 { 205 {
154 case REQ_READDIR: 206 case REQ_READDIR:
155 { 207 {
… …
170 } 222 }
171 223
172 rv = sv_2mortal (newRV_noinc ((SV *)av)); 224 rv = sv_2mortal (newRV_noinc ((SV *)av));
173 } 225 }
174 226
175 XPUSHs (rv); 227 PUSHs (rv);
176 } 228 }
177 break; 229 break;
178 230
179 case REQ_OPEN: 231 case REQ_OPEN:
180 { 232 {
181 /* convert fd to fh */ 233 /* convert fd to fh */
182 SV *fh; 234 SV *fh;
183 235
184 XPUSHs (sv_2mortal (newSViv (req->result))); 236 PUSHs (sv_2mortal (newSViv (req->result)));
185 PUTBACK; 237 PUTBACK;
186 call_pv ("IO::AIO::_fd2fh", G_SCALAR | G_EVAL); 238 call_pv ("IO::AIO::_fd2fh", G_SCALAR | G_EVAL);
187 SPAGAIN; 239 SPAGAIN;
188 240
189 fh = SvREFCNT_inc (POPs); 241 fh = SvREFCNT_inc (POPs);
… …
191 PUSHMARK (SP); 243 PUSHMARK (SP);
192 XPUSHs (sv_2mortal (fh)); 244 XPUSHs (sv_2mortal (fh));
193 } 245 }
194 break; 246 break;
195 247
248 case REQ_GROUP:
249 req->fd = 2; /* mark group as finished */
250
251 if (req->data)
252 {
253 int i;
254 AV *av = (AV *)req->data;
255
256 EXTEND (SP, AvFILL (av) + 1);
257 for (i = 0; i <= AvFILL (av); ++i)
258 PUSHs (*av_fetch (av, i, 0));
259 }
260 break;
261
196 case REQ_SLEEP: 262 case REQ_SLEEP:
197 case REQ_GROUP:
198 break; 263 break;
199 264
200 default: 265 default:
201 XPUSHs (sv_2mortal (newSViv (req->result))); 266 PUSHs (sv_2mortal (newSViv (req->result)));
202 break; 267 break;
203 } 268 }
204 269
205 270
206 PUTBACK; 271 PUTBACK;
207 call_sv (req->callback, G_VOID | G_EVAL); 272 call_sv (req->callback, G_VOID | G_EVAL);
208 SPAGAIN; 273 SPAGAIN;
209 274
275 FREETMPS;
276 LEAVE;
277
278 errno = errorno;
279
210 if (SvTRUE (ERRSV)) 280 if (SvTRUE (ERRSV))
211 { 281 {
212 req_free (req); 282 req_free (req);
213 croak (0); 283 croak (0);
214 } 284 }
215
216 LEAVE;
217
218 errno = errorno;
219} 285}
220 286
221static void req_free (aio_req req) 287static void req_free (aio_req req)
222{ 288{
223 if (req->grp) 289 if (req->grp)
224 { 290 {
225 aio_req grp = req->grp; 291 aio_req grp = req->grp;
226 292
227 /* unlink request */ 293 /* unlink request */
228 req->grp_next->grp_prev = req->grp_prev; 294 if (req->grp_next) req->grp_next->grp_prev = req->grp_prev;
229 req->grp_prev->grp_next = req->grp_next; 295 if (req->grp_prev) req->grp_prev->grp_next = req->grp_next;
230 296
231 if (grp->grp_next == grp && grp->fd) 297 if (grp->grp_first == req)
232 { 298 grp->grp_first = req->grp_next;
233 req_invoke (grp); 299
234 req_free (grp); 300 aio_grp_dec (grp);
235 }
236 } 301 }
237 302
238 if (req->self) 303 if (req->self)
239 { 304 {
240 sv_unmagic (req->self, PERL_MAGIC_ext); 305 sv_unmagic (req->self, PERL_MAGIC_ext);
241 SvREFCNT_dec (req->self); 306 SvREFCNT_dec (req->self);
242 } 307 }
243 308
244 if (req->data)
245 SvREFCNT_dec (req->data); 309 SvREFCNT_dec (req->data);
246
247 if (req->fh)
248 SvREFCNT_dec (req->fh); 310 SvREFCNT_dec (req->fh);
249
250 if (req->fh2)
251 SvREFCNT_dec (req->fh2); 311 SvREFCNT_dec (req->fh2);
252
253 if (req->statdata)
254 Safefree (req->statdata);
255
256 if (req->callback)
257 SvREFCNT_dec (req->callback); 312 SvREFCNT_dec (req->callback);
313 Safefree (req->statdata);
258 314
259 if (req->type == REQ_READDIR && req->result >= 0) 315 if (req->type == REQ_READDIR && req->result >= 0)
260 free (req->data2ptr); 316 free (req->data2ptr);
261 317
262 Safefree (req); 318 Safefree (req);
… …
268 324
269 if (req->type == REQ_GROUP) 325 if (req->type == REQ_GROUP)
270 { 326 {
271 aio_req sub; 327 aio_req sub;
272 328
273 for (sub = req->grp_next; sub != req; sub = sub->grp_next) 329 for (sub = req->grp_first; sub; sub = sub->grp_next)
274 req_cancel (sub); 330 req_cancel (sub);
275 } 331 }
276} 332}
277 333
278static int poll_cb () 334static int poll_cb ()
… …
305 pthread_mutex_unlock (&reslock); 361 pthread_mutex_unlock (&reslock);
306 362
307 if (!req) 363 if (!req)
308 break; 364 break;
309 365
310 nreqs--; 366 --nreqs;
311 367
312 if (req->type == REQ_QUIT) 368 if (req->type == REQ_QUIT)
313 started--; 369 started--;
314 else if (req->type == REQ_GROUP && req->grp_next != req) 370 else if (req->type == REQ_GROUP && req->length)
315 { 371 {
316 req->fd = 1; /* mark request as delayed */ 372 req->fd = 1; /* mark request as delayed */
317 continue; 373 continue;
318 } 374 }
319 else 375 else
… …
366static void req_send (aio_req req) 422static void req_send (aio_req req)
367{ 423{
368 while (started < wanted && nreqs >= started) 424 while (started < wanted && nreqs >= started)
369 start_thread (); 425 start_thread ();
370 426
371 nreqs++; 427 ++nreqs;
372 428
373 pthread_mutex_lock (&reqlock); 429 pthread_mutex_lock (&reqlock);
374 430
375 req->next = 0; 431 req->next = 0;
376 432
… …
728 pthread_mutex_unlock (&reqlock); 784 pthread_mutex_unlock (&reqlock);
729 785
730 errno = 0; /* strictly unnecessary */ 786 errno = 0; /* strictly unnecessary */
731 787
732 if (!req->cancelled) 788 if (!req->cancelled)
733 switch (req->type) 789 switch (type = req->type) /* remember type for QUIT check */
734 { 790 {
735 case REQ_READ: req->result = pread (req->fd, req->dataptr, req->length, req->offset); break; 791 case REQ_READ: req->result = pread (req->fd, req->dataptr, req->length, req->offset); break;
736 case REQ_WRITE: req->result = pwrite (req->fd, req->dataptr, req->length, req->offset); break; 792 case REQ_WRITE: req->result = pwrite (req->fd, req->dataptr, req->length, req->offset); break;
737 793
738 case REQ_READAHEAD: req->result = readahead (req->fd, req->offset, req->length); break; 794 case REQ_READAHEAD: req->result = readahead (req->fd, req->offset, req->length); break;
… …
1149 PROTOTYPE: ;$ 1205 PROTOTYPE: ;$
1150 PPCODE: 1206 PPCODE:
1151{ 1207{
1152 dREQ; 1208 dREQ;
1153 req->type = REQ_GROUP; 1209 req->type = REQ_GROUP;
1154 req->grp_next = req;
1155 req->grp_prev = req;
1156
1157 req_send (req); 1210 req_send (req);
1158 XPUSHs (req_sv (req, AIO_GRP_KLASS)); 1211 XPUSHs (req_sv (req, AIO_GRP_KLASS));
1159} 1212}
1160 1213
1161void 1214void
… …
1207 CODE: 1260 CODE:
1208 RETVAL = nreqs; 1261 RETVAL = nreqs;
1209 OUTPUT: 1262 OUTPUT:
1210 RETVAL 1263 RETVAL
1211 1264
1265PROTOTYPES: DISABLE
1266
1212MODULE = IO::AIO PACKAGE = IO::AIO::REQ 1267MODULE = IO::AIO PACKAGE = IO::AIO::REQ
1213 1268
1214void 1269void
1215cancel (aio_req_ornot req) 1270cancel (aio_req_ornot req)
1216 PROTOTYPE: 1271 PROTOTYPE:
… …
1219 1274
1220MODULE = IO::AIO PACKAGE = IO::AIO::GRP 1275MODULE = IO::AIO PACKAGE = IO::AIO::GRP
1221 1276
1222void 1277void
1223add (aio_req grp, ...) 1278add (aio_req grp, ...)
1224 PROTOTYPE: $;@
1225 PPCODE: 1279 PPCODE:
1226{ 1280{
1227 int i; 1281 int i;
1282
1283 if (grp->fd == 2)
1284 croak ("cannot add requests to IO::AIO::GRP after the group finished");
1228 1285
1229 for (i = 1; i < items; ++i ) 1286 for (i = 1; i < items; ++i )
1230 { 1287 {
1231 if (GIMME_V != G_VOID) 1288 if (GIMME_V != G_VOID)
1232 XPUSHs (sv_2mortal (newSVsv (ST (i)))); 1289 XPUSHs (sv_2mortal (newSVsv (ST (i))));
1233 1290
1234 aio_req req = SvAIO_REQ (ST (i)); 1291 aio_req req = SvAIO_REQ (ST (i));
1235 1292
1236 if (req) 1293 if (req)
1237 { 1294 {
1238 req->grp_prev = grp; 1295 ++grp->length;
1239 req->grp_next = grp->grp_next;
1240 grp->grp_next->grp_prev = req;
1241 grp->grp_next = req;
1242
1243 req->grp = grp; 1296 req->grp = grp;
1297
1298 req->grp_prev = 0;
1299 req->grp_next = grp->grp_first;
1300
1301 if (grp->grp_first)
1302 grp->grp_first->grp_prev = req;
1303
1304 grp->grp_first = req;
1244 } 1305 }
1245 } 1306 }
1246} 1307}
1247 1308
1309void
1310result (aio_req grp, ...)
1311 CODE:
1312{
1313 int i;
1314 AV *av = newAV ();
1315
1316 for (i = 1; i < items; ++i )
1317 av_push (av, newSVsv (ST (i)));
1318
1319 SvREFCNT_dec (grp->data);
1320 grp->data = (SV *)av;
1321}
1322
1323void
1324lock (aio_req grp)
1325 CODE:
1326 ++grp->length;
1327
1328void
1329unlock (aio_req grp)
1330 CODE:
1331 aio_grp_dec (grp);
1332
1333void
1334feeder_limit (aio_req grp, int limit)
1335 CODE:
1336 grp->fd2 = limit;
1337 aio_grp_feed (grp);
1338
1339void
1340set_feeder (aio_req grp, SV *callback=&PL_sv_undef)
1341 CODE:
1342{
1343 SvREFCNT_dec (grp->fh2);
1344 grp->fh2 = newSVsv (callback);
1345
1346 if (grp->fd2 <= 0)
1347 grp->fd2 = 2;
1348
1349 aio_grp_feed (grp);
1350}
1351

Diff Legend

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