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.267 by root, Fri Nov 14 06:29:52 2008 UTC vs.
Revision 1.274 by root, Sat Nov 15 00:08:30 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 sometimes 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
1660static void 1646INLINE void
1661prepare_cede_notself (pTHX_ struct transfer_args *ta) 1647prepare_cede_notself (pTHX_ struct coro_transfer_args *ta)
1662{ 1648{
1663 SV *prev = SvRV (coro_current); 1649 SV *prev = SvRV (coro_current);
1664 1650
1665 if (coro_nready) 1651 if (coro_nready)
1666 { 1652 {
1667 prepare_schedule (aTHX_ ta); 1653 prepare_schedule (aTHX_ ta);
1668 api_ready (prev); 1654 api_ready (aTHX_ prev);
1669 } 1655 }
1670 else 1656 else
1671 ta->prev = ta->next = SvSTATE (prev); 1657 prepare_nop (aTHX_ ta);
1672} 1658}
1673 1659
1674static void 1660static void
1675api_schedule (void) 1661api_schedule (pTHX)
1676{ 1662{
1677 dTHX;
1678 struct transfer_args ta; 1663 struct coro_transfer_args ta;
1679 1664
1680 prepare_schedule (aTHX_ &ta); 1665 prepare_schedule (aTHX_ &ta);
1681 TRANSFER (ta, 1); 1666 TRANSFER (ta, 1);
1682} 1667}
1683 1668
1684static int 1669static int
1685api_cede (void) 1670api_cede (pTHX)
1686{ 1671{
1687 dTHX;
1688 struct transfer_args ta; 1672 struct coro_transfer_args ta;
1689 1673
1690 prepare_cede (aTHX_ &ta); 1674 prepare_cede (aTHX_ &ta);
1691 1675
1692 if (expect_true (ta.prev != ta.next)) 1676 if (expect_true (ta.prev != ta.next))
1693 { 1677 {
… …
1697 else 1681 else
1698 return 0; 1682 return 0;
1699} 1683}
1700 1684
1701static int 1685static int
1702api_cede_notself (void) 1686api_cede_notself (pTHX)
1703{ 1687{
1704 if (coro_nready) 1688 if (coro_nready)
1705 { 1689 {
1706 dTHX;
1707 struct transfer_args ta; 1690 struct coro_transfer_args ta;
1708 1691
1709 prepare_cede_notself (aTHX_ &ta); 1692 prepare_cede_notself (aTHX_ &ta);
1710 TRANSFER (ta, 1); 1693 TRANSFER (ta, 1);
1711 return 1; 1694 return 1;
1712 } 1695 }
1713 else 1696 else
1714 return 0; 1697 return 0;
1715} 1698}
1716 1699
1717static void 1700static void
1718api_trace (SV *coro_sv, int flags) 1701api_trace (pTHX_ SV *coro_sv, int flags)
1719{ 1702{
1720 dTHX;
1721 struct coro *coro = SvSTATE (coro_sv); 1703 struct coro *coro = SvSTATE (coro_sv);
1722 1704
1723 if (flags & CC_TRACE) 1705 if (flags & CC_TRACE)
1724 { 1706 {
1725 if (!coro->cctx) 1707 if (!coro->cctx)
1726 coro->cctx = cctx_new_run (); 1708 coro->cctx = cctx_new_run ();
1727 else if (!(coro->cctx->flags & CC_TRACE)) 1709 else if (!(coro->cctx->flags & CC_TRACE))
1728 croak ("cannot enable tracing on coroutine with custom stack"); 1710 croak ("cannot enable tracing on coroutine with custom stack,");
1729 1711
1730 coro->cctx->flags |= CC_NOREUSE | (flags & (CC_TRACE | CC_TRACE_ALL)); 1712 coro->cctx->flags |= CC_NOREUSE | (flags & (CC_TRACE | CC_TRACE_ALL));
1731 } 1713 }
1732 else if (coro->cctx && coro->cctx->flags & CC_TRACE) 1714 else if (coro->cctx && coro->cctx->flags & CC_TRACE)
1733 { 1715 {
… …
1792 PerlIOCede *self = PerlIOSelf (f, PerlIOCede); 1774 PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
1793 double now = nvtime (); 1775 double now = nvtime ();
1794 1776
1795 if (now >= self->next) 1777 if (now >= self->next)
1796 { 1778 {
1797 api_cede (); 1779 api_cede (aTHX);
1798 self->next = now + self->every; 1780 self->next = now + self->every;
1799 } 1781 }
1800 1782
1801 return PerlIOBuf_flush (aTHX_ f); 1783 return PerlIOBuf_flush (aTHX_ f);
1802} 1784}
… …
1833 PerlIOBuf_set_ptrcnt, 1815 PerlIOBuf_set_ptrcnt,
1834}; 1816};
1835 1817
1836/*****************************************************************************/ 1818/*****************************************************************************/
1837 1819
1838static const CV *ssl_cv; /* for quick consistency check */ 1820static const CV *slf_cv; /* for quick consistency check */
1839 1821
1840static 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 */
1841static SV *ssl_arg0; 1823static SV *slf_arg0;
1842static SV *ssl_arg1; 1824static SV *slf_arg1;
1825static SV *slf_arg2;
1843 1826
1844/* 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 */
1845/* recreate the stack frame as perl will on following calls */ 1828/* recreate the stack frame as perl will on following calls */
1846/* since entersub cleared the stack */ 1829/* since entersub cleared the stack */
1847static OP * 1830static OP *
… …
1850 dSP; 1833 dSP;
1851 1834
1852 PUSHMARK (SP); 1835 PUSHMARK (SP);
1853 1836
1854 EXTEND (SP, 3); 1837 EXTEND (SP, 3);
1855 if (ssl_arg0) PUSHs (sv_2mortal (ssl_arg0)), ssl_arg0 = 0; 1838 if (slf_arg0) PUSHs (sv_2mortal (slf_arg0));
1856 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));
1857 PUSHs ((SV *)CvGV (ssl_cv)); 1841 PUSHs ((SV *)CvGV (slf_cv));
1858 1842
1859 RETURNOP (ssl_restore.op_first); 1843 RETURNOP (slf_restore.op_first);
1860} 1844}
1861 1845
1862#define OPpENTERSUB_SSL 15 /* the part of op_private entersub hopefully doesn't use */ 1846static void
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/* declare prototype */ 1852static void
1865XS(XS_Coro__State__set_stacklevel); 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));
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
1866 1904
1867/* 1905/*
1868 * these not obviously related functions are all rolled into one 1906 * these not obviously related functions are all rolled into one
1869 * function to increase chances that they all will call transfer with the same 1907 * function to increase chances that they all will call transfer with the same
1870 * stack offset 1908 * stack offset
1909 * SLF stands for "schedule-like-function".
1871 */ 1910 */
1872static OP * 1911static OP *
1873pp_set_stacklevel (pTHX) 1912pp_slf (pTHX)
1874{ 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 */
1875 dSP; 1922 dSP;
1876 struct transfer_args ta;
1877 SV **arg = PL_stack_base + TOPMARK + 1; 1923 SV **arg = PL_stack_base + TOPMARK + 1;
1878 int items = SP - arg; /* args without function object */ 1924 int items = SP - arg; /* args without function object */
1925 SV *gv = *sp;
1879 1926
1880 /* 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 */
1881 /* for us, divert to the real entersub */ 1928 /* for us, divert to the real entersub */
1882 if (SvTYPE (*sp) != SVt_PVGV || CvXSUB (GvCV (*sp)) != XS_Coro__State__set_stacklevel) 1929 if (SvTYPE (gv) != SVt_PVGV || !(CvFLAGS (GvCV (gv)) & CVf_SLF))
1883 return PL_ppaddr[OP_ENTERSUB](aTHX); 1930 return PL_ppaddr[OP_ENTERSUB](aTHX);
1884 1931
1885 /* pop args */ 1932 /* pop args */
1886 SP = PL_stack_base + POPMARK; 1933 SP = PL_stack_base + POPMARK;
1887 1934
1888 if (!(PL_op->op_flags & OPf_STACKED)) 1935 if (!(PL_op->op_flags & OPf_STACKED))
1889 { 1936 {
1890 /* ampersand-form of call, use @_ instead of stack */ 1937 /* ampersand-form of call, use @_ instead of stack */
1891 AV *av = GvAV (PL_defgv); 1938 AV *av = GvAV (PL_defgv);
1892 arg = AvARRAY (av); 1939 arg = AvARRAY (av);
1893 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;
1894 } 1977 }
1895 1978
1896 PUTBACK; 1979 PUTBACK;
1897 switch (PL_op->op_private & OPpENTERSUB_SSL)
1898 {
1899 case 0:
1900 prepare_set_stacklevel (&ta, (struct coro_cctx *)SvIV (arg [0]));
1901 break;
1902
1903 case 1:
1904 if (items != 2)
1905 croak ("Coro::State::transfer (prev, next) expects two arguments, not %d.", items);
1906
1907 prepare_transfer (aTHX_ &ta, arg [0], arg [1]);
1908 break;
1909
1910 case 2:
1911 prepare_schedule (aTHX_ &ta);
1912 break;
1913
1914 case 3:
1915 prepare_cede (aTHX_ &ta);
1916 break;
1917
1918 case 4:
1919 prepare_cede_notself (aTHX_ &ta);
1920 break;
1921 } 1980 }
1922 1981
1923 TRANSFER (ta, 0); 1982 return NORMAL;
1924 SPAGAIN;
1925
1926skip:
1927 PUTBACK;
1928 SSL_TAIL;
1929 SPAGAIN;
1930 RETURN;
1931} 1983}
1932 1984
1933static void 1985static void
1934coro_ssl_patch (pTHX_ CV *cv, int ix, SV **args, int items) 1986api_execute_slf (pTHX_ CV *cv, coro_slf_cb init_cb, SV **arg, int items)
1935{ 1987{
1936 assert (("FATAL: ssl call recursion in Coro module (please report)", PL_op->op_ppaddr != pp_set_stacklevel));
1937
1938 assert (("FATAL: ssl call with illegal CV value", CvGV (cv))); 1988 assert (("FATAL: SLF call with illegal CV value", !CvANON (cv)));
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 any 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;
1939 ssl_cv = cv; 1999 slf_cv = cv;
1940 2000
1941 /* we patch the op, and then re-run the whole call */ 2001 /* we patch the op, and then re-run the whole call */
1942 /* we have to put some dummy argument on the stack for this to work */ 2002 /* we have to put the same argument on the stack for this to work */
2003 /* and this will be done by pp_restore */
1943 ssl_restore.op_next = (OP *)&ssl_restore; 2004 slf_restore.op_next = (OP *)&slf_restore;
1944 ssl_restore.op_type = OP_NULL; 2005 slf_restore.op_type = OP_NULL;
1945 ssl_restore.op_ppaddr = pp_restore; 2006 slf_restore.op_ppaddr = pp_restore;
1946 ssl_restore.op_first = PL_op; 2007 slf_restore.op_first = PL_op;
1947 2008
1948 ssl_arg0 = items > 0 ? SvREFCNT_inc (args [0]) : 0; 2009 slf_arg0 = items > 0 ? SvREFCNT_inc (arg [0]) : 0;
1949 ssl_arg1 = items > 1 ? SvREFCNT_inc (args [1]) : 0; 2010 slf_arg1 = items > 1 ? SvREFCNT_inc (arg [1]) : 0;
2011 slf_arg2 = items > 2 ? SvREFCNT_inc (arg [2]) : 0;
1950 2012
1951 PL_op->op_ppaddr = pp_set_stacklevel; 2013 PL_op->op_ppaddr = pp_slf;
1952 PL_op->op_private = PL_op->op_private & ~OPpENTERSUB_SSL | ix; /* we potentially share our private flags with entersub */
1953 2014
1954 PL_op = (OP *)&ssl_restore; 2015 PL_op = (OP *)&slf_restore;
1955} 2016}
1956 2017
1957MODULE = Coro::State PACKAGE = Coro::State PREFIX = api_ 2018MODULE = Coro::State PACKAGE = Coro::State PREFIX = api_
1958 2019
1959PROTOTYPES: DISABLE 2020PROTOTYPES: DISABLE
… …
1990 main_top_env = PL_top_env; 2051 main_top_env = PL_top_env;
1991 2052
1992 while (main_top_env->je_prev) 2053 while (main_top_env->je_prev)
1993 main_top_env = main_top_env->je_prev; 2054 main_top_env = main_top_env->je_prev;
1994 2055
1995 coroapi.ver = CORO_API_VERSION; 2056 coroapi.ver = CORO_API_VERSION;
1996 coroapi.rev = CORO_API_REVISION; 2057 coroapi.rev = CORO_API_REVISION;
2058
1997 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;
1998 2067
1999 { 2068 {
2000 SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0); 2069 SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
2001 2070
2002 if (!svp) croak ("Time::HiRes is required"); 2071 if (!svp) croak ("Time::HiRes is required");
… …
2037 OUTPUT: 2106 OUTPUT:
2038 RETVAL 2107 RETVAL
2039 2108
2040void 2109void
2041_set_stacklevel (...) 2110_set_stacklevel (...)
2042 ALIAS: 2111 CODE:
2043 Coro::State::transfer = 1 2112 api_execute_slf (aTHX_ cv, slf_init_set_stacklevel, &ST (0), items);
2044 Coro::schedule = 2 2113
2045 Coro::cede = 3 2114void
2046 Coro::cede_notself = 4 2115transfer (...)
2047 CODE: 2116 CODE:
2048 coro_ssl_patch (aTHX_ cv, ix, &ST (0), items); 2117 api_execute_slf (aTHX_ cv, slf_init_transfer, &ST (0), items);
2049 2118
2050bool 2119bool
2051_destroy (SV *coro_sv) 2120_destroy (SV *coro_sv)
2052 CODE: 2121 CODE:
2053 RETVAL = coro_state_destroy (aTHX_ SvSTATE (coro_sv)); 2122 RETVAL = coro_state_destroy (aTHX_ SvSTATE (coro_sv));
… …
2171 SvREFCNT_dec (self->throw); 2240 SvREFCNT_dec (self->throw);
2172 self->throw = SvOK (throw) ? newSVsv (throw) : 0; 2241 self->throw = SvOK (throw) ? newSVsv (throw) : 0;
2173 2242
2174void 2243void
2175api_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
2176 2246
2177SV * 2247SV *
2178has_cctx (Coro::State coro) 2248has_cctx (Coro::State coro)
2179 PROTOTYPE: $ 2249 PROTOTYPE: $
2180 CODE: 2250 CODE:
… …
2215 PROTOTYPE: $ 2285 PROTOTYPE: $
2216 ALIAS: 2286 ALIAS:
2217 swap_defav = 1 2287 swap_defav = 1
2218 CODE: 2288 CODE:
2219 if (!self->slot) 2289 if (!self->slot)
2220 croak ("cannot swap state with coroutine that has no saved state"); 2290 croak ("cannot swap state with coroutine that has no saved state,");
2221 else 2291 else
2222 { 2292 {
2223 SV **src = ix ? (SV **)&GvAV (PL_defgv) : &GvSV (PL_defgv); 2293 SV **src = ix ? (SV **)&GvAV (PL_defgv) : &GvSV (PL_defgv);
2224 SV **dst = ix ? (SV **)&self->slot->defav : (SV **)&self->slot->defsv; 2294 SV **dst = ix ? (SV **)&self->slot->defav : (SV **)&self->slot->defsv;
2225 2295
… …
2257 coroapi.schedule = api_schedule; 2327 coroapi.schedule = api_schedule;
2258 coroapi.cede = api_cede; 2328 coroapi.cede = api_cede;
2259 coroapi.cede_notself = api_cede_notself; 2329 coroapi.cede_notself = api_cede_notself;
2260 coroapi.ready = api_ready; 2330 coroapi.ready = api_ready;
2261 coroapi.is_ready = api_is_ready; 2331 coroapi.is_ready = api_is_ready;
2262 coroapi.nready = &coro_nready; 2332 coroapi.nready = coro_nready;
2263 coroapi.current = coro_current; 2333 coroapi.current = coro_current;
2264 2334
2265 GCoroAPI = &coroapi; 2335 GCoroAPI = &coroapi;
2266 sv_setiv (sv, (IV)&coroapi); 2336 sv_setiv (sv, (IV)&coroapi);
2267 SvREADONLY_on (sv); 2337 SvREADONLY_on (sv);
2268 } 2338 }
2269} 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);
2270 2355
2271void 2356void
2272_set_current (SV *current) 2357_set_current (SV *current)
2273 PROTOTYPE: $ 2358 PROTOTYPE: $
2274 CODE: 2359 CODE:
… …
2308 2393
2309SV * 2394SV *
2310ready (SV *self) 2395ready (SV *self)
2311 PROTOTYPE: $ 2396 PROTOTYPE: $
2312 CODE: 2397 CODE:
2313 RETVAL = boolSV (api_ready (self)); 2398 RETVAL = boolSV (api_ready (aTHX_ self));
2314 OUTPUT: 2399 OUTPUT:
2315 RETVAL 2400 RETVAL
2316 2401
2317int 2402int
2318nready (...) 2403nready (...)
… …
2388 newSVpvn ("[async_pool idle]", sizeof ("[async_pool idle]") - 1), 0); 2473 newSVpvn ("[async_pool idle]", sizeof ("[async_pool idle]") - 1), 0);
2389 2474
2390 coro->prio = 0; 2475 coro->prio = 0;
2391 2476
2392 if (coro->cctx && (coro->cctx->flags & CC_TRACE)) 2477 if (coro->cctx && (coro->cctx->flags & CC_TRACE))
2393 api_trace (coro_current, 0); 2478 api_trace (aTHX_ coro_current, 0);
2394 2479
2395 av_push (av_async_pool, newSVsv (coro_current)); 2480 av_push (av_async_pool, newSVsv (coro_current));
2396} 2481}
2397 2482
2398#if 0 2483#if 0
… …
2470 2555
2471 av_push (av, data_sv); 2556 av_push (av, data_sv);
2472 2557
2473 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av))); 2558 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
2474 2559
2475 api_ready (self); 2560 api_ready (aTHX_ self);
2476} 2561}
2477 2562
2478void 2563void
2479_set_state (SV *state) 2564_set_state (SV *state)
2480 PROTOTYPE: $ 2565 PROTOTYPE: $
… …
2505 PROTOTYPE: @ 2590 PROTOTYPE: @
2506 CODE: 2591 CODE:
2507{ 2592{
2508 static int incede; 2593 static int incede;
2509 2594
2510 api_cede_notself (); 2595 api_cede_notself (aTHX);
2511 2596
2512 ++incede; 2597 ++incede;
2513 while (coro_nready >= incede && api_cede ()) 2598 while (coro_nready >= incede && api_cede (aTHX))
2514 ; 2599 ;
2515 2600
2516 sv_setsv (sv_activity, &PL_sv_undef); 2601 sv_setsv (sv_activity, &PL_sv_undef);
2517 if (coro_nready >= incede) 2602 if (coro_nready >= incede)
2518 { 2603 {

Diff Legend

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