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.390 by root, Thu Mar 31 01:36:58 2011 UTC vs.
Revision 1.394 by root, Sat Apr 30 05:17:43 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 */
… …
1665#define TRANSFER(ta, force_cctx) transfer (aTHX_ (ta).prev, (ta).next, (force_cctx)) 1666#define TRANSFER(ta, force_cctx) transfer (aTHX_ (ta).prev, (ta).next, (force_cctx))
1666#define TRANSFER_CHECK(ta) transfer_check (aTHX_ (ta).prev, (ta).next) 1667#define TRANSFER_CHECK(ta) transfer_check (aTHX_ (ta).prev, (ta).next)
1667 1668
1668/** high level stuff ********************************************************/ 1669/** high level stuff ********************************************************/
1669 1670
1670static int 1671static void
1671coro_state_destroy (pTHX_ struct coro *coro) 1672coro_state_destroy (pTHX_ struct coro *coro)
1672{ 1673{
1673 if (coro->flags & CF_DESTROYED) 1674 if (coro->flags & CF_DESTROYED)
1674 return 0; 1675 return;
1675 1676
1677 /* this callback is reserved for slf functions needing to do cleanup */
1676 if (coro->on_destroy && !PL_dirty) 1678 if (coro->on_destroy && !PL_dirty)
1677 coro->on_destroy (aTHX_ coro); 1679 coro->on_destroy (aTHX_ coro);
1680
1681 /*
1682 * The on_destroy above most likely is from an SLF call.
1683 * Since by definition the SLF call will not finish when we destroy
1684 * the coro, we will have to force-finish it here, otherwise
1685 * cleanup functions cannot call SLF functions.
1686 */
1687 coro->slf_frame.prepare = 0;
1678 1688
1679 coro->flags |= CF_DESTROYED; 1689 coro->flags |= CF_DESTROYED;
1680 1690
1681 if (coro->flags & CF_READY) 1691 if (coro->flags & CF_READY)
1682 { 1692 {
… …
1700 cctx_destroy (coro->cctx); 1710 cctx_destroy (coro->cctx);
1701 SvREFCNT_dec (coro->startcv); 1711 SvREFCNT_dec (coro->startcv);
1702 SvREFCNT_dec (coro->args); 1712 SvREFCNT_dec (coro->args);
1703 SvREFCNT_dec (coro->swap_sv); 1713 SvREFCNT_dec (coro->swap_sv);
1704 SvREFCNT_dec (CORO_THROW); 1714 SvREFCNT_dec (CORO_THROW);
1705
1706 return 1;
1707} 1715}
1708 1716
1709static int 1717static int
1710coro_state_free (pTHX_ SV *sv, MAGIC *mg) 1718coro_state_free (pTHX_ SV *sv, MAGIC *mg)
1711{ 1719{
… …
2008 2016
2009static void 2017static void
2010coro_call_on_destroy (pTHX_ struct coro *coro) 2018coro_call_on_destroy (pTHX_ struct coro *coro)
2011{ 2019{
2012 SV **on_destroyp = hv_fetch (coro->hv, "_on_destroy", sizeof ("_on_destroy") - 1, 0); 2020 SV **on_destroyp = hv_fetch (coro->hv, "_on_destroy", sizeof ("_on_destroy") - 1, 0);
2013 SV **statusp = hv_fetch (coro->hv, "_status", sizeof ("_status") - 1, 0);
2014 2021
2015 if (on_destroyp) 2022 if (on_destroyp)
2016 { 2023 {
2017 AV *on_destroy = (AV *)SvRV (*on_destroyp); 2024 SV **statusp = hv_fetch (coro->hv, "_status", sizeof ("_status") - 1, 0);
2025 AV *on_destroy = sv_2mortal (SvREFCNT_inc ((AV *)SvRV (*on_destroyp)));
2026 AV *status = statusp ? sv_2mortal (SvREFCNT_inc ((AV *)SvRV (*statusp))) : 0;
2018 2027
2019 while (AvFILLp (on_destroy) >= 0) 2028 while (AvFILLp (on_destroy) >= 0)
2020 { 2029 {
2021 dSP; /* don't disturb outer sp */ 2030 dSP; /* don't disturb outer sp */
2022 SV *cb = av_pop (on_destroy); 2031 SV *cb = av_pop (on_destroy);
… …
2024 PUSHMARK (SP); 2033 PUSHMARK (SP);
2025 2034
2026 if (statusp) 2035 if (statusp)
2027 { 2036 {
2028 int i; 2037 int i;
2029 AV *status = (AV *)SvRV (*statusp);
2030 EXTEND (SP, AvFILLp (status) + 1); 2038 EXTEND (SP, AvFILLp (status) + 1);
2031 2039
2032 for (i = 0; i <= AvFILLp (status); ++i) 2040 for (i = 0; i <= AvFILLp (status); ++i)
2033 PUSHs (AvARRAY (status)[i]); 2041 PUSHs (AvARRAY (status)[i]);
2034 } 2042 }
… …
2038 } 2046 }
2039 } 2047 }
2040} 2048}
2041 2049
2042static void 2050static void
2043slf_init_terminate (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items) 2051coro_set_status (HV *coro_hv, SV **arg, int items)
2044{ 2052{
2045 int i;
2046 HV *hv = (HV *)SvRV (coro_current);
2047 AV *av = newAV (); 2053 AV *av = newAV ();
2048 2054
2049 /* items are actually not so common, so optimise for this case */ 2055 /* items are actually not so common, so optimise for this case */
2050 if (items) 2056 if (items)
2051 { 2057 {
2058 int i;
2059
2052 av_extend (av, items - 1); 2060 av_extend (av, items - 1);
2053 2061
2054 for (i = 0; i < items; ++i) 2062 for (i = 0; i < items; ++i)
2055 av_push (av, SvREFCNT_inc_NN (arg [i])); 2063 av_push (av, SvREFCNT_inc_NN (arg [i]));
2056 } 2064 }
2057 2065
2058 hv_store (hv, "_status", sizeof ("_status") - 1, newRV_noinc ((SV *)av), 0); 2066 hv_store (coro_hv, "_status", sizeof ("_status") - 1, newRV_noinc ((SV *)av), 0);
2067}
2059 2068
2069static void
2070slf_init_terminate_cancel_common (pTHX_ struct CoroSLF *frame, HV *coro_hv)
2071{
2060 av_push (av_destroy, (SV *)newRV_inc ((SV *)hv)); /* RVinc for perl */ 2072 av_push (av_destroy, (SV *)newRV_inc ((SV *)coro_hv)); /* RVinc for perl */
2061 api_ready (aTHX_ sv_manager); 2073 api_ready (aTHX_ sv_manager);
2062 2074
2063 frame->prepare = prepare_schedule; 2075 frame->prepare = prepare_schedule;
2064 frame->check = slf_check_repeat; 2076 frame->check = slf_check_repeat;
2065 2077
2066 /* as a minor optimisation, we could unwind all stacks here */ 2078 /* as a minor optimisation, we could unwind all stacks here */
2067 /* but that puts extra pressure on pp_slf, and is not worth much */ 2079 /* but that puts extra pressure on pp_slf, and is not worth much */
2068 /*coro_unwind_stacks (aTHX);*/ 2080 /*coro_unwind_stacks (aTHX);*/
2081}
2082
2083static void
2084slf_init_terminate (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2085{
2086 HV *coro_hv = (HV *)SvRV (coro_current);
2087
2088 coro_set_status (coro_hv, arg, items);
2089 slf_init_terminate_cancel_common (frame, coro_hv);
2090}
2091
2092static void
2093slf_init_cancel (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2094{
2095 HV *coro_hv;
2096 struct coro *coro;
2097
2098 if (items <= 0)
2099 croak ("Coro::cancel called without coro object,");
2100
2101 coro = SvSTATE (arg [0]);
2102 coro_hv = coro->hv;
2103
2104 coro_set_status (coro_hv, arg + 1, items - 1);
2105
2106 if (expect_false (coro->flags & CF_NOCANCEL))
2107 {
2108 /* coro currently busy cancelling something, so just notify it */
2109 coro->slf_frame.data = (void *)coro;
2110
2111 frame->prepare = prepare_nop;
2112 frame->check = slf_check_nop;
2113 }
2114 else if (coro_hv == (HV *)SvRV (coro_current))
2115 {
2116 /* cancelling the current coro is allowed, and equals terminate */
2117 slf_init_terminate_cancel_common (frame, coro_hv);
2118 }
2119 else
2120 {
2121 struct coro *self = SvSTATE_current;
2122
2123 /* otherwise we cancel directly, purely for speed reasons
2124 * unfortunately, this requires some magic trickery, as
2125 * somebody else could cancel us, so we have to fight the cancellation.
2126 * this is ugly, and hopefully fully worth the extra speed.
2127 * besides, I can't get the slow-but-safe version working...
2128 */
2129 slf_frame.data = 0;
2130 self->flags |= CF_NOCANCEL;
2131
2132 coro_state_destroy (aTHX_ coro);
2133 coro_call_on_destroy (aTHX_ coro);
2134
2135 self->flags &= ~CF_NOCANCEL;
2136
2137 if (slf_frame.data)
2138 {
2139 /* while we were busy we have been cancelled, so terminate */
2140 slf_init_terminate_cancel_common (frame, self->hv);
2141 }
2142 else
2143 {
2144 frame->prepare = prepare_nop;
2145 frame->check = slf_check_nop;
2146 }
2147 }
2069} 2148}
2070 2149
2071/*****************************************************************************/ 2150/*****************************************************************************/
2072/* async pool handler */ 2151/* async pool handler */
2073 2152
… …
3182transfer (...) 3261transfer (...)
3183 PROTOTYPE: $$ 3262 PROTOTYPE: $$
3184 CODE: 3263 CODE:
3185 CORO_EXECUTE_SLF_XS (slf_init_transfer); 3264 CORO_EXECUTE_SLF_XS (slf_init_transfer);
3186 3265
3187bool
3188_destroy (SV *coro_sv)
3189 CODE:
3190 RETVAL = coro_state_destroy (aTHX_ SvSTATE (coro_sv));
3191 OUTPUT:
3192 RETVAL
3193
3194void 3266void
3195_exit (int code) 3267_exit (int code)
3196 PROTOTYPE: $ 3268 PROTOTYPE: $
3197 CODE: 3269 CODE:
3198 _exit (code); 3270 _exit (code);
… …
3273 CODE: 3345 CODE:
3274{ 3346{
3275 if (coro->mainstack && ((coro->flags & CF_RUNNING) || coro->slot)) 3347 if (coro->mainstack && ((coro->flags & CF_RUNNING) || coro->slot))
3276 { 3348 {
3277 struct coro *current = SvSTATE_current; 3349 struct coro *current = SvSTATE_current;
3350 struct CoroSLF slf_save;
3278 3351
3279 if (current != coro) 3352 if (current != coro)
3280 { 3353 {
3281 PUTBACK; 3354 PUTBACK;
3282 save_perl (aTHX_ current); 3355 save_perl (aTHX_ current);
3283 load_perl (aTHX_ coro); 3356 load_perl (aTHX_ coro);
3357 /* the coro is most likely in an active SLF call.
3358 * while not strictly required (the code we execute is
3359 * not allowed to call any SLF functions), it's cleaner
3360 * to reinitialise the slf_frame and restore it later.
3361 * This might one day allow us to actually do SLF calls
3362 * from code executed here.
3363 */
3364 slf_save = slf_frame;
3365 slf_frame.prepare = 0;
3284 SPAGAIN; 3366 SPAGAIN;
3285 } 3367 }
3286 3368
3287 PUSHSTACK; 3369 PUSHSTACK;
3288 3370
… …
3298 SPAGAIN; 3380 SPAGAIN;
3299 3381
3300 if (current != coro) 3382 if (current != coro)
3301 { 3383 {
3302 PUTBACK; 3384 PUTBACK;
3385 slf_frame = slf_save;
3303 save_perl (aTHX_ coro); 3386 save_perl (aTHX_ coro);
3304 load_perl (aTHX_ current); 3387 load_perl (aTHX_ current);
3305 SPAGAIN; 3388 SPAGAIN;
3306 } 3389 }
3307 } 3390 }
… …
3393 3476
3394void 3477void
3395cancel (Coro::State self) 3478cancel (Coro::State self)
3396 CODE: 3479 CODE:
3397 coro_state_destroy (aTHX_ self); 3480 coro_state_destroy (aTHX_ self);
3398 coro_call_on_destroy (aTHX_ self); /* actually only for Coro objects */
3399 3481
3400SV * 3482SV *
3401enable_times (int enabled = enable_times) 3483enable_times (int enabled = enable_times)
3402 CODE: 3484 CODE:
3403{ 3485{
… …
3508 api_ready (aTHX_ RETVAL); 3590 api_ready (aTHX_ RETVAL);
3509 OUTPUT: 3591 OUTPUT:
3510 RETVAL 3592 RETVAL
3511 3593
3512void 3594void
3595_destroy (Coro::State coro)
3596 CODE:
3597 /* used by the manager thread */
3598 coro_state_destroy (aTHX_ coro);
3599 coro_call_on_destroy (aTHX_ coro);
3600
3601void
3513terminate (...) 3602terminate (...)
3514 CODE: 3603 CODE:
3515 CORO_EXECUTE_SLF_XS (slf_init_terminate); 3604 CORO_EXECUTE_SLF_XS (slf_init_terminate);
3605
3606void
3607cancel (...)
3608 CODE:
3609 CORO_EXECUTE_SLF_XS (slf_init_cancel);
3516 3610
3517void 3611void
3518schedule (...) 3612schedule (...)
3519 CODE: 3613 CODE:
3520 CORO_EXECUTE_SLF_XS (slf_init_schedule); 3614 CORO_EXECUTE_SLF_XS (slf_init_schedule);

Diff Legend

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