ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/Coro/Coro/State.xs
(Generate patch)

Comparing Coro/Coro/State.xs (file contents):
Revision 1.392 by root, Fri Apr 29 15:43:27 2011 UTC vs.
Revision 1.393 by root, Fri Apr 29 17:38:56 2011 UTC

… …
196 int valgrind_id; 196 int valgrind_id;
197#endif 197#endif
198 unsigned char flags; 198 unsigned char flags;
199} coro_cctx; 199} coro_cctx;
200 200
201coro_cctx *cctx_current; /* the currently running cctx */ 201static coro_cctx *cctx_current; /* the currently running cctx */
202 202
203/*****************************************************************************/ 203/*****************************************************************************/
204 204
205enum { 205enum {
206 CF_RUNNING = 0x0001, /* coroutine is running */ 206 CF_RUNNING = 0x0001, /* coroutine is running */
207 CF_READY = 0x0002, /* coroutine is ready */ 207 CF_READY = 0x0002, /* coroutine is ready */
208 CF_NEW = 0x0004, /* has never been switched to */ 208 CF_NEW = 0x0004, /* has never been switched to */
209 CF_DESTROYED = 0x0008, /* coroutine data has been freed */ 209 CF_DESTROYED = 0x0008, /* coroutine data has been freed */
210 CF_SUSPENDED = 0x0010, /* coroutine can't be scheduled */ 210 CF_SUSPENDED = 0x0010, /* coroutine can't be scheduled */
211 CF_NOCANCEL = 0x0020, /* cannot cancel, set slf_frame.data to 1 (hackish) */
211}; 212};
212 213
213/* the structure where most of the perl state is stored, overlaid on the cxstack */ 214/* the structure where most of the perl state is stored, overlaid on the cxstack */
214typedef struct 215typedef struct
215{ 216{
… …
275typedef struct coro *Coro__State; 276typedef struct coro *Coro__State;
276typedef struct coro *Coro__State_or_hashref; 277typedef struct coro *Coro__State_or_hashref;
277 278
278/* the following variables are effectively part of the perl context */ 279/* the following variables are effectively part of the perl context */
279/* and get copied between struct coro and these variables */ 280/* and get copied between struct coro and these variables */
280/* the mainr easonw e don't support windows process emulation */ 281/* the main reason we don't support windows process emulation */
281static struct CoroSLF slf_frame; /* the current slf frame */ 282static struct CoroSLF slf_frame; /* the current slf frame */
282 283
283/** Coro ********************************************************************/ 284/** Coro ********************************************************************/
284 285
285#define CORO_PRIO_MAX 3 286#define CORO_PRIO_MAX 3
… …
1496cctx_destroy (coro_cctx *cctx) 1497cctx_destroy (coro_cctx *cctx)
1497{ 1498{
1498 if (!cctx) 1499 if (!cctx)
1499 return; 1500 return;
1500 1501
1501 assert (("FATAL: tried to destroy current cctx", cctx != cctx_current));//D temporary? 1502 assert (("FATAL: tried to destroy current cctx", cctx != cctx_current));
1502 1503
1503 --cctx_count; 1504 --cctx_count;
1504 coro_destroy (&cctx->cctx); 1505 coro_destroy (&cctx->cctx);
1505 1506
1506 /* coro_transfer creates new, empty cctx's */ 1507 /* coro_transfer creates new, empty cctx's */
… …
1673 if (coro->flags & CF_DESTROYED) 1674 if (coro->flags & CF_DESTROYED)
1674 return 0; 1675 return 0;
1675 1676
1676 if (coro->on_destroy && !PL_dirty) 1677 if (coro->on_destroy && !PL_dirty)
1677 coro->on_destroy (aTHX_ coro); 1678 coro->on_destroy (aTHX_ coro);
1679
1680 /*
1681 * The on_destroy above most likely is from an SLF call.
1682 * Since by definition the SLF call will not finish when we destroy
1683 * the coro, we will have to force-finish it here, otherwise
1684 * cleanup functions cannot call SLF functions.
1685 */
1686 coro->slf_frame.prepare = 0;
1678 1687
1679 coro->flags |= CF_DESTROYED; 1688 coro->flags |= CF_DESTROYED;
1680 1689
1681 if (coro->flags & CF_READY) 1690 if (coro->flags & CF_READY)
1682 { 1691 {
… …
2093 coro = SvSTATE (arg [0]); 2102 coro = SvSTATE (arg [0]);
2094 coro_hv = coro->hv; 2103 coro_hv = coro->hv;
2095 2104
2096 coro_set_status (coro_hv, arg + 1, items - 1); 2105 coro_set_status (coro_hv, arg + 1, items - 1);
2097 2106
2107 if (expect_false (coro->flags & CF_NOCANCEL))
2108 {
2109 /* coro currently busy cancelling something, so just notify it */
2110 coro->slf_frame.data = (void *)coro;
2111
2112 frame->prepare = prepare_nop;
2113 frame->check = slf_check_nop;
2114 }
2115 else if (coro_hv == (HV *)SvRV (coro_current))
2116 {
2098 /* cancelling the current coro is allowed, and equals terminate */ 2117 /* cancelling the current coro is allowed, and equals terminate */
2099 if (coro_hv == (HV *)SvRV (coro_current))
2100 slf_init_terminate_cancel_common (frame, coro_hv); 2118 slf_init_terminate_cancel_common (frame, coro_hv);
2119 }
2101 else 2120 else
2102 { 2121 {
2103 /* otherwise we cancel ourselves */ 2122 struct coro *self = SvSTATE_current;
2123
2124 /* otherwise we cancel directly, purely for speed reasons
2125 * unfortunately, this requires some magic trickery, as
2126 * somebody else could cancel us, so we have to fight the cancellation.
2127 * this is ugly, and hopefully fully worth the extra speed.
2128 * besides, I can't get the slow-but-safe version working...
2129 */
2130 slf_frame.data = 0;
2131 self->flags |= CF_NOCANCEL;
2132
2104 coro_state_destroy (aTHX_ coro); 2133 coro_state_destroy (aTHX_ coro);
2105 coro_call_on_destroy (aTHX_ coro); 2134 coro_call_on_destroy (aTHX_ coro);
2106 2135
2136 self->flags &= ~CF_NOCANCEL;
2137
2138 if (slf_frame.data)
2139 {
2140 /* while we were busy we have been cancelled, so terminate */
2141 slf_init_terminate_cancel_common (frame, self->hv);
2142 }
2143 else
2144 {
2107 frame->prepare = prepare_nop; 2145 frame->prepare = prepare_nop;
2108 frame->check = slf_check_nop; 2146 frame->check = slf_check_nop;
2147 }
2109 } 2148 }
2110} 2149}
2111 2150
2112/*****************************************************************************/ 2151/*****************************************************************************/
2113/* async pool handler */ 2152/* async pool handler */
… …
3307 CODE: 3346 CODE:
3308{ 3347{
3309 if (coro->mainstack && ((coro->flags & CF_RUNNING) || coro->slot)) 3348 if (coro->mainstack && ((coro->flags & CF_RUNNING) || coro->slot))
3310 { 3349 {
3311 struct coro *current = SvSTATE_current; 3350 struct coro *current = SvSTATE_current;
3351 struct CoroSLF slf_save;
3312 3352
3313 if (current != coro) 3353 if (current != coro)
3314 { 3354 {
3315 PUTBACK; 3355 PUTBACK;
3316 save_perl (aTHX_ current); 3356 save_perl (aTHX_ current);
3317 load_perl (aTHX_ coro); 3357 load_perl (aTHX_ coro);
3358 /* the coro is most likely in an active SLF call.
3359 * while not strictly required (the code we execute is
3360 * not allowed to call any SLF functions), it's cleaner
3361 * to reinitialise the slf_frame and restore it later.
3362 * This might one day allow us to actually do SLF calls
3363 * from code executed here.
3364 */
3365 slf_save = slf_frame;
3366 slf_frame.prepare = 0;
3318 SPAGAIN; 3367 SPAGAIN;
3319 } 3368 }
3320 3369
3321 PUSHSTACK; 3370 PUSHSTACK;
3322 3371
… …
3332 SPAGAIN; 3381 SPAGAIN;
3333 3382
3334 if (current != coro) 3383 if (current != coro)
3335 { 3384 {
3336 PUTBACK; 3385 PUTBACK;
3386 slf_frame = slf_save;
3337 save_perl (aTHX_ coro); 3387 save_perl (aTHX_ coro);
3338 load_perl (aTHX_ current); 3388 load_perl (aTHX_ current);
3339 SPAGAIN; 3389 SPAGAIN;
3340 } 3390 }
3341 } 3391 }

Diff Legend

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