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.222 by root, Sun Jan 20 10:22:07 2008 UTC vs.
Revision 1.251 by root, Thu Oct 30 09:44:31 2008 UTC

… …
4#define PERL_EXT 4#define PERL_EXT
5 5
6#include "EXTERN.h" 6#include "EXTERN.h"
7#include "perl.h" 7#include "perl.h"
8#include "XSUB.h" 8#include "XSUB.h"
9#include "perliol.h"
9 10
10#include "patchlevel.h" 11#include "patchlevel.h"
11 12
12#include <stdio.h> 13#include <stdio.h>
13#include <errno.h> 14#include <errno.h>
14#include <assert.h> 15#include <assert.h>
16
17#ifdef WIN32
18# undef setjmp
19# undef longjmp
20# undef _exit
21# define setjmp _setjmp // deep magic, don't ask
22#else
15#include <inttypes.h> /* portable stdint.h */ 23# include <inttypes.h> /* most portable stdint.h */
24#endif
16 25
17#ifdef HAVE_MMAP 26#ifdef HAVE_MMAP
18# include <unistd.h> 27# include <unistd.h>
19# include <sys/mman.h> 28# include <sys/mman.h>
20# ifndef MAP_ANONYMOUS 29# ifndef MAP_ANONYMOUS
… …
72# ifndef IS_PADCONST 81# ifndef IS_PADCONST
73# define IS_PADCONST(v) 0 82# define IS_PADCONST(v) 0
74# endif 83# endif
75#endif 84#endif
76 85
86/* 5.11 */
87#ifndef CxHASARGS
88# define CxHASARGS(cx) (cx)->blk_sub.hasargs
89#endif
90
91/* 5.10.0 */
92#ifndef SvREFCNT_inc_NN
93# define SvREFCNT_inc_NN(sv) SvREFCNT_inc (sv)
94#endif
95
96/* 5.8.8 */
97#ifndef GV_NOTQUAL
98# define GV_NOTQUAL 0
99#endif
100#ifndef newSV
101# define newSV(l) NEWSV(0,l)
102#endif
103
77/* 5.8.7 */ 104/* 5.8.7 */
78#ifndef SvRV_set 105#ifndef SvRV_set
79# define SvRV_set(s,v) SvRV(s) = (v) 106# define SvRV_set(s,v) SvRV(s) = (v)
80#endif
81
82/* 5.8.8 */
83#ifndef GV_NOTQUAL
84# define GV_NOTQUAL 0
85#endif
86#ifndef newSV
87# define newSV(l) NEWSV(0,l)
88#endif 107#endif
89 108
90#if !__i386 && !__x86_64 && !__powerpc && !__m68k && !__alpha && !__mips && !__sparc64 109#if !__i386 && !__x86_64 && !__powerpc && !__m68k && !__alpha && !__mips && !__sparc64
91# undef CORO_STACKGUARD 110# undef CORO_STACKGUARD
92#endif 111#endif
… …
134#endif 153#endif
135 154
136/* helper storage struct for Coro::AIO */ 155/* helper storage struct for Coro::AIO */
137struct io_state 156struct io_state
138{ 157{
158 AV *res;
139 int errorno; 159 int errorno;
140 I32 laststype; 160 I32 laststype;
141 int laststatval; 161 int laststatval;
142 Stat_t statcache; 162 Stat_t statcache;
143}; 163};
164
165static double (*nvtime)(); /* so why doesn't it take void? */
144 166
145static size_t coro_stacksize = CORO_STACKSIZE; 167static size_t coro_stacksize = CORO_STACKSIZE;
146static struct CoroAPI coroapi; 168static struct CoroAPI coroapi;
147static AV *main_mainstack; /* used to differentiate between $main and others */ 169static AV *main_mainstack; /* used to differentiate between $main and others */
148static JMPENV *main_top_env; 170static JMPENV *main_top_env;
… …
157 179
158/* async_pool helper stuff */ 180/* async_pool helper stuff */
159static SV *sv_pool_rss; 181static SV *sv_pool_rss;
160static SV *sv_pool_size; 182static SV *sv_pool_size;
161static AV *av_async_pool; 183static AV *av_async_pool;
184
185/* Coro::AnyEvent */
186static SV *sv_activity;
162 187
163static struct coro_cctx *cctx_first; 188static struct coro_cctx *cctx_first;
164static int cctx_count, cctx_idle; 189static int cctx_count, cctx_idle;
165 190
166enum { 191enum {
… …
252#define PRIO_IDLE -3 277#define PRIO_IDLE -3
253#define PRIO_MIN -4 278#define PRIO_MIN -4
254 279
255/* for Coro.pm */ 280/* for Coro.pm */
256static SV *coro_current; 281static SV *coro_current;
282static SV *coro_readyhook;
257static AV *coro_ready [PRIO_MAX-PRIO_MIN+1]; 283static AV *coro_ready [PRIO_MAX-PRIO_MIN+1];
258static int coro_nready; 284static int coro_nready;
259static struct coro *coro_first; 285static struct coro *coro_first;
260 286
261/** lowlevel stuff **********************************************************/ 287/** lowlevel stuff **********************************************************/
262 288
263static SV * 289static SV *
264coro_get_sv (pTHX_ const char *name, int create) 290coro_get_sv (pTHX_ const char *name, int create)
265{ 291{
266#if PERL_VERSION_ATLEAST (5,9,0) 292#if PERL_VERSION_ATLEAST (5,10,0)
267 /* silence stupid and wrong 5.10 warning that I am unable to switch off */ 293 /* silence stupid and wrong 5.10 warning that I am unable to switch off */
268 get_sv (name, create); 294 get_sv (name, create);
269#endif 295#endif
270 return get_sv (name, create); 296 return get_sv (name, create);
271} 297}
272 298
273static AV * 299static AV *
274coro_get_av (pTHX_ const char *name, int create) 300coro_get_av (pTHX_ const char *name, int create)
275{ 301{
276#if PERL_VERSION_ATLEAST (5,9,0) 302#if PERL_VERSION_ATLEAST (5,10,0)
277 /* silence stupid and wrong 5.10 warning that I am unable to switch off */ 303 /* silence stupid and wrong 5.10 warning that I am unable to switch off */
278 get_av (name, create); 304 get_av (name, create);
279#endif 305#endif
280 return get_av (name, create); 306 return get_av (name, create);
281} 307}
282 308
283static HV * 309static HV *
284coro_get_hv (pTHX_ const char *name, int create) 310coro_get_hv (pTHX_ const char *name, int create)
285{ 311{
286#if PERL_VERSION_ATLEAST (5,9,0) 312#if PERL_VERSION_ATLEAST (5,10,0)
287 /* silence stupid and wrong 5.10 warning that I am unable to switch off */ 313 /* silence stupid and wrong 5.10 warning that I am unable to switch off */
288 get_hv (name, create); 314 get_hv (name, create);
289#endif 315#endif
290 return get_hv (name, create); 316 return get_hv (name, create);
291} 317}
… …
296 AV *padlist = CvPADLIST (cv); 322 AV *padlist = CvPADLIST (cv);
297 AV *newpadlist, *newpad; 323 AV *newpadlist, *newpad;
298 324
299 newpadlist = newAV (); 325 newpadlist = newAV ();
300 AvREAL_off (newpadlist); 326 AvREAL_off (newpadlist);
301#if PERL_VERSION_ATLEAST (5,9,0) 327#if PERL_VERSION_ATLEAST (5,10,0)
302 Perl_pad_push (aTHX_ padlist, AvFILLp (padlist) + 1); 328 Perl_pad_push (aTHX_ padlist, AvFILLp (padlist) + 1);
303#else 329#else
304 Perl_pad_push (aTHX_ padlist, AvFILLp (padlist) + 1, 1); 330 Perl_pad_push (aTHX_ padlist, AvFILLp (padlist) + 1, 1);
305#endif 331#endif
306 newpad = (AV *)AvARRAY (padlist)[AvFILLp (padlist)]; 332 newpad = (AV *)AvARRAY (padlist)[AvFILLp (padlist)];
307 --AvFILLp (padlist); 333 --AvFILLp (padlist);
308 334
309 av_store (newpadlist, 0, SvREFCNT_inc (*av_fetch (padlist, 0, FALSE))); 335 av_store (newpadlist, 0, SvREFCNT_inc_NN (*av_fetch (padlist, 0, FALSE)));
310 av_store (newpadlist, 1, (SV *)newpad); 336 av_store (newpadlist, 1, (SV *)newpad);
311 337
312 return newpadlist; 338 return newpadlist;
313} 339}
314 340
… …
344 370
345 /* casting is fun. */ 371 /* casting is fun. */
346 while (&PL_sv_undef != (SV *)(padlist = (AV *)av_pop (av))) 372 while (&PL_sv_undef != (SV *)(padlist = (AV *)av_pop (av)))
347 free_padlist (aTHX_ padlist); 373 free_padlist (aTHX_ padlist);
348 374
375 SvREFCNT_dec (av); /* sv_magicext increased the refcount */
376
349 return 0; 377 return 0;
350} 378}
351 379
352#define CORO_MAGIC_type_cv PERL_MAGIC_ext 380#define CORO_MAGIC_type_cv PERL_MAGIC_ext
353#define CORO_MAGIC_type_state PERL_MAGIC_ext 381#define CORO_MAGIC_type_state PERL_MAGIC_ext
… …
403 if (expect_true (mg && AvFILLp ((av = (AV *)mg->mg_obj)) >= 0)) 431 if (expect_true (mg && AvFILLp ((av = (AV *)mg->mg_obj)) >= 0))
404 CvPADLIST (cv) = (AV *)AvARRAY (av)[AvFILLp (av)--]; 432 CvPADLIST (cv) = (AV *)AvARRAY (av)[AvFILLp (av)--];
405 else 433 else
406 { 434 {
407#if CORO_PREFER_PERL_FUNCTIONS 435#if CORO_PREFER_PERL_FUNCTIONS
408 /* this is probably cleaner, but also slower? */ 436 /* this is probably cleaner? but also slower! */
437 /* in practise, it seems to be less stable */
409 CV *cp = Perl_cv_clone (cv); 438 CV *cp = Perl_cv_clone (cv);
410 CvPADLIST (cv) = CvPADLIST (cp); 439 CvPADLIST (cv) = CvPADLIST (cp);
411 CvPADLIST (cp) = 0; 440 CvPADLIST (cp) = 0;
412 SvREFCNT_dec (cp); 441 SvREFCNT_dec (cp);
413#else 442#else
… …
497 526
498 if (expect_true (CvDEPTH (cv))) 527 if (expect_true (CvDEPTH (cv)))
499 { 528 {
500 EXTEND (SP, 3); 529 EXTEND (SP, 3);
501 PUSHs ((SV *)CvPADLIST (cv)); 530 PUSHs ((SV *)CvPADLIST (cv));
502 PUSHs (INT2PTR (SV *, CvDEPTH (cv))); 531 PUSHs (INT2PTR (SV *, (IV)CvDEPTH (cv)));
503 PUSHs ((SV *)cv); 532 PUSHs ((SV *)cv);
504 533
505 CvDEPTH (cv) = 0; 534 CvDEPTH (cv) = 0;
506 get_padlist (aTHX_ cv); 535 get_padlist (aTHX_ cv);
507 } 536 }
… …
587 616
588 New(54,PL_savestack,24,ANY); 617 New(54,PL_savestack,24,ANY);
589 PL_savestack_ix = 0; 618 PL_savestack_ix = 0;
590 PL_savestack_max = 24; 619 PL_savestack_max = 24;
591 620
592#if !PERL_VERSION_ATLEAST (5,9,0) 621#if !PERL_VERSION_ATLEAST (5,10,0)
593 New(54,PL_retstack,4,OP*); 622 New(54,PL_retstack,4,OP*);
594 PL_retstack_ix = 0; 623 PL_retstack_ix = 0;
595 PL_retstack_max = 4; 624 PL_retstack_max = 4;
596#endif 625#endif
597} 626}
… …
620 649
621 Safefree (PL_tmps_stack); 650 Safefree (PL_tmps_stack);
622 Safefree (PL_markstack); 651 Safefree (PL_markstack);
623 Safefree (PL_scopestack); 652 Safefree (PL_scopestack);
624 Safefree (PL_savestack); 653 Safefree (PL_savestack);
625#if !PERL_VERSION_ATLEAST (5,9,0) 654#if !PERL_VERSION_ATLEAST (5,10,0)
626 Safefree (PL_retstack); 655 Safefree (PL_retstack);
627#endif 656#endif
628} 657}
629 658
630static size_t 659static size_t
… …
646 #undef VAR 675 #undef VAR
647 } 676 }
648 else 677 else
649 slot = coro->slot; 678 slot = coro->slot;
650 679
680 if (slot)
681 {
651 rss += sizeof (slot->curstackinfo); 682 rss += sizeof (slot->curstackinfo);
652 rss += (slot->curstackinfo->si_cxmax + 1) * sizeof (PERL_CONTEXT); 683 rss += (slot->curstackinfo->si_cxmax + 1) * sizeof (PERL_CONTEXT);
653 rss += sizeof (SV) + sizeof (struct xpvav) + (1 + AvMAX (slot->curstack)) * sizeof (SV *); 684 rss += sizeof (SV) + sizeof (struct xpvav) + (1 + AvMAX (slot->curstack)) * sizeof (SV *);
654 rss += slot->tmps_max * sizeof (SV *); 685 rss += slot->tmps_max * sizeof (SV *);
655 rss += (slot->markstack_max - slot->markstack_ptr) * sizeof (I32); 686 rss += (slot->markstack_max - slot->markstack_ptr) * sizeof (I32);
656 rss += slot->scopestack_max * sizeof (I32); 687 rss += slot->scopestack_max * sizeof (I32);
657 rss += slot->savestack_max * sizeof (ANY); 688 rss += slot->savestack_max * sizeof (ANY);
658 689
659#if !PERL_VERSION_ATLEAST (5,9,0) 690#if !PERL_VERSION_ATLEAST (5,10,0)
660 rss += slot->retstack_max * sizeof (OP *); 691 rss += slot->retstack_max * sizeof (OP *);
661#endif 692#endif
693 }
662 } 694 }
663 695
664 return rss; 696 return rss;
665} 697}
666 698
667/** coroutine stack handling ************************************************/ 699/** coroutine stack handling ************************************************/
668 700
669static int (*orig_sigelem_get) (pTHX_ SV *sv, MAGIC *mg); 701static int (*orig_sigelem_get) (pTHX_ SV *sv, MAGIC *mg);
670static int (*orig_sigelem_set) (pTHX_ SV *sv, MAGIC *mg); 702static int (*orig_sigelem_set) (pTHX_ SV *sv, MAGIC *mg);
703static int (*orig_sigelem_clr) (pTHX_ SV *sv, MAGIC *mg);
704
705/* apparently < 5.8.8 */
706#ifndef MgPV_nolen_const
707#define MgPV_nolen_const(mg) (((((int)(mg)->mg_len)) == HEf_SVKEY) ? \
708 SvPV_nolen((SV*)((mg)->mg_ptr)) : \
709 (const char*)(mg)->mg_ptr)
710#endif
671 711
672/* 712/*
673 * This overrides the default magic get method of %SIG elements. 713 * This overrides the default magic get method of %SIG elements.
674 * The original one doesn't provide for reading back of PL_diehook/PL_warnhook 714 * The original one doesn't provide for reading back of PL_diehook/PL_warnhook
675 * and instead of tryign to save and restore the hash elements, we just provide 715 * and instead of tryign to save and restore the hash elements, we just provide
… …
683{ 723{
684 const char *s = MgPV_nolen_const (mg); 724 const char *s = MgPV_nolen_const (mg);
685 725
686 if (*s == '_') 726 if (*s == '_')
687 { 727 {
688 if (strEQ (s, "__DIE__" ) && PL_diehook ) return sv_setsv (sv, PL_diehook ), 0; 728 SV **svp = 0;
689 if (strEQ (s, "__WARN__") && PL_warnhook) return sv_setsv (sv, PL_warnhook), 0; 729
730 if (strEQ (s, "__DIE__" )) svp = &PL_diehook;
731 if (strEQ (s, "__WARN__")) svp = &PL_warnhook;
732
733 if (svp)
734 {
735 sv_setsv (sv, *svp ? *svp : &PL_sv_undef);
736 return 0;
737 }
690 } 738 }
691 739
692 return orig_sigelem_get ? orig_sigelem_get (aTHX_ sv, mg) : 0; 740 return orig_sigelem_get ? orig_sigelem_get (aTHX_ sv, mg) : 0;
741}
742
743static int
744coro_sigelem_clr (pTHX_ SV *sv, MAGIC *mg)
745{
746 const char *s = MgPV_nolen_const (mg);
747
748 if (*s == '_')
749 {
750 SV **svp = 0;
751
752 if (strEQ (s, "__DIE__" )) svp = &PL_diehook;
753 if (strEQ (s, "__WARN__")) svp = &PL_warnhook;
754
755 if (svp)
756 {
757 SV *old = *svp;
758 *svp = 0;
759 SvREFCNT_dec (old);
760 return 0;
761 }
762 }
763
764 return orig_sigelem_clr ? orig_sigelem_clr (aTHX_ sv, mg) : 0;
693} 765}
694 766
695static int 767static int
696coro_sigelem_set (pTHX_ SV *sv, MAGIC *mg) 768coro_sigelem_set (pTHX_ SV *sv, MAGIC *mg)
697{ 769{
… …
707 if (svp) 779 if (svp)
708 { 780 {
709 SV *old = *svp; 781 SV *old = *svp;
710 *svp = newSVsv (sv); 782 *svp = newSVsv (sv);
711 SvREFCNT_dec (old); 783 SvREFCNT_dec (old);
712 return; 784 return 0;
713 } 785 }
714 } 786 }
715 787
716 return orig_sigelem_set ? orig_sigelem_set (aTHX_ sv, mg) : 0; 788 return orig_sigelem_set ? orig_sigelem_set (aTHX_ sv, mg) : 0;
717} 789}
… …
731 PL_curpm = 0; 803 PL_curpm = 0;
732 PL_curpad = 0; 804 PL_curpad = 0;
733 PL_localizing = 0; 805 PL_localizing = 0;
734 PL_dirty = 0; 806 PL_dirty = 0;
735 PL_restartop = 0; 807 PL_restartop = 0;
808#if PERL_VERSION_ATLEAST (5,10,0)
809 PL_parser = 0;
810#endif
736 811
737 /* recreate the die/warn hooks */ 812 /* recreate the die/warn hooks */
738 PL_diehook = 0; SvSetMagicSV (*hv_fetch (hv_sig, "__DIE__" , sizeof ("__DIE__" ) - 1, 1), rv_diehook ); 813 PL_diehook = 0; SvSetMagicSV (*hv_fetch (hv_sig, "__DIE__" , sizeof ("__DIE__" ) - 1, 1), rv_diehook );
739 PL_warnhook = 0; SvSetMagicSV (*hv_fetch (hv_sig, "__WARN__", sizeof ("__WARN__") - 1, 1), rv_warnhook); 814 PL_warnhook = 0; SvSetMagicSV (*hv_fetch (hv_sig, "__WARN__", sizeof ("__WARN__") - 1, 1), rv_warnhook);
740 815
741 GvSV (PL_defgv) = newSV (0); 816 GvSV (PL_defgv) = newSV (0);
742 GvAV (PL_defgv) = coro->args; coro->args = 0; 817 GvAV (PL_defgv) = coro->args; coro->args = 0;
743 GvSV (PL_errgv) = newSV (0); 818 GvSV (PL_errgv) = newSV (0);
744 GvSV (irsgv) = newSVpvn ("\n", 1); sv_magic (GvSV (irsgv), (SV *)irsgv, PERL_MAGIC_sv, "/", 0); 819 GvSV (irsgv) = newSVpvn ("\n", 1); sv_magic (GvSV (irsgv), (SV *)irsgv, PERL_MAGIC_sv, "/", 0);
745 PL_rs = newSVsv (GvSV (irsgv)); 820 PL_rs = newSVsv (GvSV (irsgv));
746 PL_defoutgv = (GV *)SvREFCNT_inc (stdoutgv); 821 PL_defoutgv = (GV *)SvREFCNT_inc_NN (stdoutgv);
747 822
748 { 823 {
749 dSP; 824 dSP;
750 LOGOP myop; 825 LOGOP myop;
751 826
… …
847 : cx->blk_gimme == G_SCALAR ? bot + 1 922 : cx->blk_gimme == G_SCALAR ? bot + 1
848 : bot; 923 : bot;
849 924
850 av_extend (av, top - bot); 925 av_extend (av, top - bot);
851 while (bot < top) 926 while (bot < top)
852 av_push (av, SvREFCNT_inc (*bot++)); 927 av_push (av, SvREFCNT_inc_NN (*bot++));
853 928
854 PL_runops = RUNOPS_DEFAULT; 929 PL_runops = RUNOPS_DEFAULT;
855 ENTER; 930 ENTER;
856 SAVETMPS; 931 SAVETMPS;
857 EXTEND (SP, 3); 932 EXTEND (SP, 3);
… …
895 SAVETMPS; 970 SAVETMPS;
896 EXTEND (SP, 3); 971 EXTEND (SP, 3);
897 PUSHMARK (SP); 972 PUSHMARK (SP);
898 PUSHs (&PL_sv_yes); 973 PUSHs (&PL_sv_yes);
899 PUSHs (fullname); 974 PUSHs (fullname);
900 PUSHs (cx->blk_sub.hasargs ? sv_2mortal (newRV_inc ((SV *)cx->blk_sub.argarray)) : &PL_sv_undef); 975 PUSHs (CxHASARGS (cx) ? sv_2mortal (newRV_inc ((SV *)cx->blk_sub.argarray)) : &PL_sv_undef);
901 PUTBACK; 976 PUTBACK;
902 cb = hv_fetch ((HV *)SvRV (coro_current), "_trace_sub_cb", sizeof ("_trace_sub_cb") - 1, 0); 977 cb = hv_fetch ((HV *)SvRV (coro_current), "_trace_sub_cb", sizeof ("_trace_sub_cb") - 1, 0);
903 if (cb) call_sv (*cb, G_KEEPERR | G_EVAL | G_VOID | G_DISCARD); 978 if (cb) call_sv (*cb, G_KEEPERR | G_EVAL | G_VOID | G_DISCARD);
904 SPAGAIN; 979 SPAGAIN;
905 FREETMPS; 980 FREETMPS;
… …
1121 croak ("Coro::State::transfer called with running next Coro::State, but can only transfer to inactive states"); 1196 croak ("Coro::State::transfer called with running next Coro::State, but can only transfer to inactive states");
1122 1197
1123 if (expect_false (next->flags & CF_DESTROYED)) 1198 if (expect_false (next->flags & CF_DESTROYED))
1124 croak ("Coro::State::transfer called with destroyed next Coro::State, but can only transfer to inactive states"); 1199 croak ("Coro::State::transfer called with destroyed next Coro::State, but can only transfer to inactive states");
1125 1200
1126 if (
1127#if PERL_VERSION_ATLEAST (5,9,0) 1201#if !PERL_VERSION_ATLEAST (5,10,0)
1128 expect_false (PL_parser && PL_parser->lex_state != LEX_NOTPARSING)
1129#else
1130 expect_false (PL_lex_state != LEX_NOTPARSING) 1202 if (expect_false (PL_lex_state != LEX_NOTPARSING))
1131#endif
1132 )
1133 croak ("Coro::State::transfer called while parsing, but this is not supported"); 1203 croak ("Coro::State::transfer called while parsing, but this is not supported in your perl version");
1204#endif
1134 } 1205 }
1135} 1206}
1136 1207
1137/* always use the TRANSFER macro */ 1208/* always use the TRANSFER macro */
1138static void NOINLINE 1209static void NOINLINE
1139transfer (pTHX_ struct coro *prev, struct coro *next) 1210transfer (pTHX_ struct coro *prev, struct coro *next, int force_cctx)
1140{ 1211{
1141 dSTACKLEVEL; 1212 dSTACKLEVEL;
1142 static volatile int has_throw; 1213 static volatile int has_throw;
1143 1214
1144 /* sometimes transfer is only called to set idle_sp */ 1215 /* sometimes transfer is only called to set idle_sp */
… …
1178 load_perl (aTHX_ next); 1249 load_perl (aTHX_ next);
1179 1250
1180 prev__cctx = prev->cctx; 1251 prev__cctx = prev->cctx;
1181 1252
1182 /* possibly "free" the cctx */ 1253 /* possibly "free" the cctx */
1183 if (expect_true (prev__cctx->idle_sp == STACKLEVEL && !(prev__cctx->flags & CC_TRACE))) 1254 if (expect_true (
1255 prev__cctx->idle_sp == STACKLEVEL
1256 && !(prev__cctx->flags & CC_TRACE)
1257 && !force_cctx
1258 ))
1184 { 1259 {
1185 /* I assume that STACKLEVEL is a stronger indicator than PL_top_env changes */ 1260 /* I assume that STACKLEVEL is a stronger indicator than PL_top_env changes */
1186 assert (("ERROR: current top_env must equal previous top_env", PL_top_env == prev__cctx->idle_te)); 1261 assert (("ERROR: current top_env must equal previous top_env", PL_top_env == prev__cctx->idle_te));
1187 1262
1188 prev->cctx = 0; 1263 prev->cctx = 0;
… …
1231struct transfer_args 1306struct transfer_args
1232{ 1307{
1233 struct coro *prev, *next; 1308 struct coro *prev, *next;
1234}; 1309};
1235 1310
1236#define TRANSFER(ta) transfer (aTHX_ (ta).prev, (ta).next) 1311#define TRANSFER(ta, force_cctx) transfer (aTHX_ (ta).prev, (ta).next, (force_cctx))
1237#define TRANSFER_CHECK(ta) transfer_check (aTHX_ (ta).prev, (ta).next) 1312#define TRANSFER_CHECK(ta) transfer_check (aTHX_ (ta).prev, (ta).next)
1238 1313
1239/** high level stuff ********************************************************/ 1314/** high level stuff ********************************************************/
1240 1315
1241static int 1316static int
… …
1335{ 1410{
1336 dTHX; 1411 dTHX;
1337 struct transfer_args ta; 1412 struct transfer_args ta;
1338 1413
1339 prepare_transfer (aTHX_ &ta, prev_sv, next_sv); 1414 prepare_transfer (aTHX_ &ta, prev_sv, next_sv);
1340 TRANSFER (ta); 1415 TRANSFER (ta, 1);
1341} 1416}
1342 1417
1343/** Coro ********************************************************************/ 1418/** Coro ********************************************************************/
1344 1419
1345static void 1420static void
… …
1363static int 1438static int
1364api_ready (SV *coro_sv) 1439api_ready (SV *coro_sv)
1365{ 1440{
1366 dTHX; 1441 dTHX;
1367 struct coro *coro; 1442 struct coro *coro;
1443 SV *sv_hook;
1444 void (*xs_hook)(void);
1368 1445
1369 if (SvROK (coro_sv)) 1446 if (SvROK (coro_sv))
1370 coro_sv = SvRV (coro_sv); 1447 coro_sv = SvRV (coro_sv);
1371 1448
1372 coro = SvSTATE (coro_sv); 1449 coro = SvSTATE (coro_sv);
… …
1375 return 0; 1452 return 0;
1376 1453
1377 coro->flags |= CF_READY; 1454 coro->flags |= CF_READY;
1378 1455
1379 LOCK; 1456 LOCK;
1457
1458 sv_hook = coro_nready ? 0 : coro_readyhook;
1459 xs_hook = coro_nready ? 0 : coroapi.readyhook;
1460
1380 coro_enq (aTHX_ SvREFCNT_inc (coro_sv)); 1461 coro_enq (aTHX_ SvREFCNT_inc_NN (coro_sv));
1381 ++coro_nready; 1462 ++coro_nready;
1463
1382 UNLOCK; 1464 UNLOCK;
1465
1466 if (sv_hook)
1467 {
1468 dSP;
1469
1470 ENTER;
1471 SAVETMPS;
1472
1473 PUSHMARK (SP);
1474 PUTBACK;
1475 call_sv (sv_hook, G_DISCARD);
1476 SPAGAIN;
1477
1478 FREETMPS;
1479 LEAVE;
1480 }
1481
1482 if (xs_hook)
1483 xs_hook ();
1383 1484
1384 return 1; 1485 return 1;
1385} 1486}
1386 1487
1387static int 1488static int
… …
1476{ 1577{
1477 dTHX; 1578 dTHX;
1478 struct transfer_args ta; 1579 struct transfer_args ta;
1479 1580
1480 prepare_schedule (aTHX_ &ta); 1581 prepare_schedule (aTHX_ &ta);
1481 TRANSFER (ta); 1582 TRANSFER (ta, 1);
1482} 1583}
1483 1584
1484static int 1585static int
1485api_cede (void) 1586api_cede (void)
1486{ 1587{
… …
1489 1590
1490 prepare_cede (aTHX_ &ta); 1591 prepare_cede (aTHX_ &ta);
1491 1592
1492 if (expect_true (ta.prev != ta.next)) 1593 if (expect_true (ta.prev != ta.next))
1493 { 1594 {
1494 TRANSFER (ta); 1595 TRANSFER (ta, 1);
1495 return 1; 1596 return 1;
1496 } 1597 }
1497 else 1598 else
1498 return 0; 1599 return 0;
1499} 1600}
… …
1504 dTHX; 1605 dTHX;
1505 struct transfer_args ta; 1606 struct transfer_args ta;
1506 1607
1507 if (prepare_cede_notself (aTHX_ &ta)) 1608 if (prepare_cede_notself (aTHX_ &ta))
1508 { 1609 {
1509 TRANSFER (ta); 1610 TRANSFER (ta, 1);
1510 return 1; 1611 return 1;
1511 } 1612 }
1512 else 1613 else
1513 return 0; 1614 return 0;
1514} 1615}
… …
1537 else 1638 else
1538 coro->slot->runops = RUNOPS_DEFAULT; 1639 coro->slot->runops = RUNOPS_DEFAULT;
1539 } 1640 }
1540} 1641}
1541 1642
1643static int
1644coro_gensub_free (pTHX_ SV *sv, MAGIC *mg)
1645{
1646 AV *padlist;
1647 AV *av = (AV *)mg->mg_obj;
1648
1649 abort ();
1650
1651 return 0;
1652}
1653
1654static MGVTBL coro_gensub_vtbl = {
1655 0, 0, 0, 0,
1656 coro_gensub_free
1657};
1658
1659/*****************************************************************************/
1660/* PerlIO::cede */
1661
1662typedef struct
1663{
1664 PerlIOBuf base;
1665 NV next, every;
1666} PerlIOCede;
1667
1668static IV
1669PerlIOCede_pushed (pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
1670{
1671 PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
1672
1673 self->every = SvCUR (arg) ? SvNV (arg) : 0.01;
1674 self->next = nvtime () + self->every;
1675
1676 return PerlIOBuf_pushed (aTHX_ f, mode, Nullsv, tab);
1677}
1678
1679static SV *
1680PerlIOCede_getarg (pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)
1681{
1682 PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
1683
1684 return newSVnv (self->every);
1685}
1686
1687static IV
1688PerlIOCede_flush (pTHX_ PerlIO *f)
1689{
1690 PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
1691 double now = nvtime ();
1692
1693 if (now >= self->next)
1694 {
1695 api_cede ();
1696 self->next = now + self->every;
1697 }
1698
1699 return PerlIOBuf_flush (aTHX_ f);
1700}
1701
1702static PerlIO_funcs PerlIO_cede =
1703{
1704 sizeof(PerlIO_funcs),
1705 "cede",
1706 sizeof(PerlIOCede),
1707 PERLIO_K_DESTRUCT | PERLIO_K_RAW,
1708 PerlIOCede_pushed,
1709 PerlIOBuf_popped,
1710 PerlIOBuf_open,
1711 PerlIOBase_binmode,
1712 PerlIOCede_getarg,
1713 PerlIOBase_fileno,
1714 PerlIOBuf_dup,
1715 PerlIOBuf_read,
1716 PerlIOBuf_unread,
1717 PerlIOBuf_write,
1718 PerlIOBuf_seek,
1719 PerlIOBuf_tell,
1720 PerlIOBuf_close,
1721 PerlIOCede_flush,
1722 PerlIOBuf_fill,
1723 PerlIOBase_eof,
1724 PerlIOBase_error,
1725 PerlIOBase_clearerr,
1726 PerlIOBase_setlinebuf,
1727 PerlIOBuf_get_base,
1728 PerlIOBuf_bufsiz,
1729 PerlIOBuf_get_ptr,
1730 PerlIOBuf_get_cnt,
1731 PerlIOBuf_set_ptrcnt,
1732};
1733
1734
1542MODULE = Coro::State PACKAGE = Coro::State PREFIX = api_ 1735MODULE = Coro::State PACKAGE = Coro::State PREFIX = api_
1543 1736
1544PROTOTYPES: DISABLE 1737PROTOTYPES: DISABLE
1545 1738
1546BOOT: 1739BOOT:
… …
1551 BOOT_PAGESIZE; 1744 BOOT_PAGESIZE;
1552 1745
1553 irsgv = gv_fetchpv ("/" , GV_ADD|GV_NOTQUAL, SVt_PV); 1746 irsgv = gv_fetchpv ("/" , GV_ADD|GV_NOTQUAL, SVt_PV);
1554 stdoutgv = gv_fetchpv ("STDOUT", GV_ADD|GV_NOTQUAL, SVt_PVIO); 1747 stdoutgv = gv_fetchpv ("STDOUT", GV_ADD|GV_NOTQUAL, SVt_PVIO);
1555 1748
1556 orig_sigelem_get = PL_vtbl_sigelem.svt_get; 1749 orig_sigelem_get = PL_vtbl_sigelem.svt_get; PL_vtbl_sigelem.svt_get = coro_sigelem_get;
1557 PL_vtbl_sigelem.svt_get = coro_sigelem_get; 1750 orig_sigelem_set = PL_vtbl_sigelem.svt_set; PL_vtbl_sigelem.svt_set = coro_sigelem_set;
1558 orig_sigelem_set = PL_vtbl_sigelem.svt_set; 1751 orig_sigelem_clr = PL_vtbl_sigelem.svt_clear; PL_vtbl_sigelem.svt_clear = coro_sigelem_clr;
1559 PL_vtbl_sigelem.svt_set = coro_sigelem_set;
1560 1752
1561 hv_sig = coro_get_hv (aTHX_ "SIG", TRUE); 1753 hv_sig = coro_get_hv (aTHX_ "SIG", TRUE);
1562 rv_diehook = newRV_inc ((SV *)gv_fetchpv ("Coro::State::diehook" , 0, SVt_PVCV)); 1754 rv_diehook = newRV_inc ((SV *)gv_fetchpv ("Coro::State::diehook" , 0, SVt_PVCV));
1563 rv_warnhook = newRV_inc ((SV *)gv_fetchpv ("Coro::State::warnhook", 0, SVt_PVCV)); 1755 rv_warnhook = newRV_inc ((SV *)gv_fetchpv ("Coro::State::warnhook", 0, SVt_PVCV));
1564 1756
… …
1573 main_top_env = PL_top_env; 1765 main_top_env = PL_top_env;
1574 1766
1575 while (main_top_env->je_prev) 1767 while (main_top_env->je_prev)
1576 main_top_env = main_top_env->je_prev; 1768 main_top_env = main_top_env->je_prev;
1577 1769
1578 coroapi.ver = CORO_API_VERSION; 1770 coroapi.ver = CORO_API_VERSION;
1579 coroapi.rev = CORO_API_REVISION; 1771 coroapi.rev = CORO_API_REVISION;
1580 coroapi.transfer = api_transfer; 1772 coroapi.transfer = api_transfer;
1773
1774 {
1775 SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
1776
1777 if (!svp) croak ("Time::HiRes is required");
1778 if (!SvIOK (*svp)) croak ("Time::NVtime isn't a function pointer");
1779
1780 nvtime = INT2PTR (double (*)(), SvIV (*svp));
1781 }
1581 1782
1582 assert (("PRIO_NORMAL must be 0", !PRIO_NORMAL)); 1783 assert (("PRIO_NORMAL must be 0", !PRIO_NORMAL));
1583} 1784}
1584 1785
1585SV * 1786SV *
… …
1656 } 1857 }
1657 SPAGAIN; 1858 SPAGAIN;
1658 1859
1659 BARRIER; 1860 BARRIER;
1660 PUTBACK; 1861 PUTBACK;
1661 TRANSFER (ta); 1862 TRANSFER (ta, 0);
1662 SPAGAIN; /* might be the sp of a different coroutine now */ 1863 SPAGAIN; /* might be the sp of a different coroutine now */
1663 /* be extra careful not to ever do anything after TRANSFER */ 1864 /* be extra careful not to ever do anything after TRANSFER */
1664} 1865}
1665 1866
1666bool 1867bool
… …
1669 RETVAL = coro_state_destroy (aTHX_ SvSTATE (coro_sv)); 1870 RETVAL = coro_state_destroy (aTHX_ SvSTATE (coro_sv));
1670 OUTPUT: 1871 OUTPUT:
1671 RETVAL 1872 RETVAL
1672 1873
1673void 1874void
1674_exit (code) 1875_exit (int code)
1675 int code
1676 PROTOTYPE: $ 1876 PROTOTYPE: $
1677 CODE: 1877 CODE:
1678 _exit (code); 1878 _exit (code);
1679 1879
1680int 1880int
… …
1714call (Coro::State coro, SV *coderef) 1914call (Coro::State coro, SV *coderef)
1715 ALIAS: 1915 ALIAS:
1716 eval = 1 1916 eval = 1
1717 CODE: 1917 CODE:
1718{ 1918{
1719 if (coro->mainstack) 1919 if (coro->mainstack && ((coro->flags & CF_RUNNING) || coro->slot))
1720 { 1920 {
1721 struct coro temp; 1921 struct coro temp;
1722 1922
1723 if (!(coro->flags & CF_RUNNING)) 1923 if (!(coro->flags & CF_RUNNING))
1724 { 1924 {
… …
1771 1971
1772void 1972void
1773api_trace (SV *coro, int flags = CC_TRACE | CC_TRACE_SUB) 1973api_trace (SV *coro, int flags = CC_TRACE | CC_TRACE_SUB)
1774 1974
1775SV * 1975SV *
1776has_stack (Coro::State coro) 1976has_cctx (Coro::State coro)
1777 PROTOTYPE: $ 1977 PROTOTYPE: $
1778 CODE: 1978 CODE:
1779 RETVAL = boolSV (!!coro->cctx); 1979 RETVAL = boolSV (!!coro->cctx);
1780 OUTPUT: 1980 OUTPUT:
1781 RETVAL 1981 RETVAL
… …
1800 case 1: RETVAL = coro->usecount; break; 2000 case 1: RETVAL = coro->usecount; break;
1801 } 2001 }
1802 OUTPUT: 2002 OUTPUT:
1803 RETVAL 2003 RETVAL
1804 2004
2005void
2006force_cctx ()
2007 CODE:
2008 struct coro *coro = SvSTATE (coro_current);
2009 coro->cctx->idle_sp = 0;
2010
2011void
2012throw (Coro::State self, SV *throw = &PL_sv_undef)
2013 PROTOTYPE: $;$
2014 CODE:
2015 SvREFCNT_dec (self->throw);
2016 self->throw = SvOK (throw) ? newSVsv (throw) : 0;
2017
2018void
2019swap_defsv (Coro::State self)
2020 PROTOTYPE: $
2021 ALIAS:
2022 swap_defav = 1
2023 CODE:
2024 if (!self->slot)
2025 croak ("cannot swap state with coroutine that has no saved state");
2026 else
2027 {
2028 SV **src = ix ? (SV **)&GvAV (PL_defgv) : &GvSV (PL_defgv);
2029 SV **dst = ix ? (SV **)&self->slot->defav : (SV **)&self->slot->defsv;
2030
2031 SV *tmp = *src; *src = *dst; *dst = tmp;
2032 }
1805 2033
1806MODULE = Coro::State PACKAGE = Coro 2034MODULE = Coro::State PACKAGE = Coro
1807 2035
1808BOOT: 2036BOOT:
1809{ 2037{
1810 int i; 2038 int i;
1811 2039
2040 av_async_pool = coro_get_av (aTHX_ "Coro::async_pool", TRUE);
1812 sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE); 2041 sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE);
1813 sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE); 2042 sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE);
1814 av_async_pool = coro_get_av (aTHX_ "Coro::async_pool", TRUE);
1815 2043
1816 coro_current = coro_get_sv (aTHX_ "Coro::current", FALSE); 2044 coro_current = coro_get_sv (aTHX_ "Coro::current", FALSE);
1817 SvREADONLY_on (coro_current); 2045 SvREADONLY_on (coro_current);
1818 2046
1819 coro_stash = gv_stashpv ("Coro", TRUE); 2047 coro_stash = gv_stashpv ("Coro", TRUE);
… …
1849void 2077void
1850_set_current (SV *current) 2078_set_current (SV *current)
1851 PROTOTYPE: $ 2079 PROTOTYPE: $
1852 CODE: 2080 CODE:
1853 SvREFCNT_dec (SvRV (coro_current)); 2081 SvREFCNT_dec (SvRV (coro_current));
1854 SvRV_set (coro_current, SvREFCNT_inc (SvRV (current))); 2082 SvRV_set (coro_current, SvREFCNT_inc_NN (SvRV (current)));
2083
2084void
2085_set_readyhook (SV *hook)
2086 PROTOTYPE: $
2087 CODE:
2088 LOCK;
2089 SvREFCNT_dec (coro_readyhook);
2090 coro_readyhook = SvOK (hook) ? newSVsv (hook) : 0;
2091 UNLOCK;
1855 2092
1856int 2093int
1857prio (Coro::State coro, int newprio = 0) 2094prio (Coro::State coro, int newprio = 0)
1858 ALIAS: 2095 ALIAS:
1859 nice = 1 2096 nice = 1
… …
1889 CODE: 2126 CODE:
1890 RETVAL = coro_nready; 2127 RETVAL = coro_nready;
1891 OUTPUT: 2128 OUTPUT:
1892 RETVAL 2129 RETVAL
1893 2130
1894void
1895throw (Coro::State self, SV *throw = &PL_sv_undef)
1896 PROTOTYPE: $;$
1897 CODE:
1898 SvREFCNT_dec (self->throw);
1899 self->throw = SvOK (throw) ? newSVsv (throw) : 0;
1900
1901# for async_pool speedup 2131# for async_pool speedup
1902void 2132void
1903_pool_1 (SV *cb) 2133_pool_1 (SV *cb)
1904 CODE: 2134 CODE:
1905{ 2135{
… …
1910 AV *invoke_av; 2140 AV *invoke_av;
1911 int i, len; 2141 int i, len;
1912 2142
1913 if (!invoke) 2143 if (!invoke)
1914 { 2144 {
1915 SvREFCNT_dec (PL_diehook); PL_diehook = 0; 2145 SV *old = PL_diehook;
2146 PL_diehook = 0;
2147 SvREFCNT_dec (old);
1916 croak ("\3async_pool terminate\2\n"); 2148 croak ("\3async_pool terminate\2\n");
1917 } 2149 }
1918 2150
1919 SvREFCNT_dec (coro->saved_deffh); 2151 SvREFCNT_dec (coro->saved_deffh);
1920 coro->saved_deffh = SvREFCNT_inc ((SV *)PL_defoutgv); 2152 coro->saved_deffh = SvREFCNT_inc_NN ((SV *)PL_defoutgv);
1921 2153
1922 hv_store (hv, "desc", sizeof ("desc") - 1, 2154 hv_store (hv, "desc", sizeof ("desc") - 1,
1923 newSVpvn ("[async_pool]", sizeof ("[async_pool]") - 1), 0); 2155 newSVpvn ("[async_pool]", sizeof ("[async_pool]") - 1), 0);
1924 2156
1925 invoke_av = (AV *)SvRV (invoke); 2157 invoke_av = (AV *)SvRV (invoke);
… …
1929 2161
1930 if (len > 0) 2162 if (len > 0)
1931 { 2163 {
1932 av_fill (defav, len - 1); 2164 av_fill (defav, len - 1);
1933 for (i = 0; i < len; ++i) 2165 for (i = 0; i < len; ++i)
1934 av_store (defav, i, SvREFCNT_inc (AvARRAY (invoke_av)[i + 1])); 2166 av_store (defav, i, SvREFCNT_inc_NN (AvARRAY (invoke_av)[i + 1]));
1935 } 2167 }
1936 2168
1937 SvREFCNT_dec (invoke); 2169 SvREFCNT_dec (invoke);
1938} 2170}
1939 2171
… …
1949 coro->saved_deffh = 0; 2181 coro->saved_deffh = 0;
1950 2182
1951 if (coro_rss (aTHX_ coro) > SvIV (sv_pool_rss) 2183 if (coro_rss (aTHX_ coro) > SvIV (sv_pool_rss)
1952 || av_len (av_async_pool) + 1 >= SvIV (sv_pool_size)) 2184 || av_len (av_async_pool) + 1 >= SvIV (sv_pool_size))
1953 { 2185 {
1954 SvREFCNT_dec (PL_diehook); PL_diehook = 0; 2186 SV *old = PL_diehook;
2187 PL_diehook = 0;
2188 SvREFCNT_dec (old);
1955 croak ("\3async_pool terminate\2\n"); 2189 croak ("\3async_pool terminate\2\n");
1956 } 2190 }
1957 2191
1958 av_clear (GvAV (PL_defgv)); 2192 av_clear (GvAV (PL_defgv));
1959 hv_store ((HV *)SvRV (coro_current), "desc", sizeof ("desc") - 1, 2193 hv_store ((HV *)SvRV (coro_current), "desc", sizeof ("desc") - 1,
… …
1965 api_trace (coro_current, 0); 2199 api_trace (coro_current, 0);
1966 2200
1967 av_push (av_async_pool, newSVsv (coro_current)); 2201 av_push (av_async_pool, newSVsv (coro_current));
1968} 2202}
1969 2203
2204#if 0
2205
2206void
2207_generator_call (...)
2208 PROTOTYPE: @
2209 PPCODE:
2210 fprintf (stderr, "call %p\n", CvXSUBANY(cv).any_ptr);
2211 xxxx
2212 abort ();
2213
2214SV *
2215gensub (SV *sub, ...)
2216 PROTOTYPE: &;@
2217 CODE:
2218{
2219 struct coro *coro;
2220 MAGIC *mg;
2221 CV *xcv;
2222 CV *ncv = (CV *)newSV_type (SVt_PVCV);
2223 int i;
2224
2225 CvGV (ncv) = CvGV (cv);
2226 CvFILE (ncv) = CvFILE (cv);
2227
2228 Newz (0, coro, 1, struct coro);
2229 coro->args = newAV ();
2230 coro->flags = CF_NEW;
2231
2232 av_extend (coro->args, items - 1);
2233 for (i = 1; i < items; i++)
2234 av_push (coro->args, newSVsv (ST (i)));
2235
2236 CvISXSUB_on (ncv);
2237 CvXSUBANY (ncv).any_ptr = (void *)coro;
2238
2239 xcv = GvCV (gv_fetchpv ("Coro::_generator_call", 0, SVt_PVCV));
2240
2241 CvXSUB (ncv) = CvXSUB (xcv);
2242 CvANON_on (ncv);
2243
2244 mg = sv_magicext ((SV *)ncv, 0, CORO_MAGIC_type_state, &coro_gensub_vtbl, (char *)coro, 0);
2245 RETVAL = newRV_noinc ((SV *)ncv);
2246}
2247 OUTPUT:
2248 RETVAL
2249
2250#endif
2251
1970 2252
1971MODULE = Coro::State PACKAGE = Coro::AIO 2253MODULE = Coro::State PACKAGE = Coro::AIO
1972 2254
1973SV * 2255void
1974_get_state () 2256_get_state (SV *self)
1975 CODE: 2257 PPCODE:
1976{ 2258{
1977 struct io_state *data; 2259 AV *defav = GvAV (PL_defgv);
1978 2260 AV *av = newAV ();
2261 int i;
1979 RETVAL = newSV (sizeof (struct io_state)); 2262 SV *data_sv = newSV (sizeof (struct io_state));
1980 data = (struct io_state *)SvPVX (RETVAL); 2263 struct io_state *data = (struct io_state *)SvPVX (data_sv);
1981 SvCUR_set (RETVAL, sizeof (struct io_state)); 2264 SvCUR_set (data_sv, sizeof (struct io_state));
1982 SvPOK_only (RETVAL); 2265 SvPOK_only (data_sv);
1983 2266
1984 data->errorno = errno; 2267 data->errorno = errno;
1985 data->laststype = PL_laststype; 2268 data->laststype = PL_laststype;
1986 data->laststatval = PL_laststatval; 2269 data->laststatval = PL_laststatval;
1987 data->statcache = PL_statcache; 2270 data->statcache = PL_statcache;
2271
2272 av_extend (av, AvFILLp (defav) + 1 + 1);
2273
2274 for (i = 0; i <= AvFILLp (defav); ++i)
2275 av_push (av, SvREFCNT_inc_NN (AvARRAY (defav)[i]));
2276
2277 av_push (av, data_sv);
2278
2279 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
2280
2281 api_ready (self);
1988} 2282}
1989 OUTPUT:
1990 RETVAL
1991 2283
1992void 2284void
1993_set_state (char *data_) 2285_set_state (SV *state)
1994 PROTOTYPE: $ 2286 PROTOTYPE: $
1995 CODE: 2287 PPCODE:
1996{ 2288{
1997 struct io_state *data = (void *)data_; 2289 AV *av = (AV *)SvRV (state);
2290 struct io_state *data = (struct io_state *)SvPVX (AvARRAY (av)[AvFILLp (av)]);
2291 int i;
1998 2292
1999 errno = data->errorno; 2293 errno = data->errorno;
2000 PL_laststype = data->laststype; 2294 PL_laststype = data->laststype;
2001 PL_laststatval = data->laststatval; 2295 PL_laststatval = data->laststatval;
2002 PL_statcache = data->statcache; 2296 PL_statcache = data->statcache;
2003}
2004 2297
2298 EXTEND (SP, AvFILLp (av));
2299 for (i = 0; i < AvFILLp (av); ++i)
2300 PUSHs (sv_2mortal (SvREFCNT_inc_NN (AvARRAY (av)[i])));
2301}
2302
2303
2304MODULE = Coro::State PACKAGE = Coro::AnyEvent
2305
2306BOOT:
2307 sv_activity = coro_get_sv (aTHX_ "Coro::AnyEvent::ACTIVITY", TRUE);
2308
2309SV *
2310_schedule (...)
2311 PROTOTYPE: @
2312 CODE:
2313{
2314 static int incede;
2315
2316 api_cede_notself ();
2317
2318 ++incede;
2319 while (coro_nready >= incede && api_cede ())
2320 ;
2321
2322 sv_setsv (sv_activity, &PL_sv_undef);
2323 if (coro_nready >= incede)
2324 {
2325 PUSHMARK (SP);
2326 PUTBACK;
2327 call_pv ("Coro::AnyEvent::_activity", G_DISCARD | G_EVAL);
2328 SPAGAIN;
2329 }
2330
2331 --incede;
2332}
2333
2334
2335MODULE = Coro::State PACKAGE = PerlIO::cede
2336
2337BOOT:
2338 PerlIO_define_layer (aTHX_ &PerlIO_cede);

Diff Legend

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