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.49 by root, Sun Oct 22 13:33:28 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;
… …
106static void req_free (aio_req req); 106static void req_free (aio_req req);
107 107
108/* must be called at most once */ 108/* must be called at most once */
109static SV *req_sv (aio_req req, const char *klass) 109static SV *req_sv (aio_req req, const char *klass)
110{ 110{
111 if (!req->self)
112 {
111 req->self = (SV *)newHV (); 113 req->self = (SV *)newHV ();
112 sv_magic (req->self, 0, PERL_MAGIC_ext, (char *)req, 0); 114 sv_magic (req->self, 0, PERL_MAGIC_ext, (char *)req, 0);
115 }
113 116
114 return sv_2mortal (sv_bless (newRV_inc (req->self), gv_stashpv (klass, 1))); 117 return sv_2mortal (sv_bless (newRV_inc (req->self), gv_stashpv (klass, 1)));
115} 118}
116 119
117static aio_req SvAIO_REQ (SV *sv) 120static aio_req SvAIO_REQ (SV *sv)
… …
120 croak ("object of class " AIO_REQ_KLASS " expected"); 123 croak ("object of class " AIO_REQ_KLASS " expected");
121 124
122 MAGIC *mg = mg_find (SvRV (sv), PERL_MAGIC_ext); 125 MAGIC *mg = mg_find (SvRV (sv), PERL_MAGIC_ext);
123 126
124 return mg ? (aio_req)mg->mg_ptr : 0; 127 return mg ? (aio_req)mg->mg_ptr : 0;
128}
129
130static void aio_grp_feed (aio_req grp)
131{
132 while (grp->length < grp->fd2)
133 {
134 int old_len = grp->length;
135
136 if (grp->fh2 && SvOK (grp->fh2))
137 {
138 dSP;
139
140 ENTER;
141 SAVETMPS;
142 PUSHMARK (SP);
143 XPUSHs (req_sv (grp, AIO_GRP_KLASS));
144 PUTBACK;
145 call_sv (grp->fh2, G_VOID | G_EVAL);
146 SPAGAIN;
147 FREETMPS;
148 LEAVE;
149 }
150
151 /* stop if no progress has been made */
152 if (old_len == grp->length)
153 {
154 SvREFCNT_dec (grp->fh2);
155 grp->fh2 = 0;
156 break;
157 }
158 }
125} 159}
126 160
127static void poll_wait () 161static void poll_wait ()
128{ 162{
129 if (nreqs && !ress) 163 if (nreqs && !ress)
… …
145 return; 179 return;
146 180
147 errno = req->errorno; 181 errno = req->errorno;
148 182
149 ENTER; 183 ENTER;
184 SAVETMPS;
150 PUSHMARK (SP); 185 PUSHMARK (SP);
151 EXTEND (SP, 1); 186 EXTEND (SP, 1);
152 187
153 switch (req->type) 188 switch (req->type)
154 { 189 {
… …
193 XPUSHs (sv_2mortal (fh)); 228 XPUSHs (sv_2mortal (fh));
194 } 229 }
195 break; 230 break;
196 231
197 case REQ_GROUP: 232 case REQ_GROUP:
233 req->fd = 2; /* mark group as finished */
234
198 if (req->data) 235 if (req->data)
199 { 236 {
200 int i; 237 int i;
201 AV *av = (AV *)req->data; 238 AV *av = (AV *)req->data;
202 239
… …
223 { 260 {
224 req_free (req); 261 req_free (req);
225 croak (0); 262 croak (0);
226 } 263 }
227 264
265 FREETMPS;
228 LEAVE; 266 LEAVE;
229 267
230 errno = errorno; 268 errno = errorno;
231} 269}
232 270
… …
235 if (req->grp) 273 if (req->grp)
236 { 274 {
237 aio_req grp = req->grp; 275 aio_req grp = req->grp;
238 276
239 /* unlink request */ 277 /* unlink request */
240 req->grp_next->grp_prev = req->grp_prev; 278 if (req->grp_next) req->grp_next->grp_prev = req->grp_prev;
241 req->grp_prev->grp_next = req->grp_next; 279 if (req->grp_prev) req->grp_prev->grp_next = req->grp_next;
242 280
281 if (grp->grp_first == req)
282 grp->grp_first = req->grp_next;
283
284 --grp->length;
285
286 /* call feeder, if applicable */
287 aio_grp_feed (grp);
288
289 /* finish, if done */
243 if (grp->grp_next == grp && grp->fd) 290 if (!grp->length && grp->fd)
244 { 291 {
245 req_invoke (grp); 292 req_invoke (grp);
246 req_free (grp); 293 req_free (grp);
247 } 294 }
248 } 295 }
… …
251 { 298 {
252 sv_unmagic (req->self, PERL_MAGIC_ext); 299 sv_unmagic (req->self, PERL_MAGIC_ext);
253 SvREFCNT_dec (req->self); 300 SvREFCNT_dec (req->self);
254 } 301 }
255 302
256 if (req->data)
257 SvREFCNT_dec (req->data); 303 SvREFCNT_dec (req->data);
258
259 if (req->fh)
260 SvREFCNT_dec (req->fh); 304 SvREFCNT_dec (req->fh);
261
262 if (req->fh2)
263 SvREFCNT_dec (req->fh2); 305 SvREFCNT_dec (req->fh2);
264
265 if (req->statdata)
266 Safefree (req->statdata);
267
268 if (req->callback)
269 SvREFCNT_dec (req->callback); 306 SvREFCNT_dec (req->callback);
307 Safefree (req->statdata);
270 308
271 if (req->type == REQ_READDIR && req->result >= 0) 309 if (req->type == REQ_READDIR && req->result >= 0)
272 free (req->data2ptr); 310 free (req->data2ptr);
273 311
274 Safefree (req); 312 Safefree (req);
… …
280 318
281 if (req->type == REQ_GROUP) 319 if (req->type == REQ_GROUP)
282 { 320 {
283 aio_req sub; 321 aio_req sub;
284 322
285 for (sub = req->grp_next; sub != req; sub = sub->grp_next) 323 for (sub = req->grp_first; sub; sub = sub->grp_next)
286 req_cancel (sub); 324 req_cancel (sub);
287 } 325 }
288} 326}
289 327
290static int poll_cb () 328static int poll_cb ()
… …
321 359
322 nreqs--; 360 nreqs--;
323 361
324 if (req->type == REQ_QUIT) 362 if (req->type == REQ_QUIT)
325 started--; 363 started--;
326 else if (req->type == REQ_GROUP && req->grp_next != req) 364 else if (req->type == REQ_GROUP && req->length)
327 { 365 {
328 req->fd = 1; /* mark request as delayed */ 366 req->fd = 1; /* mark request as delayed */
329 continue; 367 continue;
330 } 368 }
331 else 369 else
… …
1161 PROTOTYPE: ;$ 1199 PROTOTYPE: ;$
1162 PPCODE: 1200 PPCODE:
1163{ 1201{
1164 dREQ; 1202 dREQ;
1165 req->type = REQ_GROUP; 1203 req->type = REQ_GROUP;
1166 req->grp_next = req;
1167 req->grp_prev = req;
1168
1169 req_send (req); 1204 req_send (req);
1170 XPUSHs (req_sv (req, AIO_GRP_KLASS)); 1205 XPUSHs (req_sv (req, AIO_GRP_KLASS));
1171} 1206}
1172 1207
1173void 1208void
… …
1237add (aio_req grp, ...) 1272add (aio_req grp, ...)
1238 PPCODE: 1273 PPCODE:
1239{ 1274{
1240 int i; 1275 int i;
1241 1276
1277 if (grp->fd == 2)
1278 croak ("cannot add requests to IO::AIO::GRP after the group finished");
1279
1242 for (i = 1; i < items; ++i ) 1280 for (i = 1; i < items; ++i )
1243 { 1281 {
1244 if (GIMME_V != G_VOID) 1282 if (GIMME_V != G_VOID)
1245 XPUSHs (sv_2mortal (newSVsv (ST (i)))); 1283 XPUSHs (sv_2mortal (newSVsv (ST (i))));
1246 1284
1247 aio_req req = SvAIO_REQ (ST (i)); 1285 aio_req req = SvAIO_REQ (ST (i));
1248 1286
1249 if (req) 1287 if (req)
1250 { 1288 {
1251 req->grp_prev = grp; 1289 ++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; 1290 req->grp = grp;
1291
1292 req->grp_prev = 0;
1293 req->grp_next = grp->grp_first;
1294
1295 if (grp->grp_first)
1296 grp->grp_first->grp_prev = req;
1297
1298 grp->grp_first = req;
1257 } 1299 }
1258 } 1300 }
1259} 1301}
1260 1302
1261void 1303void
… …
1263 CODE: 1305 CODE:
1264{ 1306{
1265 int i; 1307 int i;
1266 AV *av = newAV (); 1308 AV *av = newAV ();
1267 1309
1268 if (grp->data)
1269 SvREFCNT_dec (grp->data);
1270
1271 for (i = 1; i < items; ++i ) 1310 for (i = 1; i < items; ++i )
1272 av_push (av, newSVsv (ST (i))); 1311 av_push (av, newSVsv (ST (i)));
1273 1312
1313 SvREFCNT_dec (grp->data);
1274 grp->data = (SV *)av; 1314 grp->data = (SV *)av;
1275} 1315}
1276 1316
1317void
1318feeder_limit (aio_req grp, int limit)
1319 CODE:
1320 grp->fd2 = limit;
1321 aio_grp_feed (grp);
1322
1323void
1324set_feeder (aio_req grp, SV *callback=&PL_sv_undef)
1325 CODE:
1326{
1327 SvREFCNT_dec (grp->fh2);
1328 grp->fh2 = newSVsv (callback);
1329
1330 if (grp->fd2 <= 0)
1331 grp->fd2 = 2;
1332
1333 aio_grp_feed (grp);
1334}
1335

Diff Legend

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