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.339 by root, Mon Dec 15 00:28:30 2008 UTC vs.
Revision 1.358 by root, Mon Jun 29 04:30:25 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
… …
238enum { 248enum {
239 CF_RUNNING = 0x0001, /* coroutine is running */ 249 CF_RUNNING = 0x0001, /* coroutine is running */
240 CF_READY = 0x0002, /* coroutine is ready */ 250 CF_READY = 0x0002, /* coroutine is ready */
241 CF_NEW = 0x0004, /* has never been switched to */ 251 CF_NEW = 0x0004, /* has never been switched to */
242 CF_DESTROYED = 0x0008, /* coroutine data has been freed */ 252 CF_DESTROYED = 0x0008, /* coroutine data has been freed */
253 CF_SUSPENDED = 0x0010, /* coroutine can't be scheduled */
243}; 254};
244 255
245/* the structure where most of the perl state is stored, overlaid on the cxstack */ 256/* the structure where most of the perl state is stored, overlaid on the cxstack */
246typedef struct 257typedef struct
247{ 258{
… …
260/* this is a structure representing a perl-level coroutine */ 271/* this is a structure representing a perl-level coroutine */
261struct coro { 272struct coro {
262 /* the C coroutine allocated to this perl coroutine, if any */ 273 /* the C coroutine allocated to this perl coroutine, if any */
263 coro_cctx *cctx; 274 coro_cctx *cctx;
264 275
276 /* ready queue */
277 struct coro *next_ready;
278
265 /* state data */ 279 /* state data */
266 struct CoroSLF slf_frame; /* saved slf frame */ 280 struct CoroSLF slf_frame; /* saved slf frame */
267 AV *mainstack; 281 AV *mainstack;
268 perl_slots *slot; /* basically the saved sp */ 282 perl_slots *slot; /* basically the saved sp */
269 283
… …
303/* the mainr easonw e don't support windows process emulation */ 317/* the mainr easonw e don't support windows process emulation */
304static struct CoroSLF slf_frame; /* the current slf frame */ 318static struct CoroSLF slf_frame; /* the current slf frame */
305 319
306/** Coro ********************************************************************/ 320/** Coro ********************************************************************/
307 321
308#define PRIO_MAX 3 322#define CORO_PRIO_MAX 3
309#define PRIO_HIGH 1 323#define CORO_PRIO_HIGH 1
310#define PRIO_NORMAL 0 324#define CORO_PRIO_NORMAL 0
311#define PRIO_LOW -1 325#define CORO_PRIO_LOW -1
312#define PRIO_IDLE -3 326#define CORO_PRIO_IDLE -3
313#define PRIO_MIN -4 327#define CORO_PRIO_MIN -4
314 328
315/* for Coro.pm */ 329/* for Coro.pm */
316static SV *coro_current; 330static SV *coro_current;
317static SV *coro_readyhook; 331static SV *coro_readyhook;
318static AV *coro_ready [PRIO_MAX - PRIO_MIN + 1]; 332static struct coro *coro_ready [CORO_PRIO_MAX - CORO_PRIO_MIN + 1][2]; /* head|tail */
319static CV *cv_coro_run, *cv_coro_terminate; 333static CV *cv_coro_run, *cv_coro_terminate;
320static struct coro *coro_first; 334static struct coro *coro_first;
321#define coro_nready coroapi.nready 335#define coro_nready coroapi.nready
322 336
323/** lowlevel stuff **********************************************************/ 337/** lowlevel stuff **********************************************************/
… …
471static int 485static int
472coro_cv_free (pTHX_ SV *sv, MAGIC *mg) 486coro_cv_free (pTHX_ SV *sv, MAGIC *mg)
473{ 487{
474 AV *padlist; 488 AV *padlist;
475 AV *av = (AV *)mg->mg_obj; 489 AV *av = (AV *)mg->mg_obj;
490
491 /* perl manages to free our internal AV and _then_ call us */
492 if (IN_DESTRUCT)
493 return;
476 494
477 /* casting is fun. */ 495 /* casting is fun. */
478 while (&PL_sv_undef != (SV *)(padlist = (AV *)av_pop (av))) 496 while (&PL_sv_undef != (SV *)(padlist = (AV *)av_pop (av)))
479 free_padlist (aTHX_ padlist); 497 free_padlist (aTHX_ padlist);
480 498
… …
574 if (expect_false (c->on_enter)) 592 if (expect_false (c->on_enter))
575 { 593 {
576 int i; 594 int i;
577 595
578 for (i = 0; i <= AvFILLp (c->on_enter); ++i) 596 for (i = 0; i <= AvFILLp (c->on_enter); ++i)
579 on_enterleave_call (AvARRAY (c->on_enter)[i]); 597 on_enterleave_call (aTHX_ AvARRAY (c->on_enter)[i]);
580 } 598 }
581} 599}
582 600
583static void 601static void
584save_perl (pTHX_ Coro__State c) 602save_perl (pTHX_ Coro__State c)
… …
586 if (expect_false (c->on_leave)) 604 if (expect_false (c->on_leave))
587 { 605 {
588 int i; 606 int i;
589 607
590 for (i = AvFILLp (c->on_leave); i >= 0; --i) 608 for (i = AvFILLp (c->on_leave); i >= 0; --i)
591 on_enterleave_call (AvARRAY (c->on_leave)[i]); 609 on_enterleave_call (aTHX_ AvARRAY (c->on_leave)[i]);
592 } 610 }
593 611
594 c->except = CORO_THROW; 612 c->except = CORO_THROW;
595 c->slf_frame = slf_frame; 613 c->slf_frame = slf_frame;
596 614
… …
611 { 629 {
612 while (expect_true (cxix >= 0)) 630 while (expect_true (cxix >= 0))
613 { 631 {
614 PERL_CONTEXT *cx = &ccstk[cxix--]; 632 PERL_CONTEXT *cx = &ccstk[cxix--];
615 633
616 if (expect_true (CxTYPE (cx) == CXt_SUB || CxTYPE (cx) == CXt_FORMAT)) 634 if (expect_true (CxTYPE (cx) == CXt_SUB) || expect_false (CxTYPE (cx) == CXt_FORMAT))
617 { 635 {
618 CV *cv = cx->blk_sub.cv; 636 CV *cv = cx->blk_sub.cv;
619 637
620 if (expect_true (CvDEPTH (cv))) 638 if (expect_true (CvDEPTH (cv)))
621 { 639 {
… …
986} 1004}
987 1005
988static void 1006static void
989coro_destruct_perl (pTHX_ struct coro *coro) 1007coro_destruct_perl (pTHX_ struct coro *coro)
990{ 1008{
1009 SV *svf [9];
1010
1011 {
1012 struct coro *current = SvSTATE_current;
1013
1014 assert (("FATAL: tried to destroy currently running coroutine", coro->mainstack != PL_mainstack));
1015
1016 save_perl (aTHX_ current);
1017 load_perl (aTHX_ coro);
1018
991 coro_unwind_stacks (aTHX); 1019 coro_unwind_stacks (aTHX);
1020 coro_destruct_stacks (aTHX);
992 1021
993 SvREFCNT_dec (GvSV (PL_defgv)); 1022 // now save some sv's to be free'd later
994 SvREFCNT_dec (GvAV (PL_defgv)); 1023 svf [0] = GvSV (PL_defgv);
995 SvREFCNT_dec (GvSV (PL_errgv)); 1024 svf [1] = (SV *)GvAV (PL_defgv);
996 SvREFCNT_dec (PL_defoutgv); 1025 svf [2] = GvSV (PL_errgv);
997 SvREFCNT_dec (PL_rs); 1026 svf [3] = (SV *)PL_defoutgv;
998 SvREFCNT_dec (GvSV (irsgv)); 1027 svf [4] = PL_rs;
999 SvREFCNT_dec (GvHV (PL_hintgv)); 1028 svf [5] = GvSV (irsgv);
1029 svf [6] = (SV *)GvHV (PL_hintgv);
1030 svf [7] = PL_diehook;
1031 svf [8] = PL_warnhook;
1032 assert (9 == sizeof (svf) / sizeof (*svf));
1000 1033
1001 SvREFCNT_dec (PL_diehook); 1034 load_perl (aTHX_ current);
1002 SvREFCNT_dec (PL_warnhook);
1003 1035 }
1036
1037 {
1038 int i;
1039
1040 for (i = 0; i < sizeof (svf) / sizeof (*svf); ++i)
1041 SvREFCNT_dec (svf [i]);
1042
1004 SvREFCNT_dec (coro->saved_deffh); 1043 SvREFCNT_dec (coro->saved_deffh);
1005 SvREFCNT_dec (coro->rouse_cb); 1044 SvREFCNT_dec (coro->rouse_cb);
1006 SvREFCNT_dec (coro->invoke_cb); 1045 SvREFCNT_dec (coro->invoke_cb);
1007 SvREFCNT_dec (coro->invoke_av); 1046 SvREFCNT_dec (coro->invoke_av);
1008 1047 }
1009 coro_destruct_stacks (aTHX);
1010} 1048}
1011 1049
1012INLINE void 1050INLINE void
1013free_coro_mortal (pTHX) 1051free_coro_mortal (pTHX)
1014{ 1052{
… …
1382 /* TODO: throwing up here is considered harmful */ 1420 /* TODO: throwing up here is considered harmful */
1383 1421
1384 if (expect_true (prev != next)) 1422 if (expect_true (prev != next))
1385 { 1423 {
1386 if (expect_false (!(prev->flags & (CF_RUNNING | CF_NEW)))) 1424 if (expect_false (!(prev->flags & (CF_RUNNING | CF_NEW))))
1387 croak ("Coro::State::transfer called with a suspended prev Coro::State, but can only transfer from running or new states,"); 1425 croak ("Coro::State::transfer called with a blocked prev Coro::State, but can only transfer from running or new states,");
1388 1426
1389 if (expect_false (next->flags & CF_RUNNING))
1390 croak ("Coro::State::transfer called with running next Coro::State, but can only transfer to inactive states,");
1391
1392 if (expect_false (next->flags & CF_DESTROYED)) 1427 if (expect_false (next->flags & (CF_RUNNING | CF_DESTROYED | CF_SUSPENDED)))
1393 croak ("Coro::State::transfer called with destroyed next Coro::State, but can only transfer to inactive states,"); 1428 croak ("Coro::State::transfer called with running, destroyed or suspended next Coro::State, but can only transfer to inactive states,");
1394 1429
1395#if !PERL_VERSION_ATLEAST (5,10,0) 1430#if !PERL_VERSION_ATLEAST (5,10,0)
1396 if (expect_false (PL_lex_state != LEX_NOTPARSING)) 1431 if (expect_false (PL_lex_state != LEX_NOTPARSING))
1397 croak ("Coro::State::transfer called while parsing, but this is not supported in your perl version,"); 1432 croak ("Coro::State::transfer called while parsing, but this is not supported in your perl version,");
1398#endif 1433#endif
… …
1486coro_state_destroy (pTHX_ struct coro *coro) 1521coro_state_destroy (pTHX_ struct coro *coro)
1487{ 1522{
1488 if (coro->flags & CF_DESTROYED) 1523 if (coro->flags & CF_DESTROYED)
1489 return 0; 1524 return 0;
1490 1525
1491 if (coro->on_destroy) 1526 if (coro->on_destroy && !PL_dirty)
1492 coro->on_destroy (aTHX_ coro); 1527 coro->on_destroy (aTHX_ coro);
1493 1528
1494 coro->flags |= CF_DESTROYED; 1529 coro->flags |= CF_DESTROYED;
1495 1530
1496 if (coro->flags & CF_READY) 1531 if (coro->flags & CF_READY)
… …
1504 1539
1505 if (coro->mainstack 1540 if (coro->mainstack
1506 && coro->mainstack != main_mainstack 1541 && coro->mainstack != main_mainstack
1507 && coro->slot 1542 && coro->slot
1508 && !PL_dirty) 1543 && !PL_dirty)
1509 {
1510 struct coro *current = SvSTATE_current;
1511
1512 assert (("FATAL: tried to destroy currently running coroutine", coro->mainstack != PL_mainstack));
1513
1514 save_perl (aTHX_ current);
1515 load_perl (aTHX_ coro);
1516
1517 coro_destruct_perl (aTHX_ coro); 1544 coro_destruct_perl (aTHX_ coro);
1518
1519 load_perl (aTHX_ current);
1520
1521 coro->slot = 0;
1522 }
1523 1545
1524 cctx_destroy (coro->cctx); 1546 cctx_destroy (coro->cctx);
1525 SvREFCNT_dec (coro->startcv); 1547 SvREFCNT_dec (coro->startcv);
1526 SvREFCNT_dec (coro->args); 1548 SvREFCNT_dec (coro->args);
1527 SvREFCNT_dec (CORO_THROW); 1549 SvREFCNT_dec (CORO_THROW);
… …
1614/** Coro ********************************************************************/ 1636/** Coro ********************************************************************/
1615 1637
1616INLINE void 1638INLINE void
1617coro_enq (pTHX_ struct coro *coro) 1639coro_enq (pTHX_ struct coro *coro)
1618{ 1640{
1619 av_push (coro_ready [coro->prio - PRIO_MIN], SvREFCNT_inc_NN (coro->hv)); 1641 struct coro **ready = coro_ready [coro->prio - CORO_PRIO_MIN];
1620}
1621 1642
1622INLINE SV * 1643 SvREFCNT_inc_NN (coro->hv);
1644
1645 coro->next_ready = 0;
1646 *(ready [0] ? &ready [1]->next_ready : &ready [0]) = coro;
1647 ready [1] = coro;
1648}
1649
1650INLINE struct coro *
1623coro_deq (pTHX) 1651coro_deq (pTHX)
1624{ 1652{
1625 int prio; 1653 int prio;
1626 1654
1627 for (prio = PRIO_MAX - PRIO_MIN + 1; --prio >= 0; ) 1655 for (prio = CORO_PRIO_MAX - CORO_PRIO_MIN + 1; --prio >= 0; )
1628 if (AvFILLp (coro_ready [prio]) >= 0) 1656 {
1629 return av_shift (coro_ready [prio]); 1657 struct coro **ready = coro_ready [prio];
1658
1659 if (ready [0])
1660 {
1661 struct coro *coro = ready [0];
1662 ready [0] = coro->next_ready;
1663 return coro;
1664 }
1665 }
1630 1666
1631 return 0; 1667 return 0;
1632} 1668}
1633 1669
1634static int 1670static int
… …
1698static void 1734static void
1699prepare_schedule (pTHX_ struct coro_transfer_args *ta) 1735prepare_schedule (pTHX_ struct coro_transfer_args *ta)
1700{ 1736{
1701 for (;;) 1737 for (;;)
1702 { 1738 {
1703 SV *next_sv = coro_deq (aTHX); 1739 struct coro *next = coro_deq (aTHX);
1704 1740
1705 if (expect_true (next_sv)) 1741 if (expect_true (next))
1706 { 1742 {
1707 struct coro *next = SvSTATE_hv (next_sv);
1708
1709 /* cannot transfer to destroyed coros, skip and look for next */ 1743 /* cannot transfer to destroyed coros, skip and look for next */
1710 if (expect_false (next->flags & CF_DESTROYED)) 1744 if (expect_false (next->flags & (CF_DESTROYED | CF_SUSPENDED)))
1711 SvREFCNT_dec (next_sv); /* coro_nready has already been taken care of by destroy */ 1745 SvREFCNT_dec (next->hv); /* coro_nready has already been taken care of by destroy */
1712 else 1746 else
1713 { 1747 {
1714 next->flags &= ~CF_READY; 1748 next->flags &= ~CF_READY;
1715 --coro_nready; 1749 --coro_nready;
1716 1750
… …
1990 SV *data = (SV *)GENSUB_ARG; 2024 SV *data = (SV *)GENSUB_ARG;
1991 2025
1992 if (SvTYPE (SvRV (data)) != SVt_PVAV) 2026 if (SvTYPE (SvRV (data)) != SVt_PVAV)
1993 { 2027 {
1994 /* first call, set args */ 2028 /* first call, set args */
2029 SV *coro = SvRV (data);
1995 AV *av = newAV (); 2030 AV *av = newAV ();
1996 SV *coro = SvRV (data);
1997 2031
1998 SvRV_set (data, (SV *)av); 2032 SvRV_set (data, (SV *)av);
1999 api_ready (aTHX_ coro);
2000 SvREFCNT_dec (coro);
2001 2033
2002 /* better take a full copy of the arguments */ 2034 /* better take a full copy of the arguments */
2003 while (items--) 2035 while (items--)
2004 av_store (av, items, newSVsv (ST (items))); 2036 av_store (av, items, newSVsv (ST (items)));
2037
2038 api_ready (aTHX_ coro);
2039 SvREFCNT_dec (coro);
2005 } 2040 }
2006 2041
2007 XSRETURN_EMPTY; 2042 XSRETURN_EMPTY;
2008} 2043}
2009 2044
… …
2026 2061
2027 EXTEND (SP, AvFILLp (av) + 1); 2062 EXTEND (SP, AvFILLp (av) + 1);
2028 for (i = 0; i <= AvFILLp (av); ++i) 2063 for (i = 0; i <= AvFILLp (av); ++i)
2029 PUSHs (sv_2mortal (AvARRAY (av)[i])); 2064 PUSHs (sv_2mortal (AvARRAY (av)[i]));
2030 2065
2031 /* we have stolen the elements, so ste length to zero and free */ 2066 /* we have stolen the elements, so set length to zero and free */
2032 AvFILLp (av) = -1; 2067 AvFILLp (av) = -1;
2033 av_undef (av); 2068 av_undef (av);
2034 2069
2035 PUTBACK; 2070 PUTBACK;
2036 } 2071 }
… …
2347 2382
2348 POPSTACK; 2383 POPSTACK;
2349} 2384}
2350 2385
2351static SV * 2386static SV *
2352coro_avp_pop_and_free (AV **avp) 2387coro_avp_pop_and_free (pTHX_ AV **avp)
2353{ 2388{
2354 AV *av = *avp; 2389 AV *av = *avp;
2355 SV *res = av_pop (av); 2390 SV *res = av_pop (av);
2356 2391
2357 if (AvFILLp (av) < 0) 2392 if (AvFILLp (av) < 0)
… …
2364} 2399}
2365 2400
2366static void 2401static void
2367coro_pop_on_enter (pTHX_ void *coro) 2402coro_pop_on_enter (pTHX_ void *coro)
2368{ 2403{
2369 SV *cb = coro_avp_pop_and_free (&((struct coro *)coro)->on_enter); 2404 SV *cb = coro_avp_pop_and_free (aTHX_ &((struct coro *)coro)->on_enter);
2370 SvREFCNT_dec (cb); 2405 SvREFCNT_dec (cb);
2371} 2406}
2372 2407
2373static void 2408static void
2374coro_pop_on_leave (pTHX_ void *coro) 2409coro_pop_on_leave (pTHX_ void *coro)
2375{ 2410{
2376 SV *cb = coro_avp_pop_and_free (&((struct coro *)coro)->on_leave); 2411 SV *cb = coro_avp_pop_and_free (aTHX_ &((struct coro *)coro)->on_leave);
2377 on_enterleave_call (sv_2mortal (cb)); 2412 on_enterleave_call (aTHX_ sv_2mortal (cb));
2378} 2413}
2379 2414
2380/*****************************************************************************/ 2415/*****************************************************************************/
2381/* PerlIO::cede */ 2416/* PerlIO::cede */
2382 2417
… …
2456/* Coro::Semaphore & Coro::Signal */ 2491/* Coro::Semaphore & Coro::Signal */
2457 2492
2458static SV * 2493static SV *
2459coro_waitarray_new (pTHX_ int count) 2494coro_waitarray_new (pTHX_ int count)
2460{ 2495{
2461 /* a semaphore contains a counter IV in $sem->[0] and any waiters after that */ 2496 /* a waitarray=semaphore contains a counter IV in $sem->[0] and any waiters after that */
2462 AV *av = newAV (); 2497 AV *av = newAV ();
2463 SV **ary; 2498 SV **ary;
2464 2499
2465 /* unfortunately, building manually saves memory */ 2500 /* unfortunately, building manually saves memory */
2466 Newx (ary, 2, SV *); 2501 Newx (ary, 2, SV *);
… …
2610 { 2645 {
2611 /* callback form */ 2646 /* callback form */
2612 AV *av = (AV *)SvRV (arg [0]); 2647 AV *av = (AV *)SvRV (arg [0]);
2613 CV *cb_cv = coro_sv_2cv (aTHX_ arg [1]); 2648 CV *cb_cv = coro_sv_2cv (aTHX_ arg [1]);
2614 2649
2615 av_push (av, (SV *)SvREFCNT_inc_NN (cb_cv)); 2650 av_push (av, SvREFCNT_inc_NN (cb_cv));
2616 2651
2617 if (SvIVX (AvARRAY (av)[0]) > 0) 2652 if (SvIVX (AvARRAY (av)[0]) > 0)
2618 coro_semaphore_adjust (aTHX_ av, 0); 2653 coro_semaphore_adjust (aTHX_ av, 0);
2619 2654
2620 frame->prepare = prepare_nop; 2655 frame->prepare = prepare_nop;
… …
2644 AvARRAY (av)[0] = AvARRAY (av)[1]; 2679 AvARRAY (av)[0] = AvARRAY (av)[1];
2645 AvARRAY (av)[1] = cb; 2680 AvARRAY (av)[1] = cb;
2646 2681
2647 cb = av_shift (av); 2682 cb = av_shift (av);
2648 2683
2684 if (SvTYPE (cb) == SVt_PVCV)
2685 {
2686 dSP;
2687 PUSHMARK (SP);
2688 XPUSHs (sv_2mortal (newRV_inc ((SV *)av)));
2689 PUTBACK;
2690 call_sv (cb, G_VOID | G_DISCARD | G_EVAL | G_KEEPERR);
2691 }
2692 else
2693 {
2649 api_ready (aTHX_ cb); 2694 api_ready (aTHX_ cb);
2650 sv_setiv (cb, 0); /* signal waiter */ 2695 sv_setiv (cb, 0); /* signal waiter */
2696 }
2697
2651 SvREFCNT_dec (cb); 2698 SvREFCNT_dec (cb);
2652 2699
2653 --count; 2700 --count;
2654 } 2701 }
2655} 2702}
… …
2664static void 2711static void
2665slf_init_signal_wait (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items) 2712slf_init_signal_wait (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2666{ 2713{
2667 AV *av = (AV *)SvRV (arg [0]); 2714 AV *av = (AV *)SvRV (arg [0]);
2668 2715
2716 if (items >= 2)
2717 {
2718 CV *cb_cv = coro_sv_2cv (aTHX_ arg [1]);
2719 av_push (av, SvREFCNT_inc_NN (cb_cv));
2720
2669 if (SvIVX (AvARRAY (av)[0])) 2721 if (SvIVX (AvARRAY (av)[0]))
2722 coro_signal_wake (aTHX_ av, 1); /* ust be the only waiter */
2723
2724 frame->prepare = prepare_nop;
2725 frame->check = slf_check_nop;
2726 }
2727 else if (SvIVX (AvARRAY (av)[0]))
2670 { 2728 {
2671 SvIVX (AvARRAY (av)[0]) = 0; 2729 SvIVX (AvARRAY (av)[0]) = 0;
2672 frame->prepare = prepare_nop; 2730 frame->prepare = prepare_nop;
2673 frame->check = slf_check_nop; 2731 frame->check = slf_check_nop;
2674 } 2732 }
2675 else 2733 else
2676 { 2734 {
2677 SV *waiter = newRV_inc (SvRV (coro_current)); /* owned by signal av */ 2735 SV *waiter = newSVsv (coro_current); /* owned by signal av */
2678 2736
2679 av_push (av, waiter); 2737 av_push (av, waiter);
2680 2738
2681 frame->data = (void *)sv_2mortal (SvREFCNT_inc_NN (waiter)); /* owned by process */ 2739 frame->data = (void *)sv_2mortal (SvREFCNT_inc_NN (waiter)); /* owned by process */
2682 frame->prepare = prepare_schedule; 2740 frame->prepare = prepare_schedule;
… …
2923 if (!SvIOK (*svp)) croak ("Time::NVtime isn't a function pointer"); 2981 if (!SvIOK (*svp)) croak ("Time::NVtime isn't a function pointer");
2924 2982
2925 nvtime = INT2PTR (double (*)(), SvIV (*svp)); 2983 nvtime = INT2PTR (double (*)(), SvIV (*svp));
2926 } 2984 }
2927 2985
2928 assert (("PRIO_NORMAL must be 0", !PRIO_NORMAL)); 2986 assert (("PRIO_NORMAL must be 0", !CORO_PRIO_NORMAL));
2929} 2987}
2930 2988
2931SV * 2989SV *
2932new (char *klass, ...) 2990new (char *klass, ...)
2933 ALIAS: 2991 ALIAS:
… …
3100 if (ix) 3158 if (ix)
3101 eval_sv (coderef, 0); 3159 eval_sv (coderef, 0);
3102 else 3160 else
3103 call_sv (coderef, G_KEEPERR | G_EVAL | G_VOID | G_DISCARD); 3161 call_sv (coderef, G_KEEPERR | G_EVAL | G_VOID | G_DISCARD);
3104 3162
3163 POPSTACK;
3105 SPAGAIN; 3164 SPAGAIN;
3106 POPSTACK;
3107 3165
3108 if (current != coro) 3166 if (current != coro)
3109 { 3167 {
3110 PUTBACK; 3168 PUTBACK;
3111 save_perl (aTHX_ coro); 3169 save_perl (aTHX_ coro);
… …
3121 ALIAS: 3179 ALIAS:
3122 is_ready = CF_READY 3180 is_ready = CF_READY
3123 is_running = CF_RUNNING 3181 is_running = CF_RUNNING
3124 is_new = CF_NEW 3182 is_new = CF_NEW
3125 is_destroyed = CF_DESTROYED 3183 is_destroyed = CF_DESTROYED
3184 is_suspended = CF_SUSPENDED
3126 CODE: 3185 CODE:
3127 RETVAL = boolSV (coro->flags & ix); 3186 RETVAL = boolSV (coro->flags & ix);
3128 OUTPUT: 3187 OUTPUT:
3129 RETVAL 3188 RETVAL
3130 3189
… …
3134 CODE: 3193 CODE:
3135{ 3194{
3136 struct coro *current = SvSTATE_current; 3195 struct coro *current = SvSTATE_current;
3137 SV **throwp = self == current ? &CORO_THROW : &self->except; 3196 SV **throwp = self == current ? &CORO_THROW : &self->except;
3138 SvREFCNT_dec (*throwp); 3197 SvREFCNT_dec (*throwp);
3198 SvGETMAGIC (throw);
3139 *throwp = SvOK (throw) ? newSVsv (throw) : 0; 3199 *throwp = SvOK (throw) ? newSVsv (throw) : 0;
3140} 3200}
3141 3201
3142void 3202void
3143api_trace (SV *coro, int flags = CC_TRACE | CC_TRACE_SUB) 3203api_trace (SV *coro, int flags = CC_TRACE | CC_TRACE_SUB)
… …
3195 SV **dst = ix ? (SV **)&self->slot->defav : (SV **)&self->slot->defsv; 3255 SV **dst = ix ? (SV **)&self->slot->defav : (SV **)&self->slot->defsv;
3196 3256
3197 SV *tmp = *src; *src = *dst; *dst = tmp; 3257 SV *tmp = *src; *src = *dst; *dst = tmp;
3198 } 3258 }
3199 3259
3260void
3261cancel (Coro::State self)
3262 CODE:
3263 coro_state_destroy (aTHX_ self);
3264 coro_call_on_destroy (aTHX_ self); /* actually only for Coro objects */
3265
3200 3266
3201MODULE = Coro::State PACKAGE = Coro 3267MODULE = Coro::State PACKAGE = Coro
3202 3268
3203BOOT: 3269BOOT:
3204{ 3270{
3205 int i;
3206
3207 sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE); 3271 sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE);
3208 sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE); 3272 sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE);
3209 cv_coro_run = get_cv ( "Coro::_coro_run" , GV_ADD); 3273 cv_coro_run = get_cv ( "Coro::_coro_run" , GV_ADD);
3210 cv_coro_terminate = get_cv ( "Coro::terminate" , GV_ADD); 3274 cv_coro_terminate = get_cv ( "Coro::terminate" , GV_ADD);
3211 coro_current = coro_get_sv (aTHX_ "Coro::current" , FALSE); SvREADONLY_on (coro_current); 3275 coro_current = coro_get_sv (aTHX_ "Coro::current" , FALSE); SvREADONLY_on (coro_current);
… …
3219 cv_pool_handler = get_cv ("Coro::pool_handler", GV_ADD); SvREADONLY_on (cv_pool_handler); 3283 cv_pool_handler = get_cv ("Coro::pool_handler", GV_ADD); SvREADONLY_on (cv_pool_handler);
3220 cv_coro_state_new = get_cv ("Coro::State::new", 0); SvREADONLY_on (cv_coro_state_new); 3284 cv_coro_state_new = get_cv ("Coro::State::new", 0); SvREADONLY_on (cv_coro_state_new);
3221 3285
3222 coro_stash = gv_stashpv ("Coro", TRUE); 3286 coro_stash = gv_stashpv ("Coro", TRUE);
3223 3287
3224 newCONSTSUB (coro_stash, "PRIO_MAX", newSViv (PRIO_MAX)); 3288 newCONSTSUB (coro_stash, "PRIO_MAX", newSViv (CORO_PRIO_MAX));
3225 newCONSTSUB (coro_stash, "PRIO_HIGH", newSViv (PRIO_HIGH)); 3289 newCONSTSUB (coro_stash, "PRIO_HIGH", newSViv (CORO_PRIO_HIGH));
3226 newCONSTSUB (coro_stash, "PRIO_NORMAL", newSViv (PRIO_NORMAL)); 3290 newCONSTSUB (coro_stash, "PRIO_NORMAL", newSViv (CORO_PRIO_NORMAL));
3227 newCONSTSUB (coro_stash, "PRIO_LOW", newSViv (PRIO_LOW)); 3291 newCONSTSUB (coro_stash, "PRIO_LOW", newSViv (CORO_PRIO_LOW));
3228 newCONSTSUB (coro_stash, "PRIO_IDLE", newSViv (PRIO_IDLE)); 3292 newCONSTSUB (coro_stash, "PRIO_IDLE", newSViv (CORO_PRIO_IDLE));
3229 newCONSTSUB (coro_stash, "PRIO_MIN", newSViv (PRIO_MIN)); 3293 newCONSTSUB (coro_stash, "PRIO_MIN", newSViv (CORO_PRIO_MIN));
3230
3231 for (i = PRIO_MAX - PRIO_MIN + 1; i--; )
3232 coro_ready[i] = newAV ();
3233 3294
3234 { 3295 {
3235 SV *sv = coro_get_sv (aTHX_ "Coro::API", TRUE); 3296 SV *sv = coro_get_sv (aTHX_ "Coro::API", TRUE);
3236 3297
3237 coroapi.schedule = api_schedule; 3298 coroapi.schedule = api_schedule;
… …
3278cede_notself (...) 3339cede_notself (...)
3279 CODE: 3340 CODE:
3280 CORO_EXECUTE_SLF_XS (slf_init_cede_notself); 3341 CORO_EXECUTE_SLF_XS (slf_init_cede_notself);
3281 3342
3282void 3343void
3283_cancel (Coro::State self)
3284 CODE:
3285 coro_state_destroy (aTHX_ self);
3286 coro_call_on_destroy (aTHX_ self);
3287
3288void
3289_set_current (SV *current) 3344_set_current (SV *current)
3290 PROTOTYPE: $ 3345 PROTOTYPE: $
3291 CODE: 3346 CODE:
3292 SvREFCNT_dec (SvRV (coro_current)); 3347 SvREFCNT_dec (SvRV (coro_current));
3293 SvRV_set (coro_current, SvREFCNT_inc_NN (SvRV (current))); 3348 SvRV_set (coro_current, SvREFCNT_inc_NN (SvRV (current)));
… …
3295void 3350void
3296_set_readyhook (SV *hook) 3351_set_readyhook (SV *hook)
3297 PROTOTYPE: $ 3352 PROTOTYPE: $
3298 CODE: 3353 CODE:
3299 SvREFCNT_dec (coro_readyhook); 3354 SvREFCNT_dec (coro_readyhook);
3355 SvGETMAGIC (hook);
3300 coro_readyhook = SvOK (hook) ? newSVsv (hook) : 0; 3356 coro_readyhook = SvOK (hook) ? newSVsv (hook) : 0;
3301 3357
3302int 3358int
3303prio (Coro::State coro, int newprio = 0) 3359prio (Coro::State coro, int newprio = 0)
3304 PROTOTYPE: $;$ 3360 PROTOTYPE: $;$
… …
3335 PROTOTYPE: 3391 PROTOTYPE:
3336 CODE: 3392 CODE:
3337 RETVAL = coro_nready; 3393 RETVAL = coro_nready;
3338 OUTPUT: 3394 OUTPUT:
3339 RETVAL 3395 RETVAL
3396
3397void
3398suspend (Coro::State self)
3399 PROTOTYPE: $
3400 CODE:
3401 self->flags |= CF_SUSPENDED;
3402
3403void
3404resume (Coro::State self)
3405 PROTOTYPE: $
3406 CODE:
3407 self->flags &= ~CF_SUSPENDED;
3340 3408
3341void 3409void
3342_pool_handler (...) 3410_pool_handler (...)
3343 CODE: 3411 CODE:
3344 CORO_EXECUTE_SLF_XS (slf_init_pool_handler); 3412 CORO_EXECUTE_SLF_XS (slf_init_pool_handler);
… …
3409 CODE: 3477 CODE:
3410{ 3478{
3411 struct coro *coro = SvSTATE_current; 3479 struct coro *coro = SvSTATE_current;
3412 AV **avp = ix ? &coro->on_leave : &coro->on_enter; 3480 AV **avp = ix ? &coro->on_leave : &coro->on_enter;
3413 3481
3414 block = (SV *)coro_sv_2cv (block); 3482 block = (SV *)coro_sv_2cv (aTHX_ block);
3415 3483
3416 if (!*avp) 3484 if (!*avp)
3417 *avp = newAV (); 3485 *avp = newAV ();
3418 3486
3419 av_push (*avp, SvREFCNT_inc (block)); 3487 av_push (*avp, SvREFCNT_inc (block));
3420 3488
3421 if (!ix) 3489 if (!ix)
3422 on_enterleave_call (aTHX_ block); 3490 on_enterleave_call (aTHX_ block);
3423 3491
3424 LEAVE; /* pp_entersub unfortunately forces an ENTER/LEAVE around xs calls */ 3492 LEAVE; /* pp_entersub unfortunately forces an ENTER/LEAVE around XS calls */
3425 SAVEDESTRUCTOR_X (ix ? coro_pop_on_leave : coro_pop_on_enter, (void *)coro); 3493 SAVEDESTRUCTOR_X (ix ? coro_pop_on_leave : coro_pop_on_enter, (void *)coro);
3426 ENTER; /* pp_entersub unfortunately forces an ENTER/LEAVE around xs calls */ 3494 ENTER; /* pp_entersub unfortunately forces an ENTER/LEAVE around XS calls */
3427} 3495}
3428 3496
3429 3497
3430MODULE = Coro::State PACKAGE = PerlIO::cede 3498MODULE = Coro::State PACKAGE = PerlIO::cede
3431 3499
… …
3436MODULE = Coro::State PACKAGE = Coro::Semaphore 3504MODULE = Coro::State PACKAGE = Coro::Semaphore
3437 3505
3438SV * 3506SV *
3439new (SV *klass, SV *count = 0) 3507new (SV *klass, SV *count = 0)
3440 CODE: 3508 CODE:
3509{
3510 int semcnt = 1;
3511
3512 if (count)
3513 {
3514 SvGETMAGIC (count);
3515
3516 if (SvOK (count))
3517 semcnt = SvIV (count);
3518 }
3519
3441 RETVAL = sv_bless ( 3520 RETVAL = sv_bless (
3442 coro_waitarray_new (aTHX_ count && SvOK (count) ? SvIV (count) : 1), 3521 coro_waitarray_new (aTHX_ semcnt),
3443 GvSTASH (CvGV (cv)) 3522 GvSTASH (CvGV (cv))
3444 ); 3523 );
3524}
3445 OUTPUT: 3525 OUTPUT:
3446 RETVAL 3526 RETVAL
3447 3527
3448# helper for Coro::Channel 3528# helper for Coro::Channel and others
3449SV * 3529SV *
3450_alloc (int count) 3530_alloc (int count)
3451 CODE: 3531 CODE:
3452 RETVAL = coro_waitarray_new (aTHX_ count); 3532 RETVAL = coro_waitarray_new (aTHX_ count);
3453 OUTPUT: 3533 OUTPUT:
… …
3511 for (i = 1; i <= wcount; ++i) 3591 for (i = 1; i <= wcount; ++i)
3512 PUSHs (sv_2mortal (newRV_inc (AvARRAY (av)[i]))); 3592 PUSHs (sv_2mortal (newRV_inc (AvARRAY (av)[i])));
3513 } 3593 }
3514} 3594}
3515 3595
3596MODULE = Coro::State PACKAGE = Coro::SemaphoreSet
3597
3598void
3599_may_delete (SV *sem, int count, int extra_refs)
3600 PPCODE:
3601{
3602 AV *av = (AV *)SvRV (sem);
3603
3604 if (SvREFCNT ((SV *)av) == 1 + extra_refs
3605 && AvFILLp (av) == 0 /* no waiters, just count */
3606 && SvIV (AvARRAY (av)[0]) == count)
3607 XSRETURN_YES;
3608
3609 XSRETURN_NO;
3610}
3611
3516MODULE = Coro::State PACKAGE = Coro::Signal 3612MODULE = Coro::State PACKAGE = Coro::Signal
3517 3613
3518SV * 3614SV *
3519new (SV *klass) 3615new (SV *klass)
3520 CODE: 3616 CODE:

Diff Legend

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