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

Diff Legend

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