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.266 by root, Fri Nov 14 03:26:22 2008 UTC vs.
Revision 1.273 by root, Fri Nov 14 23:48:10 2008 UTC

… …
116# define CORO_PREFER_PERL_FUNCTIONS 0 116# define CORO_PREFER_PERL_FUNCTIONS 0
117#endif 117#endif
118 118
119/* The next macros try to return the current stack pointer, in an as 119/* The next macros try to return the current stack pointer, in an as
120 * portable way as possible. */ 120 * portable way as possible. */
121#define dSTACKLEVEL volatile char stacklevel 121#if __GNUC__ >= 4
122#define STACKLEVEL ((void *)&stacklevel) 122# define dSTACKLEVEL void *stacklevel = __builtin_frame_address (0)
123#else
124# define dSTACKLEVEL volatile void *stacklevel = (volatile void *)&stacklevel
125#endif
123 126
124#define IN_DESTRUCT (PL_main_cv == Nullcv) 127#define IN_DESTRUCT (PL_main_cv == Nullcv)
125 128
126#if __GNUC__ >= 3 129#if __GNUC__ >= 3
127# define attribute(x) __attribute__(x) 130# define attribute(x) __attribute__(x)
… …
180static JMPENV *main_top_env; 183static JMPENV *main_top_env;
181static HV *coro_state_stash, *coro_stash; 184static HV *coro_state_stash, *coro_stash;
182static volatile SV *coro_mortal; /* will be freed/thrown after next transfer */ 185static volatile SV *coro_mortal; /* will be freed/thrown after next transfer */
183static volatile struct coro *transfer_next; 186static volatile struct coro *transfer_next;
184 187
185struct transfer_args
186{
187 struct coro *prev, *next;
188};
189
190static GV *irsgv; /* $/ */ 188static GV *irsgv; /* $/ */
191static GV *stdoutgv; /* *STDOUT */ 189static GV *stdoutgv; /* *STDOUT */
192static SV *rv_diehook; 190static SV *rv_diehook;
193static SV *rv_warnhook; 191static SV *rv_warnhook;
194static HV *hv_sig; /* %SIG */ 192static HV *hv_sig; /* %SIG */
… …
212 CC_TRACE_LINE = 0x10, /* trace each statement */ 210 CC_TRACE_LINE = 0x10, /* trace each statement */
213 CC_TRACE_ALL = CC_TRACE_SUB | CC_TRACE_LINE, 211 CC_TRACE_ALL = CC_TRACE_SUB | CC_TRACE_LINE,
214}; 212};
215 213
216/* this is a structure representing a c-level coroutine */ 214/* this is a structure representing a c-level coroutine */
217typedef struct coro_cctx { 215typedef struct coro_cctx
216{
218 struct coro_cctx *next; 217 struct coro_cctx *next;
219 218
220 /* the stack */ 219 /* the stack */
221 void *sptr; 220 void *sptr;
222 size_t ssize; 221 size_t ssize;
… …
240 CF_NEW = 0x0004, /* has never been switched to */ 239 CF_NEW = 0x0004, /* has never been switched to */
241 CF_DESTROYED = 0x0008, /* coroutine data has been freed */ 240 CF_DESTROYED = 0x0008, /* coroutine data has been freed */
242}; 241};
243 242
244/* the structure where most of the perl state is stored, overlaid on the cxstack */ 243/* the structure where most of the perl state is stored, overlaid on the cxstack */
245typedef struct { 244typedef struct
245{
246 SV *defsv; 246 SV *defsv;
247 AV *defav; 247 AV *defav;
248 SV *errsv; 248 SV *errsv;
249 SV *irsgv; 249 SV *irsgv;
250#define VAR(name,type) type name; 250#define VAR(name,type) type name;
… …
254 254
255#define SLOT_COUNT ((sizeof (perl_slots) + sizeof (PERL_CONTEXT) - 1) / sizeof (PERL_CONTEXT)) 255#define SLOT_COUNT ((sizeof (perl_slots) + sizeof (PERL_CONTEXT) - 1) / sizeof (PERL_CONTEXT))
256 256
257/* this is a structure representing a perl-level coroutine */ 257/* this is a structure representing a perl-level coroutine */
258struct coro { 258struct coro {
259 /* the c coroutine allocated to this perl coroutine, if any */ 259 /* the C coroutine allocated to this perl coroutine, if any */
260 coro_cctx *cctx; 260 coro_cctx *cctx;
261 261
262 /* process data */ 262 /* process data */
263 struct CoroSLF slf_frame; /* saved slf frame */
263 AV *mainstack; 264 AV *mainstack;
264 perl_slots *slot; /* basically the saved sp */ 265 perl_slots *slot; /* basically the saved sp */
265 266
266 AV *args; /* data associated with this coroutine (initial args) */ 267 AV *args; /* data associated with this coroutine (initial args) */
267 int refcnt; /* coroutines are refcounted, yes */ 268 int refcnt; /* coroutines are refcounted, yes */
… …
282 struct coro *next, *prev; 283 struct coro *next, *prev;
283}; 284};
284 285
285typedef struct coro *Coro__State; 286typedef struct coro *Coro__State;
286typedef struct coro *Coro__State_or_hashref; 287typedef struct coro *Coro__State_or_hashref;
288
289static struct CoroSLF slf_frame; /* the current slf frame */
287 290
288/** Coro ********************************************************************/ 291/** Coro ********************************************************************/
289 292
290#define PRIO_MAX 3 293#define PRIO_MAX 3
291#define PRIO_HIGH 1 294#define PRIO_HIGH 1
… …
296 299
297/* for Coro.pm */ 300/* for Coro.pm */
298static SV *coro_current; 301static SV *coro_current;
299static SV *coro_readyhook; 302static SV *coro_readyhook;
300static AV *coro_ready [PRIO_MAX - PRIO_MIN + 1]; 303static AV *coro_ready [PRIO_MAX - PRIO_MIN + 1];
301static int coro_nready;
302static struct coro *coro_first; 304static struct coro *coro_first;
305#define coro_nready coroapi.nready
303 306
304/** lowlevel stuff **********************************************************/ 307/** lowlevel stuff **********************************************************/
305 308
306static SV * 309static SV *
307coro_get_sv (pTHX_ const char *name, int create) 310coro_get_sv (pTHX_ const char *name, int create)
… …
511 CvPADLIST (cv) = (AV *)POPs; 514 CvPADLIST (cv) = (AV *)POPs;
512 } 515 }
513 516
514 PUTBACK; 517 PUTBACK;
515 } 518 }
519
520 slf_frame = c->slf_frame;
516} 521}
517 522
518static void 523static void
519save_perl (pTHX_ Coro__State c) 524save_perl (pTHX_ Coro__State c)
520{ 525{
526 c->slf_frame = slf_frame;
527
521 { 528 {
522 dSP; 529 dSP;
523 I32 cxix = cxstack_ix; 530 I32 cxix = cxstack_ix;
524 PERL_CONTEXT *ccstk = cxstack; 531 PERL_CONTEXT *ccstk = cxstack;
525 PERL_SI *top_si = PL_curstackinfo; 532 PERL_SI *top_si = PL_curstackinfo;
… …
592 #undef VAR 599 #undef VAR
593 } 600 }
594} 601}
595 602
596/* 603/*
597 * allocate various perl stacks. This is an exact copy 604 * allocate various perl stacks. This is almost an exact copy
598 * of perl.c:init_stacks, except that it uses less memory 605 * of perl.c:init_stacks, except that it uses less memory
599 * on the (sometimes correct) assumption that coroutines do 606 * on the (sometimes correct) assumption that coroutines do
600 * not usually need a lot of stackspace. 607 * not usually need a lot of stackspace.
601 */ 608 */
602#if CORO_PREFER_PERL_FUNCTIONS 609#if CORO_PREFER_PERL_FUNCTIONS
… …
709#endif 716#endif
710 } 717 }
711 } 718 }
712 719
713 return rss; 720 return rss;
714}
715
716/** set stacklevel support **************************************************/
717
718/* we sometimes need to create the effect of pp_set_stacklevel calling us */
719#define SSL_HEAD (void)0
720/* we somtimes need to create the effect of leaving via pp_set_stacklevel */
721#define SSL_TAIL set_stacklevel_tail (aTHX)
722
723INLINE void
724set_stacklevel_tail (pTHX)
725{
726 dSP;
727 SV **bot = SP;
728
729 int gimme = GIMME_V;
730
731 /* make sure we put something on the stack in scalar context */
732 if (gimme == G_SCALAR)
733 {
734 if (sp == bot)
735 XPUSHs (&PL_sv_undef);
736
737 SP = bot + 1;
738 }
739
740 PUTBACK;
741} 721}
742 722
743/** coroutine stack handling ************************************************/ 723/** coroutine stack handling ************************************************/
744 724
745static int (*orig_sigelem_get) (pTHX_ SV *sv, MAGIC *mg); 725static int (*orig_sigelem_get) (pTHX_ SV *sv, MAGIC *mg);
… …
831 811
832 return orig_sigelem_set ? orig_sigelem_set (aTHX_ sv, mg) : 0; 812 return orig_sigelem_set ? orig_sigelem_set (aTHX_ sv, mg) : 0;
833} 813}
834 814
835static void 815static void
816prepare_nop (aTHX_ struct coro_transfer_args *ta)
817{
818 /* kind of mega-hacky, but works */
819 ta->next = ta->prev = (struct coro *)ta;
820}
821
822static int
823slf_check_nop (aTHX)
824{
825 return 0;
826}
827
828static void
836coro_setup (pTHX_ struct coro *coro) 829coro_setup (pTHX_ struct coro *coro)
837{ 830{
838 /* 831 /*
839 * emulate part of the perl startup here. 832 * emulate part of the perl startup here.
840 */ 833 */
… …
879 PL_op = PL_ppaddr[OP_ENTERSUB](aTHX); 872 PL_op = PL_ppaddr[OP_ENTERSUB](aTHX);
880 SPAGAIN; 873 SPAGAIN;
881 } 874 }
882 875
883 /* this newly created coroutine might be run on an existing cctx which most 876 /* this newly created coroutine might be run on an existing cctx which most
884 * likely was suspended in set_stacklevel, called from pp_set_stacklevel, 877 * likely was suspended in pp_slf, so we have to emulate entering pp_slf here.
885 * so we have to emulate entering pp_set_stacklevel here.
886 */ 878 */
887 SSL_HEAD; 879 slf_frame.prepare = prepare_nop; /* provide a nop function for an eventual pp_slf */
880 slf_frame.check = slf_check_nop; /* signal pp_slf to not repeat */
888} 881}
889 882
890static void 883static void
891coro_destruct (pTHX_ struct coro *coro) 884coro_destruct (pTHX_ struct coro *coro)
892{ 885{
… …
1056 TAINT_NOT; 1049 TAINT_NOT;
1057 return 0; 1050 return 0;
1058} 1051}
1059 1052
1060static void 1053static void
1061prepare_set_stacklevel (struct transfer_args *ta, struct coro_cctx *cctx) 1054prepare_set_stacklevel (struct coro_transfer_args *ta, struct coro_cctx *cctx)
1062{ 1055{
1063 ta->prev = (struct coro *)cctx; 1056 ta->prev = (struct coro *)cctx;
1064 ta->next = 0; 1057 ta->next = 0;
1065} 1058}
1066 1059
… …
1126# endif 1119# endif
1127#endif 1120#endif
1128 { 1121 {
1129 dTHX; 1122 dTHX;
1130 1123
1131 /* we are the alternative tail to pp_set_stacklevel */ 1124 /* normally we would need to skip the entersub here */
1132 /* so do the same things here */ 1125 /* not doing so will re-execute it, which is exactly what we want */
1133 SSL_TAIL;
1134
1135 /* we now skip the op that did lead to transfer() */
1136 PL_op = PL_op->op_next; 1126 /* PL_nop = PL_nop->op_next */
1137 1127
1138 /* inject a fake subroutine call to cctx_init */ 1128 /* inject a fake subroutine call to cctx_init */
1139 cctx_prepare (aTHX_ (coro_cctx *)arg); 1129 cctx_prepare (aTHX_ (coro_cctx *)arg);
1140 1130
1141 /* cctx_run is the alternative tail of transfer() */ 1131 /* cctx_run is the alternative tail of transfer() */
1132 /* TODO: throwing an exception here might be deadly, VERIFY */
1142 transfer_tail (aTHX); 1133 transfer_tail (aTHX);
1143 1134
1144 /* somebody or something will hit me for both perl_run and PL_restartop */ 1135 /* somebody or something will hit me for both perl_run and PL_restartop */
1145 PL_restartop = PL_op; 1136 PL_restartop = PL_op;
1146 perl_run (PL_curinterp); 1137 perl_run (PL_curinterp);
… …
1305transfer_check (pTHX_ struct coro *prev, struct coro *next) 1296transfer_check (pTHX_ struct coro *prev, struct coro *next)
1306{ 1297{
1307 if (expect_true (prev != next)) 1298 if (expect_true (prev != next))
1308 { 1299 {
1309 if (expect_false (!(prev->flags & (CF_RUNNING | CF_NEW)))) 1300 if (expect_false (!(prev->flags & (CF_RUNNING | CF_NEW))))
1310 croak ("Coro::State::transfer called with non-running/new prev Coro::State, but can only transfer from running or new states"); 1301 croak ("Coro::State::transfer called with non-running/new prev Coro::State, but can only transfer from running or new states,");
1311 1302
1312 if (expect_false (next->flags & CF_RUNNING)) 1303 if (expect_false (next->flags & CF_RUNNING))
1313 croak ("Coro::State::transfer called with running next Coro::State, but can only transfer to inactive states"); 1304 croak ("Coro::State::transfer called with running next Coro::State, but can only transfer to inactive states,");
1314 1305
1315 if (expect_false (next->flags & CF_DESTROYED)) 1306 if (expect_false (next->flags & CF_DESTROYED))
1316 croak ("Coro::State::transfer called with destroyed next Coro::State, but can only transfer to inactive states"); 1307 croak ("Coro::State::transfer called with destroyed next Coro::State, but can only transfer to inactive states,");
1317 1308
1318#if !PERL_VERSION_ATLEAST (5,10,0) 1309#if !PERL_VERSION_ATLEAST (5,10,0)
1319 if (expect_false (PL_lex_state != LEX_NOTPARSING)) 1310 if (expect_false (PL_lex_state != LEX_NOTPARSING))
1320 croak ("Coro::State::transfer called while parsing, but this is not supported in your perl version"); 1311 croak ("Coro::State::transfer called while parsing, but this is not supported in your perl version,");
1321#endif 1312#endif
1322 } 1313 }
1323} 1314}
1324 1315
1325/* always use the TRANSFER macro */ 1316/* always use the TRANSFER macro */
… …
1329 dSTACKLEVEL; 1320 dSTACKLEVEL;
1330 1321
1331 /* sometimes transfer is only called to set idle_sp */ 1322 /* sometimes transfer is only called to set idle_sp */
1332 if (expect_false (!next)) 1323 if (expect_false (!next))
1333 { 1324 {
1334 ((coro_cctx *)prev)->idle_sp = STACKLEVEL; 1325 ((coro_cctx *)prev)->idle_sp = stacklevel;
1335 assert (((coro_cctx *)prev)->idle_te = PL_top_env); /* just for the side-effect when asserts are enabled */ 1326 assert (((coro_cctx *)prev)->idle_te = PL_top_env); /* just for the side-effect when asserts are enabled */
1336 } 1327 }
1337 else if (expect_true (prev != next)) 1328 else if (expect_true (prev != next))
1338 { 1329 {
1339 coro_cctx *prev__cctx; 1330 coro_cctx *prev__cctx;
… …
1366 1357
1367 prev__cctx = prev->cctx; 1358 prev__cctx = prev->cctx;
1368 1359
1369 /* possibly untie and reuse the cctx */ 1360 /* possibly untie and reuse the cctx */
1370 if (expect_true ( 1361 if (expect_true (
1371 prev__cctx->idle_sp == STACKLEVEL 1362 prev__cctx->idle_sp == stacklevel
1372 && !(prev__cctx->flags & CC_TRACE) 1363 && !(prev__cctx->flags & CC_TRACE)
1373 && !force_cctx 1364 && !force_cctx
1374 )) 1365 ))
1375 { 1366 {
1376 /* I assume that STACKLEVEL is a stronger indicator than PL_top_env changes */ 1367 /* I assume that stacklevel is a stronger indicator than PL_top_env changes */
1377 assert (("FATAL: current top_env must equal previous top_env in Coro (please report)", PL_top_env == prev__cctx->idle_te)); 1368 assert (("FATAL: current top_env must equal previous top_env in Coro (please report)", PL_top_env == prev__cctx->idle_te));
1378 1369
1379 prev->cctx = 0; 1370 prev->cctx = 0;
1380 1371
1381 /* if the cctx is about to be destroyed we need to make sure we won't see it in cctx_get */ 1372 /* if the cctx is about to be destroyed we need to make sure we won't see it in cctx_get */
… …
1432 1423
1433 if (coro->mainstack && coro->mainstack != main_mainstack) 1424 if (coro->mainstack && coro->mainstack != main_mainstack)
1434 { 1425 {
1435 struct coro temp; 1426 struct coro temp;
1436 1427
1437 if (coro->flags & CF_RUNNING) 1428 assert (("FATAL: tried to destroy currently running coroutine (please report)", !(coro->flags & CF_RUNNING)));
1438 croak ("FATAL: tried to destroy currently running coroutine");
1439 1429
1440 save_perl (aTHX_ &temp); 1430 save_perl (aTHX_ &temp);
1441 load_perl (aTHX_ coro); 1431 load_perl (aTHX_ coro);
1442 1432
1443 coro_destruct (aTHX_ coro); 1433 coro_destruct (aTHX_ coro);
… …
1494# define MGf_DUP 0 1484# define MGf_DUP 0
1495#endif 1485#endif
1496}; 1486};
1497 1487
1498static void 1488static void
1499prepare_transfer (pTHX_ struct transfer_args *ta, SV *prev_sv, SV *next_sv) 1489prepare_transfer (pTHX_ struct coro_transfer_args *ta, SV *prev_sv, SV *next_sv)
1500{ 1490{
1501 ta->prev = SvSTATE (prev_sv); 1491 ta->prev = SvSTATE (prev_sv);
1502 ta->next = SvSTATE (next_sv); 1492 ta->next = SvSTATE (next_sv);
1503 TRANSFER_CHECK (*ta); 1493 TRANSFER_CHECK (*ta);
1504} 1494}
1505 1495
1506static void 1496static void
1507api_transfer (SV *prev_sv, SV *next_sv) 1497api_transfer (pTHX_ SV *prev_sv, SV *next_sv)
1508{ 1498{
1509 dTHX;
1510 struct transfer_args ta; 1499 struct coro_transfer_args ta;
1511 1500
1512 prepare_transfer (aTHX_ &ta, prev_sv, next_sv); 1501 prepare_transfer (aTHX_ &ta, prev_sv, next_sv);
1513 TRANSFER (ta, 1); 1502 TRANSFER (ta, 1);
1514} 1503}
1515 1504
… …
1532 1521
1533 return 0; 1522 return 0;
1534} 1523}
1535 1524
1536static int 1525static int
1537api_ready (SV *coro_sv) 1526api_ready (pTHX_ SV *coro_sv)
1538{ 1527{
1539 dTHX;
1540 struct coro *coro; 1528 struct coro *coro;
1541 SV *sv_hook; 1529 SV *sv_hook;
1542 void (*xs_hook)(void); 1530 void (*xs_hook)(void);
1543 1531
1544 if (SvROK (coro_sv)) 1532 if (SvROK (coro_sv))
… …
1582 1570
1583 return 1; 1571 return 1;
1584} 1572}
1585 1573
1586static int 1574static int
1587api_is_ready (SV *coro_sv) 1575api_is_ready (pTHX_ SV *coro_sv)
1588{ 1576{
1589 dTHX;
1590
1591 return !!(SvSTATE (coro_sv)->flags & CF_READY); 1577 return !!(SvSTATE (coro_sv)->flags & CF_READY);
1592} 1578}
1593 1579
1594INLINE void 1580INLINE void
1595prepare_schedule (pTHX_ struct transfer_args *ta) 1581prepare_schedule (pTHX_ struct coro_transfer_args *ta)
1596{ 1582{
1597 SV *prev_sv, *next_sv; 1583 SV *prev_sv, *next_sv;
1598 1584
1599 for (;;) 1585 for (;;)
1600 { 1586 {
… …
1649 coro_mortal = prev_sv; 1635 coro_mortal = prev_sv;
1650 UNLOCK; 1636 UNLOCK;
1651} 1637}
1652 1638
1653INLINE void 1639INLINE void
1654prepare_cede (pTHX_ struct transfer_args *ta) 1640prepare_cede (pTHX_ struct coro_transfer_args *ta)
1655{ 1641{
1656 api_ready (coro_current); 1642 api_ready (aTHX_ coro_current);
1657 prepare_schedule (aTHX_ ta); 1643 prepare_schedule (aTHX_ ta);
1658} 1644}
1659 1645
1646INLINE void
1647prepare_cede_notself (pTHX_ struct coro_transfer_args *ta)
1648{
1649 SV *prev = SvRV (coro_current);
1650
1651 if (coro_nready)
1652 {
1653 prepare_schedule (aTHX_ ta);
1654 api_ready (aTHX_ prev);
1655 }
1656 else
1657 prepare_nop (aTHX_ ta);
1658}
1659
1660static void
1661api_schedule (pTHX)
1662{
1663 struct coro_transfer_args ta;
1664
1665 prepare_schedule (aTHX_ &ta);
1666 TRANSFER (ta, 1);
1667}
1668
1660static int 1669static int
1661prepare_cede_notself (pTHX_ struct transfer_args *ta) 1670api_cede (pTHX)
1662{ 1671{
1663 if (coro_nready) 1672 struct coro_transfer_args ta;
1664 { 1673
1665 SV *prev = SvRV (coro_current);
1666 prepare_schedule (aTHX_ ta); 1674 prepare_cede (aTHX_ &ta);
1667 api_ready (prev); 1675
1676 if (expect_true (ta.prev != ta.next))
1677 {
1678 TRANSFER (ta, 1);
1668 return 1; 1679 return 1;
1669 } 1680 }
1670 else 1681 else
1671 return 0; 1682 return 0;
1672} 1683}
1673 1684
1674static void
1675api_schedule (void)
1676{
1677 dTHX;
1678 struct transfer_args ta;
1679
1680 prepare_schedule (aTHX_ &ta);
1681 TRANSFER (ta, 1);
1682}
1683
1684static int 1685static int
1685api_cede (void) 1686api_cede_notself (pTHX)
1686{ 1687{
1687 dTHX; 1688 if (coro_nready)
1689 {
1688 struct transfer_args ta; 1690 struct coro_transfer_args ta;
1689 1691
1690 prepare_cede (aTHX_ &ta); 1692 prepare_cede_notself (aTHX_ &ta);
1691
1692 if (expect_true (ta.prev != ta.next))
1693 {
1694 TRANSFER (ta, 1); 1693 TRANSFER (ta, 1);
1695 return 1; 1694 return 1;
1696 } 1695 }
1697 else 1696 else
1698 return 0; 1697 return 0;
1699} 1698}
1700 1699
1701static int 1700static void
1702api_cede_notself (void)
1703{
1704 dTHX;
1705 struct transfer_args ta;
1706
1707 if (prepare_cede_notself (aTHX_ &ta))
1708 {
1709 TRANSFER (ta, 1);
1710 return 1;
1711 }
1712 else
1713 return 0;
1714}
1715
1716static void
1717api_trace (SV *coro_sv, int flags) 1701api_trace (pTHX_ SV *coro_sv, int flags)
1718{ 1702{
1719 dTHX;
1720 struct coro *coro = SvSTATE (coro_sv); 1703 struct coro *coro = SvSTATE (coro_sv);
1721 1704
1722 if (flags & CC_TRACE) 1705 if (flags & CC_TRACE)
1723 { 1706 {
1724 if (!coro->cctx) 1707 if (!coro->cctx)
1725 coro->cctx = cctx_new_run (); 1708 coro->cctx = cctx_new_run ();
1726 else if (!(coro->cctx->flags & CC_TRACE)) 1709 else if (!(coro->cctx->flags & CC_TRACE))
1727 croak ("cannot enable tracing on coroutine with custom stack"); 1710 croak ("cannot enable tracing on coroutine with custom stack,");
1728 1711
1729 coro->cctx->flags |= CC_NOREUSE | (flags & (CC_TRACE | CC_TRACE_ALL)); 1712 coro->cctx->flags |= CC_NOREUSE | (flags & (CC_TRACE | CC_TRACE_ALL));
1730 } 1713 }
1731 else if (coro->cctx && coro->cctx->flags & CC_TRACE) 1714 else if (coro->cctx && coro->cctx->flags & CC_TRACE)
1732 { 1715 {
… …
1791 PerlIOCede *self = PerlIOSelf (f, PerlIOCede); 1774 PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
1792 double now = nvtime (); 1775 double now = nvtime ();
1793 1776
1794 if (now >= self->next) 1777 if (now >= self->next)
1795 { 1778 {
1796 api_cede (); 1779 api_cede (aTHX);
1797 self->next = now + self->every; 1780 self->next = now + self->every;
1798 } 1781 }
1799 1782
1800 return PerlIOBuf_flush (aTHX_ f); 1783 return PerlIOBuf_flush (aTHX_ f);
1801} 1784}
… …
1832 PerlIOBuf_set_ptrcnt, 1815 PerlIOBuf_set_ptrcnt,
1833}; 1816};
1834 1817
1835/*****************************************************************************/ 1818/*****************************************************************************/
1836 1819
1837static const CV *ssl_cv; /* for quick consistency check */ 1820static const CV *slf_cv; /* for quick consistency check */
1838 1821
1839static UNOP ssl_restore; /* restore stack as entersub did, for first-re-run */ 1822static UNOP slf_restore; /* restore stack as entersub did, for first-re-run */
1840static SV *ssl_arg0; 1823static SV *slf_arg0;
1841static SV *ssl_arg1; 1824static SV *slf_arg1;
1825static SV *slf_arg2;
1842 1826
1843/* this restores the stack in the case we patched the entersub, to */ 1827/* this restores the stack in the case we patched the entersub, to */
1844/* recreate the stack frame as perl will on following calls */ 1828/* recreate the stack frame as perl will on following calls */
1845/* since entersub cleared the stack */ 1829/* since entersub cleared the stack */
1846static OP * 1830static OP *
… …
1849 dSP; 1833 dSP;
1850 1834
1851 PUSHMARK (SP); 1835 PUSHMARK (SP);
1852 1836
1853 EXTEND (SP, 3); 1837 EXTEND (SP, 3);
1854 if (ssl_arg0) PUSHs (sv_2mortal (ssl_arg0)), ssl_arg0 = 0; 1838 if (slf_arg0) PUSHs (sv_2mortal (slf_arg0));
1855 if (ssl_arg1) PUSHs (sv_2mortal (ssl_arg1)), ssl_arg1 = 0; 1839 if (slf_arg1) PUSHs (sv_2mortal (slf_arg1));
1840 if (slf_arg2) PUSHs (sv_2mortal (slf_arg2));
1856 PUSHs ((SV *)CvGV (ssl_cv)); 1841 PUSHs ((SV *)CvGV (slf_cv));
1857 1842
1858 RETURNOP (ssl_restore.op_first); 1843 RETURNOP (slf_restore.op_first);
1859} 1844}
1860 1845
1861/* declare prototype */ 1846static void
1862XS(XS_Coro__State__set_stacklevel); 1847slf_prepare_set_stacklevel (pTHX_ struct coro_transfer_args *ta)
1848{
1849 prepare_set_stacklevel (ta, (struct coro_cctx *)slf_frame.data);
1850}
1863 1851
1864#define OPpENTERSUB_SSL 15 1852static void
1853slf_init_set_stacklevel (pTHX_ struct CoroSLF *frame, SV **arg, int items)
1854{
1855 assert (("FATAL: set_stacklevel needs the coro cctx as sole argument", items == 1));
1865 1856
1857 frame->prepare = slf_prepare_set_stacklevel;
1858 frame->check = slf_check_nop;
1859 frame->data = (void *)SvIV (arg [0]);
1860}
1861
1862static void
1863slf_prepare_transfer (pTHX_ struct coro_transfer_args *ta)
1864{
1865 SV **arg = (SV **)slf_frame.data;
1866
1867 prepare_transfer (ta, arg [0], arg [1]);
1868}
1869
1870static void
1871slf_init_transfer (pTHX_ struct CoroSLF *frame, SV **arg, int items)
1872{
1873 if (items != 2)
1874 croak ("Coro::State::transfer (prev, next) expects two arguments, not %d,", items);
1875
1876 frame->prepare = slf_prepare_transfer;
1877 frame->check = slf_check_nop;
1878 frame->data = (void *)arg; /* let's hope it will stay valid */
1879}
1880
1881static void
1882slf_init_schedule (pTHX_ struct CoroSLF *frame, SV **arg, int items)
1883{
1884 frame->prepare = prepare_schedule;
1885 frame->check = slf_check_nop;
1886}
1887
1888static void
1889slf_init_cede (pTHX_ struct CoroSLF *frame, SV **arg, int items)
1890{
1891 frame->prepare = prepare_cede;
1892 frame->check = slf_check_nop;
1893}
1894
1895static void
1896slf_init_cede_notself (pTHX_ struct CoroSLF *frame, SV **arg, int items)
1897{
1898 frame->prepare = prepare_cede_notself;
1899 frame->check = slf_check_nop;
1900}
1901
1902/* we hijack an hopefully unused CV flag for our purposes */
1903#define CVf_SLF 0x4000
1904
1905/*
1906 * these not obviously related functions are all rolled into one
1907 * function to increase chances that they all will call transfer with the same
1908 * stack offset
1909 * SLF stands for "schedule-like-function".
1910 */
1866static OP * 1911static OP *
1867pp_set_stacklevel (pTHX) 1912pp_slf (pTHX)
1868{ 1913{
1914 I32 checkmark; /* mark SP to see how many elements check has pushed */
1915
1916 /* set up the slf frame, unless it has already been set-up */
1917 /* the latter happens when a new coro has been started */
1918 /* or when a new cctx was attached to an existing coroutine */
1919 if (expect_true (!slf_frame.prepare))
1920 {
1921 /* first iteration */
1869 dSP; 1922 dSP;
1870 struct transfer_args ta;
1871 SV **arg = PL_stack_base + TOPMARK + 1; 1923 SV **arg = PL_stack_base + TOPMARK + 1;
1872 int items = SP - arg; /* args without function object */ 1924 int items = SP - arg; /* args without function object */
1925 SV *gv = *sp;
1873 1926
1874 /* do a quick consistency check on the "function" object, and if it isn't */ 1927 /* do a quick consistency check on the "function" object, and if it isn't */
1875 /* for us, divert to the real entersub */ 1928 /* for us, divert to the real entersub */
1876 if (SvTYPE (*sp) != SVt_PVGV || CvXSUB (GvCV (*sp)) != XS_Coro__State__set_stacklevel) 1929 if (SvTYPE (gv) != SVt_PVGV || !(CvFLAGS (GvCV (gv)) & CVf_SLF))
1877 return PL_ppaddr[OP_ENTERSUB](aTHX); 1930 return PL_ppaddr[OP_ENTERSUB](aTHX);
1878 1931
1879 /* pop args */ 1932 /* pop args */
1880 SP = PL_stack_base + POPMARK; 1933 SP = PL_stack_base + POPMARK;
1881 1934
1882 if (!(PL_op->op_flags & OPf_STACKED)) 1935 if (!(PL_op->op_flags & OPf_STACKED))
1883 { 1936 {
1884 /* ampersand-form of call, use @_ instead of stack */ 1937 /* ampersand-form of call, use @_ instead of stack */
1885 AV *av = GvAV (PL_defgv); 1938 AV *av = GvAV (PL_defgv);
1886 arg = AvARRAY (av); 1939 arg = AvARRAY (av);
1887 items = AvFILLp (av) + 1; 1940 items = AvFILLp (av) + 1;
1941 }
1942
1943 PUTBACK;
1944
1945 ((coro_slf_cb)CvXSUBANY (GvCV (gv)).any_ptr) (aTHX_ &slf_frame, arg, items);
1946 }
1947
1948 /* now interpret the slf_frame */
1949 /* we use a callback system not to make the code needlessly */
1950 /* complicated, but so we can run multiple perl coros from one cctx */
1951
1952 do
1953 {
1954 struct coro_transfer_args ta;
1955
1956 slf_frame.prepare (aTHX_ &ta);
1957 TRANSFER (ta, 0);
1958
1959 checkmark = PL_stack_sp - PL_stack_base;
1960 }
1961 while (slf_frame.check (aTHX_ &slf_frame));
1962
1963 {
1964 dSP;
1965 SV **bot = PL_stack_base + checkmark;
1966 int gimme = GIMME_V;
1967
1968 slf_frame.prepare = 0; /* signal pp_slf that we need a new frame */
1969
1970 /* make sure we put something on the stack in scalar context */
1971 if (gimme == G_SCALAR)
1972 {
1973 if (sp == bot)
1974 XPUSHs (&PL_sv_undef);
1975
1976 SP = bot + 1;
1888 } 1977 }
1889 1978
1890 PUTBACK; 1979 PUTBACK;
1891 switch (PL_op->op_private & OPpENTERSUB_SSL)
1892 {
1893 case 0:
1894 prepare_set_stacklevel (&ta, (struct coro_cctx *)SvIV (arg [0]));
1895 break;
1896
1897 case 1:
1898 if (items != 2)
1899 croak ("Coro::State::transfer (prev, next) expects two arguments, not %d.", items);
1900
1901 prepare_transfer (aTHX_ &ta, arg [0], arg [1]);
1902 break;
1903
1904 case 2:
1905 prepare_schedule (aTHX_ &ta);
1906 break;
1907
1908 case 3:
1909 prepare_cede (aTHX_ &ta);
1910 break;
1911
1912 case 4:
1913 if (!prepare_cede_notself (aTHX_ &ta))
1914 goto skip;
1915
1916 break;
1917 } 1980 }
1918 1981
1919 TRANSFER (ta, 0); 1982 return NORMAL;
1920 SPAGAIN; 1983}
1921 1984
1922skip: 1985static void
1923 PUTBACK; 1986api_execute_slf (pTHX_ CV *cv, coro_slf_cb init_cb, SV **arg, int items)
1924 SSL_TAIL; 1987{
1925 SPAGAIN; 1988 assert (("FATAL: SLF call with illegal CV value", !CvANON (cv)));
1926 RETURN; 1989
1990 if (PL_op->op_ppaddr != PL_ppaddr [OP_ENTERSUB]
1991 && PL_op->op_ppaddr != pp_slf)
1992 croak ("FATAL: Coro SLF calls can only be made normally, not via goto or other means, caught");
1993
1994 if (items > 3)
1995 croak ("Coro only supports up to three arguments to SLF functions currently, caught");
1996
1997 CvFLAGS (cv) |= CVf_SLF;
1998 CvXSUBANY (cv).any_ptr = (void *)init_cb;
1999 slf_cv = cv;
2000
2001 /* we patch the op, and then re-run the whole call */
2002 /* we have to put the same argument on the stack for this to work */
2003 /* and this will be done by pp_restore */
2004 slf_restore.op_next = (OP *)&slf_restore;
2005 slf_restore.op_type = OP_NULL;
2006 slf_restore.op_ppaddr = pp_restore;
2007 slf_restore.op_first = PL_op;
2008
2009 slf_arg0 = items > 0 ? SvREFCNT_inc (arg [0]) : 0;
2010 slf_arg1 = items > 1 ? SvREFCNT_inc (arg [1]) : 0;
2011 slf_arg2 = items > 2 ? SvREFCNT_inc (arg [2]) : 0;
2012
2013 PL_op->op_ppaddr = pp_slf;
2014
2015 PL_op = (OP *)&slf_restore;
1927} 2016}
1928 2017
1929MODULE = Coro::State PACKAGE = Coro::State PREFIX = api_ 2018MODULE = Coro::State PACKAGE = Coro::State PREFIX = api_
1930 2019
1931PROTOTYPES: DISABLE 2020PROTOTYPES: DISABLE
1932
1933# these not obviously related functions are all rolled into the same xs
1934# function to increase chances that they all will call transfer with the same
1935# stack offset
1936void
1937_set_stacklevel (...)
1938 ALIAS:
1939 Coro::State::transfer = 1
1940 Coro::schedule = 2
1941 Coro::cede = 3
1942 Coro::cede_notself = 4
1943 CODE:
1944{
1945 assert (("FATAL: ssl call recursion in Coro module (please report)", PL_op->op_ppaddr != pp_set_stacklevel));
1946
1947 assert (("FATAL: ssl call with illegal CV value", CvGV (cv)));
1948 ssl_cv = cv;
1949
1950 /* we patch the op, and then re-run the whole call */
1951 /* we have to put some dummy argument on the stack for this to work */
1952 ssl_restore.op_next = (OP *)&ssl_restore;
1953 ssl_restore.op_type = OP_NULL;
1954 ssl_restore.op_ppaddr = pp_restore;
1955 ssl_restore.op_first = PL_op;
1956
1957 ssl_arg0 = items > 0 ? SvREFCNT_inc (ST (0)) : 0;
1958 ssl_arg1 = items > 1 ? SvREFCNT_inc (ST (1)) : 0;
1959
1960 PL_op->op_ppaddr = pp_set_stacklevel;
1961 PL_op->op_private = PL_op->op_private & ~OPpENTERSUB_SSL | ix; /* we potentially share our private flags with entersub */
1962
1963 PL_op = (OP *)&ssl_restore;
1964}
1965 2021
1966BOOT: 2022BOOT:
1967{ 2023{
1968#ifdef USE_ITHREADS 2024#ifdef USE_ITHREADS
1969 MUTEX_INIT (&coro_lock); 2025 MUTEX_INIT (&coro_lock);
… …
1995 main_top_env = PL_top_env; 2051 main_top_env = PL_top_env;
1996 2052
1997 while (main_top_env->je_prev) 2053 while (main_top_env->je_prev)
1998 main_top_env = main_top_env->je_prev; 2054 main_top_env = main_top_env->je_prev;
1999 2055
2000 coroapi.ver = CORO_API_VERSION; 2056 coroapi.ver = CORO_API_VERSION;
2001 coroapi.rev = CORO_API_REVISION; 2057 coroapi.rev = CORO_API_REVISION;
2058
2002 coroapi.transfer = api_transfer; 2059 coroapi.transfer = api_transfer;
2060
2061 coroapi.sv_state = SvSTATE_;
2062 coroapi.execute_slf = api_execute_slf;
2063 coroapi.prepare_nop = prepare_nop;
2064 coroapi.prepare_schedule = prepare_schedule;
2065 coroapi.prepare_cede = prepare_cede;
2066 coroapi.prepare_cede_notself = prepare_cede_notself;
2003 2067
2004 { 2068 {
2005 SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0); 2069 SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
2006 2070
2007 if (!svp) croak ("Time::HiRes is required"); 2071 if (!svp) croak ("Time::HiRes is required");
… …
2039 for (i = 1; i < items; i++) 2103 for (i = 1; i < items; i++)
2040 av_push (coro->args, newSVsv (ST (i))); 2104 av_push (coro->args, newSVsv (ST (i)));
2041} 2105}
2042 OUTPUT: 2106 OUTPUT:
2043 RETVAL 2107 RETVAL
2108
2109void
2110_set_stacklevel (...)
2111 CODE:
2112 api_execute_slf (aTHX_ cv, slf_init_set_stacklevel, &ST (0), items);
2113
2114void
2115transfer (...)
2116 CODE:
2117 api_execute_slf (aTHX_ cv, slf_init_transfer, &ST (0), items);
2044 2118
2045bool 2119bool
2046_destroy (SV *coro_sv) 2120_destroy (SV *coro_sv)
2047 CODE: 2121 CODE:
2048 RETVAL = coro_state_destroy (aTHX_ SvSTATE (coro_sv)); 2122 RETVAL = coro_state_destroy (aTHX_ SvSTATE (coro_sv));
… …
2166 SvREFCNT_dec (self->throw); 2240 SvREFCNT_dec (self->throw);
2167 self->throw = SvOK (throw) ? newSVsv (throw) : 0; 2241 self->throw = SvOK (throw) ? newSVsv (throw) : 0;
2168 2242
2169void 2243void
2170api_trace (SV *coro, int flags = CC_TRACE | CC_TRACE_SUB) 2244api_trace (SV *coro, int flags = CC_TRACE | CC_TRACE_SUB)
2245 C_ARGS: aTHX_ coro, flags
2171 2246
2172SV * 2247SV *
2173has_cctx (Coro::State coro) 2248has_cctx (Coro::State coro)
2174 PROTOTYPE: $ 2249 PROTOTYPE: $
2175 CODE: 2250 CODE:
… …
2210 PROTOTYPE: $ 2285 PROTOTYPE: $
2211 ALIAS: 2286 ALIAS:
2212 swap_defav = 1 2287 swap_defav = 1
2213 CODE: 2288 CODE:
2214 if (!self->slot) 2289 if (!self->slot)
2215 croak ("cannot swap state with coroutine that has no saved state"); 2290 croak ("cannot swap state with coroutine that has no saved state,");
2216 else 2291 else
2217 { 2292 {
2218 SV **src = ix ? (SV **)&GvAV (PL_defgv) : &GvSV (PL_defgv); 2293 SV **src = ix ? (SV **)&GvAV (PL_defgv) : &GvSV (PL_defgv);
2219 SV **dst = ix ? (SV **)&self->slot->defav : (SV **)&self->slot->defsv; 2294 SV **dst = ix ? (SV **)&self->slot->defav : (SV **)&self->slot->defsv;
2220 2295
… …
2252 coroapi.schedule = api_schedule; 2327 coroapi.schedule = api_schedule;
2253 coroapi.cede = api_cede; 2328 coroapi.cede = api_cede;
2254 coroapi.cede_notself = api_cede_notself; 2329 coroapi.cede_notself = api_cede_notself;
2255 coroapi.ready = api_ready; 2330 coroapi.ready = api_ready;
2256 coroapi.is_ready = api_is_ready; 2331 coroapi.is_ready = api_is_ready;
2257 coroapi.nready = &coro_nready; 2332 coroapi.nready = coro_nready;
2258 coroapi.current = coro_current; 2333 coroapi.current = coro_current;
2259 2334
2260 GCoroAPI = &coroapi; 2335 GCoroAPI = &coroapi;
2261 sv_setiv (sv, (IV)&coroapi); 2336 sv_setiv (sv, (IV)&coroapi);
2262 SvREADONLY_on (sv); 2337 SvREADONLY_on (sv);
2263 } 2338 }
2264} 2339}
2340
2341void
2342schedule (...)
2343 CODE:
2344 api_execute_slf (aTHX_ cv, slf_init_schedule, &ST (0), items);
2345
2346void
2347cede (...)
2348 CODE:
2349 api_execute_slf (aTHX_ cv, slf_init_cede, &ST (0), items);
2350
2351void
2352cede_notself (...)
2353 CODE:
2354 api_execute_slf (aTHX_ cv, slf_init_cede_notself, &ST (0), items);
2265 2355
2266void 2356void
2267_set_current (SV *current) 2357_set_current (SV *current)
2268 PROTOTYPE: $ 2358 PROTOTYPE: $
2269 CODE: 2359 CODE:
… …
2303 2393
2304SV * 2394SV *
2305ready (SV *self) 2395ready (SV *self)
2306 PROTOTYPE: $ 2396 PROTOTYPE: $
2307 CODE: 2397 CODE:
2308 RETVAL = boolSV (api_ready (self)); 2398 RETVAL = boolSV (api_ready (aTHX_ self));
2309 OUTPUT: 2399 OUTPUT:
2310 RETVAL 2400 RETVAL
2311 2401
2312int 2402int
2313nready (...) 2403nready (...)
… …
2383 newSVpvn ("[async_pool idle]", sizeof ("[async_pool idle]") - 1), 0); 2473 newSVpvn ("[async_pool idle]", sizeof ("[async_pool idle]") - 1), 0);
2384 2474
2385 coro->prio = 0; 2475 coro->prio = 0;
2386 2476
2387 if (coro->cctx && (coro->cctx->flags & CC_TRACE)) 2477 if (coro->cctx && (coro->cctx->flags & CC_TRACE))
2388 api_trace (coro_current, 0); 2478 api_trace (aTHX_ coro_current, 0);
2389 2479
2390 av_push (av_async_pool, newSVsv (coro_current)); 2480 av_push (av_async_pool, newSVsv (coro_current));
2391} 2481}
2392 2482
2393#if 0 2483#if 0
… …
2465 2555
2466 av_push (av, data_sv); 2556 av_push (av, data_sv);
2467 2557
2468 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av))); 2558 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
2469 2559
2470 api_ready (self); 2560 api_ready (aTHX_ self);
2471} 2561}
2472 2562
2473void 2563void
2474_set_state (SV *state) 2564_set_state (SV *state)
2475 PROTOTYPE: $ 2565 PROTOTYPE: $
… …
2500 PROTOTYPE: @ 2590 PROTOTYPE: @
2501 CODE: 2591 CODE:
2502{ 2592{
2503 static int incede; 2593 static int incede;
2504 2594
2505 api_cede_notself (); 2595 api_cede_notself (aTHX);
2506 2596
2507 ++incede; 2597 ++incede;
2508 while (coro_nready >= incede && api_cede ()) 2598 while (coro_nready >= incede && api_cede (aTHX))
2509 ; 2599 ;
2510 2600
2511 sv_setsv (sv_activity, &PL_sv_undef); 2601 sv_setsv (sv_activity, &PL_sv_undef);
2512 if (coro_nready >= incede) 2602 if (coro_nready >= incede)
2513 { 2603 {

Diff Legend

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