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.342 by root, Mon Dec 15 16:22:34 2008 UTC vs.
Revision 1.359 by root, Mon Jun 29 05:07:19 2009 UTC

… …
137 137
138#define IN_DESTRUCT PL_dirty 138#define IN_DESTRUCT PL_dirty
139 139
140#if __GNUC__ >= 3 140#if __GNUC__ >= 3
141# define attribute(x) __attribute__(x) 141# define attribute(x) __attribute__(x)
142# define expect(expr,value) __builtin_expect ((expr),(value)) 142# define expect(expr,value) __builtin_expect ((expr), (value))
143# define INLINE static inline 143# define INLINE static inline
144#else 144#else
145# define attribute(x) 145# define attribute(x)
146# define expect(expr,value) (expr) 146# define expect(expr,value) (expr)
147# define INLINE static 147# define INLINE static
… …
156#define GCoroAPI (&coroapi) /* very sneaky */ 156#define GCoroAPI (&coroapi) /* very sneaky */
157 157
158#ifdef USE_ITHREADS 158#ifdef USE_ITHREADS
159# if CORO_PTHREAD 159# if CORO_PTHREAD
160static void *coro_thx; 160static void *coro_thx;
161# endif
162#endif
163
164#ifdef __linux
165# include <time.h> /* for timespec */
166# include <syscall.h> /* for SYS_* */
167# ifdef SYS_clock_gettime
168# define coro_clock_gettime(id, ts) syscall (SYS_clock_gettime, (id), (ts))
169# define CORO_CLOCK_MONOTONIC 1
170# define CORO_CLOCK_THREAD_CPUTIME_ID 3
161# endif 171# endif
162#endif 172#endif
163 173
164static double (*nvtime)(); /* so why doesn't it take void? */ 174static double (*nvtime)(); /* so why doesn't it take void? */
165 175
… …
194static CV *cv_pool_handler; 204static CV *cv_pool_handler;
195static CV *cv_coro_state_new; 205static CV *cv_coro_state_new;
196 206
197/* Coro::AnyEvent */ 207/* Coro::AnyEvent */
198static SV *sv_activity; 208static SV *sv_activity;
209
210/* enable processtime/realtime profiling */
211static char profile_times;
212typedef U32 coro_ts[2];
199 213
200static struct coro_cctx *cctx_first; 214static struct coro_cctx *cctx_first;
201static int cctx_count, cctx_idle; 215static int cctx_count, cctx_idle;
202 216
203enum { 217enum {
… …
261/* this is a structure representing a perl-level coroutine */ 275/* this is a structure representing a perl-level coroutine */
262struct coro { 276struct coro {
263 /* the C coroutine allocated to this perl coroutine, if any */ 277 /* the C coroutine allocated to this perl coroutine, if any */
264 coro_cctx *cctx; 278 coro_cctx *cctx;
265 279
280 /* ready queue */
281 struct coro *next_ready;
282
266 /* state data */ 283 /* state data */
267 struct CoroSLF slf_frame; /* saved slf frame */ 284 struct CoroSLF slf_frame; /* saved slf frame */
268 AV *mainstack; 285 AV *mainstack;
269 perl_slots *slot; /* basically the saved sp */ 286 perl_slots *slot; /* basically the saved sp */
270 287
… …
304/* the mainr easonw e don't support windows process emulation */ 321/* the mainr easonw e don't support windows process emulation */
305static struct CoroSLF slf_frame; /* the current slf frame */ 322static struct CoroSLF slf_frame; /* the current slf frame */
306 323
307/** Coro ********************************************************************/ 324/** Coro ********************************************************************/
308 325
309#define PRIO_MAX 3 326#define CORO_PRIO_MAX 3
310#define PRIO_HIGH 1 327#define CORO_PRIO_HIGH 1
311#define PRIO_NORMAL 0 328#define CORO_PRIO_NORMAL 0
312#define PRIO_LOW -1 329#define CORO_PRIO_LOW -1
313#define PRIO_IDLE -3 330#define CORO_PRIO_IDLE -3
314#define PRIO_MIN -4 331#define CORO_PRIO_MIN -4
315 332
316/* for Coro.pm */ 333/* for Coro.pm */
317static SV *coro_current; 334static SV *coro_current;
318static SV *coro_readyhook; 335static SV *coro_readyhook;
319static AV *coro_ready [PRIO_MAX - PRIO_MIN + 1]; 336static struct coro *coro_ready [CORO_PRIO_MAX - CORO_PRIO_MIN + 1][2]; /* head|tail */
320static CV *cv_coro_run, *cv_coro_terminate; 337static CV *cv_coro_run, *cv_coro_terminate;
321static struct coro *coro_first; 338static struct coro *coro_first;
322#define coro_nready coroapi.nready 339#define coro_nready coroapi.nready
323 340
324/** lowlevel stuff **********************************************************/ 341/** lowlevel stuff **********************************************************/
… …
472static int 489static int
473coro_cv_free (pTHX_ SV *sv, MAGIC *mg) 490coro_cv_free (pTHX_ SV *sv, MAGIC *mg)
474{ 491{
475 AV *padlist; 492 AV *padlist;
476 AV *av = (AV *)mg->mg_obj; 493 AV *av = (AV *)mg->mg_obj;
494
495 /* perl manages to free our internal AV and _then_ call us */
496 if (IN_DESTRUCT)
497 return;
477 498
478 /* casting is fun. */ 499 /* casting is fun. */
479 while (&PL_sv_undef != (SV *)(padlist = (AV *)av_pop (av))) 500 while (&PL_sv_undef != (SV *)(padlist = (AV *)av_pop (av)))
480 free_padlist (aTHX_ padlist); 501 free_padlist (aTHX_ padlist);
481 502
… …
612 { 633 {
613 while (expect_true (cxix >= 0)) 634 while (expect_true (cxix >= 0))
614 { 635 {
615 PERL_CONTEXT *cx = &ccstk[cxix--]; 636 PERL_CONTEXT *cx = &ccstk[cxix--];
616 637
617 if (expect_true (CxTYPE (cx) == CXt_SUB || CxTYPE (cx) == CXt_FORMAT)) 638 if (expect_true (CxTYPE (cx) == CXt_SUB) || expect_false (CxTYPE (cx) == CXt_FORMAT))
618 { 639 {
619 CV *cv = cx->blk_sub.cv; 640 CV *cv = cx->blk_sub.cv;
620 641
621 if (expect_true (CvDEPTH (cv))) 642 if (expect_true (CvDEPTH (cv)))
622 { 643 {
… …
987} 1008}
988 1009
989static void 1010static void
990coro_destruct_perl (pTHX_ struct coro *coro) 1011coro_destruct_perl (pTHX_ struct coro *coro)
991{ 1012{
1013 SV *svf [9];
1014
1015 {
1016 struct coro *current = SvSTATE_current;
1017
1018 assert (("FATAL: tried to destroy currently running coroutine", coro->mainstack != PL_mainstack));
1019
1020 save_perl (aTHX_ current);
1021 load_perl (aTHX_ coro);
1022
992 coro_unwind_stacks (aTHX); 1023 coro_unwind_stacks (aTHX);
1024 coro_destruct_stacks (aTHX);
993 1025
994 SvREFCNT_dec (GvSV (PL_defgv)); 1026 // now save some sv's to be free'd later
995 SvREFCNT_dec (GvAV (PL_defgv)); 1027 svf [0] = GvSV (PL_defgv);
996 SvREFCNT_dec (GvSV (PL_errgv)); 1028 svf [1] = (SV *)GvAV (PL_defgv);
997 SvREFCNT_dec (PL_defoutgv); 1029 svf [2] = GvSV (PL_errgv);
998 SvREFCNT_dec (PL_rs); 1030 svf [3] = (SV *)PL_defoutgv;
999 SvREFCNT_dec (GvSV (irsgv)); 1031 svf [4] = PL_rs;
1000 SvREFCNT_dec (GvHV (PL_hintgv)); 1032 svf [5] = GvSV (irsgv);
1033 svf [6] = (SV *)GvHV (PL_hintgv);
1034 svf [7] = PL_diehook;
1035 svf [8] = PL_warnhook;
1036 assert (9 == sizeof (svf) / sizeof (*svf));
1001 1037
1002 SvREFCNT_dec (PL_diehook); 1038 load_perl (aTHX_ current);
1003 SvREFCNT_dec (PL_warnhook);
1004 1039 }
1040
1041 {
1042 int i;
1043
1044 for (i = 0; i < sizeof (svf) / sizeof (*svf); ++i)
1045 SvREFCNT_dec (svf [i]);
1046
1005 SvREFCNT_dec (coro->saved_deffh); 1047 SvREFCNT_dec (coro->saved_deffh);
1006 SvREFCNT_dec (coro->rouse_cb); 1048 SvREFCNT_dec (coro->rouse_cb);
1007 SvREFCNT_dec (coro->invoke_cb); 1049 SvREFCNT_dec (coro->invoke_cb);
1008 SvREFCNT_dec (coro->invoke_av); 1050 SvREFCNT_dec (coro->invoke_av);
1009 1051 }
1010 coro_destruct_stacks (aTHX);
1011} 1052}
1012 1053
1013INLINE void 1054INLINE void
1014free_coro_mortal (pTHX) 1055free_coro_mortal (pTHX)
1015{ 1056{
… …
1484coro_state_destroy (pTHX_ struct coro *coro) 1525coro_state_destroy (pTHX_ struct coro *coro)
1485{ 1526{
1486 if (coro->flags & CF_DESTROYED) 1527 if (coro->flags & CF_DESTROYED)
1487 return 0; 1528 return 0;
1488 1529
1489 if (coro->on_destroy) 1530 if (coro->on_destroy && !PL_dirty)
1490 coro->on_destroy (aTHX_ coro); 1531 coro->on_destroy (aTHX_ coro);
1491 1532
1492 coro->flags |= CF_DESTROYED; 1533 coro->flags |= CF_DESTROYED;
1493 1534
1494 if (coro->flags & CF_READY) 1535 if (coro->flags & CF_READY)
… …
1502 1543
1503 if (coro->mainstack 1544 if (coro->mainstack
1504 && coro->mainstack != main_mainstack 1545 && coro->mainstack != main_mainstack
1505 && coro->slot 1546 && coro->slot
1506 && !PL_dirty) 1547 && !PL_dirty)
1507 {
1508 struct coro *current = SvSTATE_current;
1509
1510 assert (("FATAL: tried to destroy currently running coroutine", coro->mainstack != PL_mainstack));
1511
1512 save_perl (aTHX_ current);
1513 load_perl (aTHX_ coro);
1514
1515 coro_destruct_perl (aTHX_ coro); 1548 coro_destruct_perl (aTHX_ coro);
1516
1517 load_perl (aTHX_ current);
1518
1519 coro->slot = 0;
1520 }
1521 1549
1522 cctx_destroy (coro->cctx); 1550 cctx_destroy (coro->cctx);
1523 SvREFCNT_dec (coro->startcv); 1551 SvREFCNT_dec (coro->startcv);
1524 SvREFCNT_dec (coro->args); 1552 SvREFCNT_dec (coro->args);
1525 SvREFCNT_dec (CORO_THROW); 1553 SvREFCNT_dec (CORO_THROW);
… …
1612/** Coro ********************************************************************/ 1640/** Coro ********************************************************************/
1613 1641
1614INLINE void 1642INLINE void
1615coro_enq (pTHX_ struct coro *coro) 1643coro_enq (pTHX_ struct coro *coro)
1616{ 1644{
1617 av_push (coro_ready [coro->prio - PRIO_MIN], SvREFCNT_inc_NN (coro->hv)); 1645 struct coro **ready = coro_ready [coro->prio - CORO_PRIO_MIN];
1618}
1619 1646
1620INLINE SV * 1647 SvREFCNT_inc_NN (coro->hv);
1648
1649 coro->next_ready = 0;
1650 *(ready [0] ? &ready [1]->next_ready : &ready [0]) = coro;
1651 ready [1] = coro;
1652}
1653
1654INLINE struct coro *
1621coro_deq (pTHX) 1655coro_deq (pTHX)
1622{ 1656{
1623 int prio; 1657 int prio;
1624 1658
1625 for (prio = PRIO_MAX - PRIO_MIN + 1; --prio >= 0; ) 1659 for (prio = CORO_PRIO_MAX - CORO_PRIO_MIN + 1; --prio >= 0; )
1626 if (AvFILLp (coro_ready [prio]) >= 0) 1660 {
1627 return av_shift (coro_ready [prio]); 1661 struct coro **ready = coro_ready [prio];
1662
1663 if (ready [0])
1664 {
1665 struct coro *coro = ready [0];
1666 ready [0] = coro->next_ready;
1667 return coro;
1668 }
1669 }
1628 1670
1629 return 0; 1671 return 0;
1630} 1672}
1631 1673
1632static int 1674static int
… …
1696static void 1738static void
1697prepare_schedule (pTHX_ struct coro_transfer_args *ta) 1739prepare_schedule (pTHX_ struct coro_transfer_args *ta)
1698{ 1740{
1699 for (;;) 1741 for (;;)
1700 { 1742 {
1701 SV *next_sv = coro_deq (aTHX); 1743 struct coro *next = coro_deq (aTHX);
1702 1744
1703 if (expect_true (next_sv)) 1745 if (expect_true (next))
1704 { 1746 {
1705 struct coro *next = SvSTATE_hv (next_sv);
1706
1707 /* cannot transfer to destroyed coros, skip and look for next */ 1747 /* cannot transfer to destroyed coros, skip and look for next */
1708 if (expect_false (next->flags & (CF_DESTROYED | CF_SUSPENDED))) 1748 if (expect_false (next->flags & (CF_DESTROYED | CF_SUSPENDED)))
1709 SvREFCNT_dec (next_sv); /* coro_nready has already been taken care of by destroy */ 1749 SvREFCNT_dec (next->hv); /* coro_nready has already been taken care of by destroy */
1710 else 1750 else
1711 { 1751 {
1712 next->flags &= ~CF_READY; 1752 next->flags &= ~CF_READY;
1713 --coro_nready; 1753 --coro_nready;
1714 1754
… …
1988 SV *data = (SV *)GENSUB_ARG; 2028 SV *data = (SV *)GENSUB_ARG;
1989 2029
1990 if (SvTYPE (SvRV (data)) != SVt_PVAV) 2030 if (SvTYPE (SvRV (data)) != SVt_PVAV)
1991 { 2031 {
1992 /* first call, set args */ 2032 /* first call, set args */
2033 SV *coro = SvRV (data);
1993 AV *av = newAV (); 2034 AV *av = newAV ();
1994 SV *coro = SvRV (data);
1995 2035
1996 SvRV_set (data, (SV *)av); 2036 SvRV_set (data, (SV *)av);
1997 api_ready (aTHX_ coro);
1998 SvREFCNT_dec (coro);
1999 2037
2000 /* better take a full copy of the arguments */ 2038 /* better take a full copy of the arguments */
2001 while (items--) 2039 while (items--)
2002 av_store (av, items, newSVsv (ST (items))); 2040 av_store (av, items, newSVsv (ST (items)));
2041
2042 api_ready (aTHX_ coro);
2043 SvREFCNT_dec (coro);
2003 } 2044 }
2004 2045
2005 XSRETURN_EMPTY; 2046 XSRETURN_EMPTY;
2006} 2047}
2007 2048
… …
2024 2065
2025 EXTEND (SP, AvFILLp (av) + 1); 2066 EXTEND (SP, AvFILLp (av) + 1);
2026 for (i = 0; i <= AvFILLp (av); ++i) 2067 for (i = 0; i <= AvFILLp (av); ++i)
2027 PUSHs (sv_2mortal (AvARRAY (av)[i])); 2068 PUSHs (sv_2mortal (AvARRAY (av)[i]));
2028 2069
2029 /* we have stolen the elements, so ste length to zero and free */ 2070 /* we have stolen the elements, so set length to zero and free */
2030 AvFILLp (av) = -1; 2071 AvFILLp (av) = -1;
2031 av_undef (av); 2072 av_undef (av);
2032 2073
2033 PUTBACK; 2074 PUTBACK;
2034 } 2075 }
… …
2454/* Coro::Semaphore & Coro::Signal */ 2495/* Coro::Semaphore & Coro::Signal */
2455 2496
2456static SV * 2497static SV *
2457coro_waitarray_new (pTHX_ int count) 2498coro_waitarray_new (pTHX_ int count)
2458{ 2499{
2459 /* a semaphore contains a counter IV in $sem->[0] and any waiters after that */ 2500 /* a waitarray=semaphore contains a counter IV in $sem->[0] and any waiters after that */
2460 AV *av = newAV (); 2501 AV *av = newAV ();
2461 SV **ary; 2502 SV **ary;
2462 2503
2463 /* unfortunately, building manually saves memory */ 2504 /* unfortunately, building manually saves memory */
2464 Newx (ary, 2, SV *); 2505 Newx (ary, 2, SV *);
… …
2608 { 2649 {
2609 /* callback form */ 2650 /* callback form */
2610 AV *av = (AV *)SvRV (arg [0]); 2651 AV *av = (AV *)SvRV (arg [0]);
2611 CV *cb_cv = coro_sv_2cv (aTHX_ arg [1]); 2652 CV *cb_cv = coro_sv_2cv (aTHX_ arg [1]);
2612 2653
2613 av_push (av, (SV *)SvREFCNT_inc_NN (cb_cv)); 2654 av_push (av, SvREFCNT_inc_NN (cb_cv));
2614 2655
2615 if (SvIVX (AvARRAY (av)[0]) > 0) 2656 if (SvIVX (AvARRAY (av)[0]) > 0)
2616 coro_semaphore_adjust (aTHX_ av, 0); 2657 coro_semaphore_adjust (aTHX_ av, 0);
2617 2658
2618 frame->prepare = prepare_nop; 2659 frame->prepare = prepare_nop;
… …
2642 AvARRAY (av)[0] = AvARRAY (av)[1]; 2683 AvARRAY (av)[0] = AvARRAY (av)[1];
2643 AvARRAY (av)[1] = cb; 2684 AvARRAY (av)[1] = cb;
2644 2685
2645 cb = av_shift (av); 2686 cb = av_shift (av);
2646 2687
2688 if (SvTYPE (cb) == SVt_PVCV)
2689 {
2690 dSP;
2691 PUSHMARK (SP);
2692 XPUSHs (sv_2mortal (newRV_inc ((SV *)av)));
2693 PUTBACK;
2694 call_sv (cb, G_VOID | G_DISCARD | G_EVAL | G_KEEPERR);
2695 }
2696 else
2697 {
2647 api_ready (aTHX_ cb); 2698 api_ready (aTHX_ cb);
2648 sv_setiv (cb, 0); /* signal waiter */ 2699 sv_setiv (cb, 0); /* signal waiter */
2700 }
2701
2649 SvREFCNT_dec (cb); 2702 SvREFCNT_dec (cb);
2650 2703
2651 --count; 2704 --count;
2652 } 2705 }
2653} 2706}
… …
2662static void 2715static void
2663slf_init_signal_wait (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items) 2716slf_init_signal_wait (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2664{ 2717{
2665 AV *av = (AV *)SvRV (arg [0]); 2718 AV *av = (AV *)SvRV (arg [0]);
2666 2719
2720 if (items >= 2)
2721 {
2722 CV *cb_cv = coro_sv_2cv (aTHX_ arg [1]);
2723 av_push (av, SvREFCNT_inc_NN (cb_cv));
2724
2667 if (SvIVX (AvARRAY (av)[0])) 2725 if (SvIVX (AvARRAY (av)[0]))
2726 coro_signal_wake (aTHX_ av, 1); /* ust be the only waiter */
2727
2728 frame->prepare = prepare_nop;
2729 frame->check = slf_check_nop;
2730 }
2731 else if (SvIVX (AvARRAY (av)[0]))
2668 { 2732 {
2669 SvIVX (AvARRAY (av)[0]) = 0; 2733 SvIVX (AvARRAY (av)[0]) = 0;
2670 frame->prepare = prepare_nop; 2734 frame->prepare = prepare_nop;
2671 frame->check = slf_check_nop; 2735 frame->check = slf_check_nop;
2672 } 2736 }
2673 else 2737 else
2674 { 2738 {
2675 SV *waiter = newRV_inc (SvRV (coro_current)); /* owned by signal av */ 2739 SV *waiter = newSVsv (coro_current); /* owned by signal av */
2676 2740
2677 av_push (av, waiter); 2741 av_push (av, waiter);
2678 2742
2679 frame->data = (void *)sv_2mortal (SvREFCNT_inc_NN (waiter)); /* owned by process */ 2743 frame->data = (void *)sv_2mortal (SvREFCNT_inc_NN (waiter)); /* owned by process */
2680 frame->prepare = prepare_schedule; 2744 frame->prepare = prepare_schedule;
… …
2921 if (!SvIOK (*svp)) croak ("Time::NVtime isn't a function pointer"); 2985 if (!SvIOK (*svp)) croak ("Time::NVtime isn't a function pointer");
2922 2986
2923 nvtime = INT2PTR (double (*)(), SvIV (*svp)); 2987 nvtime = INT2PTR (double (*)(), SvIV (*svp));
2924 } 2988 }
2925 2989
2926 assert (("PRIO_NORMAL must be 0", !PRIO_NORMAL)); 2990 assert (("PRIO_NORMAL must be 0", !CORO_PRIO_NORMAL));
2927} 2991}
2928 2992
2929SV * 2993SV *
2930new (char *klass, ...) 2994new (char *klass, ...)
2931 ALIAS: 2995 ALIAS:
… …
3133 CODE: 3197 CODE:
3134{ 3198{
3135 struct coro *current = SvSTATE_current; 3199 struct coro *current = SvSTATE_current;
3136 SV **throwp = self == current ? &CORO_THROW : &self->except; 3200 SV **throwp = self == current ? &CORO_THROW : &self->except;
3137 SvREFCNT_dec (*throwp); 3201 SvREFCNT_dec (*throwp);
3202 SvGETMAGIC (throw);
3138 *throwp = SvOK (throw) ? newSVsv (throw) : 0; 3203 *throwp = SvOK (throw) ? newSVsv (throw) : 0;
3139} 3204}
3140 3205
3141void 3206void
3142api_trace (SV *coro, int flags = CC_TRACE | CC_TRACE_SUB) 3207api_trace (SV *coro, int flags = CC_TRACE | CC_TRACE_SUB)
… …
3205 3270
3206MODULE = Coro::State PACKAGE = Coro 3271MODULE = Coro::State PACKAGE = Coro
3207 3272
3208BOOT: 3273BOOT:
3209{ 3274{
3210 int i;
3211
3212 sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE); 3275 sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE);
3213 sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE); 3276 sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE);
3214 cv_coro_run = get_cv ( "Coro::_coro_run" , GV_ADD); 3277 cv_coro_run = get_cv ( "Coro::_coro_run" , GV_ADD);
3215 cv_coro_terminate = get_cv ( "Coro::terminate" , GV_ADD); 3278 cv_coro_terminate = get_cv ( "Coro::terminate" , GV_ADD);
3216 coro_current = coro_get_sv (aTHX_ "Coro::current" , FALSE); SvREADONLY_on (coro_current); 3279 coro_current = coro_get_sv (aTHX_ "Coro::current" , FALSE); SvREADONLY_on (coro_current);
… …
3224 cv_pool_handler = get_cv ("Coro::pool_handler", GV_ADD); SvREADONLY_on (cv_pool_handler); 3287 cv_pool_handler = get_cv ("Coro::pool_handler", GV_ADD); SvREADONLY_on (cv_pool_handler);
3225 cv_coro_state_new = get_cv ("Coro::State::new", 0); SvREADONLY_on (cv_coro_state_new); 3288 cv_coro_state_new = get_cv ("Coro::State::new", 0); SvREADONLY_on (cv_coro_state_new);
3226 3289
3227 coro_stash = gv_stashpv ("Coro", TRUE); 3290 coro_stash = gv_stashpv ("Coro", TRUE);
3228 3291
3229 newCONSTSUB (coro_stash, "PRIO_MAX", newSViv (PRIO_MAX)); 3292 newCONSTSUB (coro_stash, "PRIO_MAX", newSViv (CORO_PRIO_MAX));
3230 newCONSTSUB (coro_stash, "PRIO_HIGH", newSViv (PRIO_HIGH)); 3293 newCONSTSUB (coro_stash, "PRIO_HIGH", newSViv (CORO_PRIO_HIGH));
3231 newCONSTSUB (coro_stash, "PRIO_NORMAL", newSViv (PRIO_NORMAL)); 3294 newCONSTSUB (coro_stash, "PRIO_NORMAL", newSViv (CORO_PRIO_NORMAL));
3232 newCONSTSUB (coro_stash, "PRIO_LOW", newSViv (PRIO_LOW)); 3295 newCONSTSUB (coro_stash, "PRIO_LOW", newSViv (CORO_PRIO_LOW));
3233 newCONSTSUB (coro_stash, "PRIO_IDLE", newSViv (PRIO_IDLE)); 3296 newCONSTSUB (coro_stash, "PRIO_IDLE", newSViv (CORO_PRIO_IDLE));
3234 newCONSTSUB (coro_stash, "PRIO_MIN", newSViv (PRIO_MIN)); 3297 newCONSTSUB (coro_stash, "PRIO_MIN", newSViv (CORO_PRIO_MIN));
3235
3236 for (i = PRIO_MAX - PRIO_MIN + 1; i--; )
3237 coro_ready[i] = newAV ();
3238 3298
3239 { 3299 {
3240 SV *sv = coro_get_sv (aTHX_ "Coro::API", TRUE); 3300 SV *sv = coro_get_sv (aTHX_ "Coro::API", TRUE);
3241 3301
3242 coroapi.schedule = api_schedule; 3302 coroapi.schedule = api_schedule;
… …
3294void 3354void
3295_set_readyhook (SV *hook) 3355_set_readyhook (SV *hook)
3296 PROTOTYPE: $ 3356 PROTOTYPE: $
3297 CODE: 3357 CODE:
3298 SvREFCNT_dec (coro_readyhook); 3358 SvREFCNT_dec (coro_readyhook);
3359 SvGETMAGIC (hook);
3299 coro_readyhook = SvOK (hook) ? newSVsv (hook) : 0; 3360 coro_readyhook = SvOK (hook) ? newSVsv (hook) : 0;
3300 3361
3301int 3362int
3302prio (Coro::State coro, int newprio = 0) 3363prio (Coro::State coro, int newprio = 0)
3303 PROTOTYPE: $;$ 3364 PROTOTYPE: $;$
… …
3310 if (items > 1) 3371 if (items > 1)
3311 { 3372 {
3312 if (ix) 3373 if (ix)
3313 newprio = coro->prio - newprio; 3374 newprio = coro->prio - newprio;
3314 3375
3315 if (newprio < PRIO_MIN) newprio = PRIO_MIN; 3376 if (newprio < CORO_PRIO_MIN) newprio = CORO_PRIO_MIN;
3316 if (newprio > PRIO_MAX) newprio = PRIO_MAX; 3377 if (newprio > CORO_PRIO_MAX) newprio = CORO_PRIO_MAX;
3317 3378
3318 coro->prio = newprio; 3379 coro->prio = newprio;
3319 } 3380 }
3320} 3381}
3321 OUTPUT: 3382 OUTPUT:
… …
3334 PROTOTYPE: 3395 PROTOTYPE:
3335 CODE: 3396 CODE:
3336 RETVAL = coro_nready; 3397 RETVAL = coro_nready;
3337 OUTPUT: 3398 OUTPUT:
3338 RETVAL 3399 RETVAL
3400
3401void
3402suspend (Coro::State self)
3403 PROTOTYPE: $
3404 CODE:
3405 self->flags |= CF_SUSPENDED;
3406
3407void
3408resume (Coro::State self)
3409 PROTOTYPE: $
3410 CODE:
3411 self->flags &= ~CF_SUSPENDED;
3339 3412
3340void 3413void
3341_pool_handler (...) 3414_pool_handler (...)
3342 CODE: 3415 CODE:
3343 CORO_EXECUTE_SLF_XS (slf_init_pool_handler); 3416 CORO_EXECUTE_SLF_XS (slf_init_pool_handler);
… …
3418 av_push (*avp, SvREFCNT_inc (block)); 3491 av_push (*avp, SvREFCNT_inc (block));
3419 3492
3420 if (!ix) 3493 if (!ix)
3421 on_enterleave_call (aTHX_ block); 3494 on_enterleave_call (aTHX_ block);
3422 3495
3423 LEAVE; /* pp_entersub unfortunately forces an ENTER/LEAVE around xs calls */ 3496 LEAVE; /* pp_entersub unfortunately forces an ENTER/LEAVE around XS calls */
3424 SAVEDESTRUCTOR_X (ix ? coro_pop_on_leave : coro_pop_on_enter, (void *)coro); 3497 SAVEDESTRUCTOR_X (ix ? coro_pop_on_leave : coro_pop_on_enter, (void *)coro);
3425 ENTER; /* pp_entersub unfortunately forces an ENTER/LEAVE around xs calls */ 3498 ENTER; /* pp_entersub unfortunately forces an ENTER/LEAVE around XS calls */
3426} 3499}
3427 3500
3428 3501
3429MODULE = Coro::State PACKAGE = PerlIO::cede 3502MODULE = Coro::State PACKAGE = PerlIO::cede
3430 3503
… …
3435MODULE = Coro::State PACKAGE = Coro::Semaphore 3508MODULE = Coro::State PACKAGE = Coro::Semaphore
3436 3509
3437SV * 3510SV *
3438new (SV *klass, SV *count = 0) 3511new (SV *klass, SV *count = 0)
3439 CODE: 3512 CODE:
3513{
3514 int semcnt = 1;
3515
3516 if (count)
3517 {
3518 SvGETMAGIC (count);
3519
3520 if (SvOK (count))
3521 semcnt = SvIV (count);
3522 }
3523
3440 RETVAL = sv_bless ( 3524 RETVAL = sv_bless (
3441 coro_waitarray_new (aTHX_ count && SvOK (count) ? SvIV (count) : 1), 3525 coro_waitarray_new (aTHX_ semcnt),
3442 GvSTASH (CvGV (cv)) 3526 GvSTASH (CvGV (cv))
3443 ); 3527 );
3528}
3444 OUTPUT: 3529 OUTPUT:
3445 RETVAL 3530 RETVAL
3446 3531
3447# helper for Coro::Channel 3532# helper for Coro::Channel and others
3448SV * 3533SV *
3449_alloc (int count) 3534_alloc (int count)
3450 CODE: 3535 CODE:
3451 RETVAL = coro_waitarray_new (aTHX_ count); 3536 RETVAL = coro_waitarray_new (aTHX_ count);
3452 OUTPUT: 3537 OUTPUT:
… …
3510 for (i = 1; i <= wcount; ++i) 3595 for (i = 1; i <= wcount; ++i)
3511 PUSHs (sv_2mortal (newRV_inc (AvARRAY (av)[i]))); 3596 PUSHs (sv_2mortal (newRV_inc (AvARRAY (av)[i])));
3512 } 3597 }
3513} 3598}
3514 3599
3600MODULE = Coro::State PACKAGE = Coro::SemaphoreSet
3601
3602void
3603_may_delete (SV *sem, int count, int extra_refs)
3604 PPCODE:
3605{
3606 AV *av = (AV *)SvRV (sem);
3607
3608 if (SvREFCNT ((SV *)av) == 1 + extra_refs
3609 && AvFILLp (av) == 0 /* no waiters, just count */
3610 && SvIV (AvARRAY (av)[0]) == count)
3611 XSRETURN_YES;
3612
3613 XSRETURN_NO;
3614}
3615
3515MODULE = Coro::State PACKAGE = Coro::Signal 3616MODULE = Coro::State PACKAGE = Coro::Signal
3516 3617
3517SV * 3618SV *
3518new (SV *klass) 3619new (SV *klass)
3519 CODE: 3620 CODE:

Diff Legend

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