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.391 by root, Thu Mar 31 04:24:19 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
… …
356 357
357 require_pv ("Time/HiRes.pm"); 358 require_pv ("Time/HiRes.pm");
358 359
359 svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0); 360 svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
360 361
361 if (!svp) croak ("Time::HiRes is required, but missing."); 362 if (!svp) croak ("Time::HiRes is required, but missing. Caught");
362 if (!SvIOK (*svp)) croak ("Time::NVtime isn't a function pointer"); 363 if (!SvIOK (*svp)) croak ("Time::NVtime isn't a function pointer. Caught");
363 364
364 nvtime = INT2PTR (double (*)(), SvIV (*svp)); 365 nvtime = INT2PTR (double (*)(), SvIV (*svp));
365 366
366 svp = hv_fetch (PL_modglobal, "Time::U2time", 12, 0); 367 svp = hv_fetch (PL_modglobal, "Time::U2time", 12, 0);
367 u2time = INT2PTR (void (*)(pTHX_ UV ret[2]), SvIV (*svp)); 368 u2time = INT2PTR (void (*)(pTHX_ UV ret[2]), SvIV (*svp));
… …
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 {
… …
2038 } 2047 }
2039 } 2048 }
2040} 2049}
2041 2050
2042static void 2051static void
2043slf_init_terminate (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items) 2052coro_set_status (HV *coro_hv, SV **arg, int items)
2044{ 2053{
2045 int i;
2046 HV *hv = (HV *)SvRV (coro_current);
2047 AV *av = newAV (); 2054 AV *av = newAV ();
2048 2055
2049 /* items are actually not so common, so optimise for this case */ 2056 /* items are actually not so common, so optimise for this case */
2050 if (items) 2057 if (items)
2051 { 2058 {
2059 int i;
2060
2052 av_extend (av, items - 1); 2061 av_extend (av, items - 1);
2053 2062
2054 for (i = 0; i < items; ++i) 2063 for (i = 0; i < items; ++i)
2055 av_push (av, SvREFCNT_inc_NN (arg [i])); 2064 av_push (av, SvREFCNT_inc_NN (arg [i]));
2056 } 2065 }
2057 2066
2058 hv_store (hv, "_status", sizeof ("_status") - 1, newRV_noinc ((SV *)av), 0); 2067 hv_store (coro_hv, "_status", sizeof ("_status") - 1, newRV_noinc ((SV *)av), 0);
2068}
2059 2069
2070static void
2071slf_init_terminate_cancel_common (pTHX_ struct CoroSLF *frame, HV *coro_hv)
2072{
2060 av_push (av_destroy, (SV *)newRV_inc ((SV *)hv)); /* RVinc for perl */ 2073 av_push (av_destroy, (SV *)newRV_inc ((SV *)coro_hv)); /* RVinc for perl */
2061 api_ready (aTHX_ sv_manager); 2074 api_ready (aTHX_ sv_manager);
2062 2075
2063 frame->prepare = prepare_schedule; 2076 frame->prepare = prepare_schedule;
2064 frame->check = slf_check_repeat; 2077 frame->check = slf_check_repeat;
2065 2078
2066 /* as a minor optimisation, we could unwind all stacks here */ 2079 /* as a minor optimisation, we could unwind all stacks here */
2067 /* but that puts extra pressure on pp_slf, and is not worth much */ 2080 /* but that puts extra pressure on pp_slf, and is not worth much */
2068 /*coro_unwind_stacks (aTHX);*/ 2081 /*coro_unwind_stacks (aTHX);*/
2082}
2083
2084static void
2085slf_init_terminate (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2086{
2087 HV *coro_hv = (HV *)SvRV (coro_current);
2088
2089 coro_set_status (coro_hv, arg, items);
2090 slf_init_terminate_cancel_common (frame, coro_hv);
2091}
2092
2093static void
2094slf_init_cancel (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2095{
2096 HV *coro_hv;
2097 struct coro *coro;
2098
2099 if (items <= 0)
2100 croak ("Coro::cancel called without coro object,");
2101
2102 coro = SvSTATE (arg [0]);
2103 coro_hv = coro->hv;
2104
2105 coro_set_status (coro_hv, arg + 1, items - 1);
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 {
2117 /* cancelling the current coro is allowed, and equals terminate */
2118 slf_init_terminate_cancel_common (frame, coro_hv);
2119 }
2120 else
2121 {
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
2133 coro_state_destroy (aTHX_ coro);
2134 coro_call_on_destroy (aTHX_ coro);
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 {
2145 frame->prepare = prepare_nop;
2146 frame->check = slf_check_nop;
2147 }
2148 }
2069} 2149}
2070 2150
2071/*****************************************************************************/ 2151/*****************************************************************************/
2072/* async pool handler */ 2152/* async pool handler */
2073 2153
… …
3182transfer (...) 3262transfer (...)
3183 PROTOTYPE: $$ 3263 PROTOTYPE: $$
3184 CODE: 3264 CODE:
3185 CORO_EXECUTE_SLF_XS (slf_init_transfer); 3265 CORO_EXECUTE_SLF_XS (slf_init_transfer);
3186 3266
3187bool
3188_destroy (SV *coro_sv)
3189 CODE:
3190 RETVAL = coro_state_destroy (aTHX_ SvSTATE (coro_sv));
3191 OUTPUT:
3192 RETVAL
3193
3194void 3267void
3195_exit (int code) 3268_exit (int code)
3196 PROTOTYPE: $ 3269 PROTOTYPE: $
3197 CODE: 3270 CODE:
3198 _exit (code); 3271 _exit (code);
… …
3273 CODE: 3346 CODE:
3274{ 3347{
3275 if (coro->mainstack && ((coro->flags & CF_RUNNING) || coro->slot)) 3348 if (coro->mainstack && ((coro->flags & CF_RUNNING) || coro->slot))
3276 { 3349 {
3277 struct coro *current = SvSTATE_current; 3350 struct coro *current = SvSTATE_current;
3351 struct CoroSLF slf_save;
3278 3352
3279 if (current != coro) 3353 if (current != coro)
3280 { 3354 {
3281 PUTBACK; 3355 PUTBACK;
3282 save_perl (aTHX_ current); 3356 save_perl (aTHX_ current);
3283 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;
3284 SPAGAIN; 3367 SPAGAIN;
3285 } 3368 }
3286 3369
3287 PUSHSTACK; 3370 PUSHSTACK;
3288 3371
… …
3298 SPAGAIN; 3381 SPAGAIN;
3299 3382
3300 if (current != coro) 3383 if (current != coro)
3301 { 3384 {
3302 PUTBACK; 3385 PUTBACK;
3386 slf_frame = slf_save;
3303 save_perl (aTHX_ coro); 3387 save_perl (aTHX_ coro);
3304 load_perl (aTHX_ current); 3388 load_perl (aTHX_ current);
3305 SPAGAIN; 3389 SPAGAIN;
3306 } 3390 }
3307 } 3391 }
… …
3393 3477
3394void 3478void
3395cancel (Coro::State self) 3479cancel (Coro::State self)
3396 CODE: 3480 CODE:
3397 coro_state_destroy (aTHX_ self); 3481 coro_state_destroy (aTHX_ self);
3398 coro_call_on_destroy (aTHX_ self); /* actually only for Coro objects */
3399 3482
3400SV * 3483SV *
3401enable_times (int enabled = enable_times) 3484enable_times (int enabled = enable_times)
3402 CODE: 3485 CODE:
3403{ 3486{
… …
3508 api_ready (aTHX_ RETVAL); 3591 api_ready (aTHX_ RETVAL);
3509 OUTPUT: 3592 OUTPUT:
3510 RETVAL 3593 RETVAL
3511 3594
3512void 3595void
3596_destroy (Coro::State coro)
3597 CODE:
3598 /* used by the manager thread */
3599 coro_state_destroy (aTHX_ coro);
3600 coro_call_on_destroy (aTHX_ coro);
3601
3602void
3513terminate (...) 3603terminate (...)
3514 CODE: 3604 CODE:
3515 CORO_EXECUTE_SLF_XS (slf_init_terminate); 3605 CORO_EXECUTE_SLF_XS (slf_init_terminate);
3606
3607void
3608cancel (...)
3609 CODE:
3610 CORO_EXECUTE_SLF_XS (slf_init_cancel);
3516 3611
3517void 3612void
3518schedule (...) 3613schedule (...)
3519 CODE: 3614 CODE:
3520 CORO_EXECUTE_SLF_XS (slf_init_schedule); 3615 CORO_EXECUTE_SLF_XS (slf_init_schedule);

Diff Legend

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