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.3 by root, Tue Jul 17 00:24:15 2001 UTC vs.
Revision 1.312 by root, Thu Nov 20 03:10:30 2008 UTC

1#include "libcoro/coro.c"
2
3#define PERL_NO_GET_CONTEXT
4#define PERL_EXT
5
1#include "EXTERN.h" 6#include "EXTERN.h"
2#include "perl.h" 7#include "perl.h"
3#include "XSUB.h" 8#include "XSUB.h"
9#include "perliol.h"
4 10
5#if 0 11#include "patchlevel.h"
6# define CHK(x) (void *)0 12
13#include <stdio.h>
14#include <errno.h>
15#include <assert.h>
16
17#ifdef WIN32
18# undef setjmp
19# undef longjmp
20# undef _exit
21# define setjmp _setjmp /* deep magic */
7#else 22#else
8# define CHK(x) if (!(x)) croak("FATAL, CHK: " #x) 23# include <inttypes.h> /* most portable stdint.h */
9#endif 24#endif
10 25
26#ifdef HAVE_MMAP
27# include <unistd.h>
28# include <sys/mman.h>
29# ifndef MAP_ANONYMOUS
30# ifdef MAP_ANON
31# define MAP_ANONYMOUS MAP_ANON
32# else
33# undef HAVE_MMAP
34# endif
35# endif
36# include <limits.h>
37# ifndef PAGESIZE
38# define PAGESIZE pagesize
39# define BOOT_PAGESIZE pagesize = sysconf (_SC_PAGESIZE)
40static long pagesize;
41# else
42# define BOOT_PAGESIZE (void)0
43# endif
44#else
45# define PAGESIZE 0
46# define BOOT_PAGESIZE (void)0
47#endif
48
49#if CORO_USE_VALGRIND
50# include <valgrind/valgrind.h>
51#endif
52
53/* the maximum number of idle cctx that will be pooled */
54static int cctx_max_idle = 4;
55
56#define PERL_VERSION_ATLEAST(a,b,c) \
57 (PERL_REVISION > (a) \
58 || (PERL_REVISION == (a) \
59 && (PERL_VERSION > (b) \
60 || (PERL_VERSION == (b) && PERL_SUBVERSION >= (c)))))
61
62#if !PERL_VERSION_ATLEAST (5,6,0)
63# ifndef PL_ppaddr
64# define PL_ppaddr ppaddr
65# endif
66# ifndef call_sv
67# define call_sv perl_call_sv
68# endif
69# ifndef get_sv
70# define get_sv perl_get_sv
71# endif
72# ifndef get_cv
73# define get_cv perl_get_cv
74# endif
75# ifndef IS_PADGV
76# define IS_PADGV(v) 0
77# endif
78# ifndef IS_PADCONST
79# define IS_PADCONST(v) 0
80# endif
81#endif
82
83/* 5.11 */
84#ifndef CxHASARGS
85# define CxHASARGS(cx) (cx)->blk_sub.hasargs
86#endif
87
88/* 5.10.0 */
89#ifndef SvREFCNT_inc_NN
90# define SvREFCNT_inc_NN(sv) SvREFCNT_inc (sv)
91#endif
92
93/* 5.8.8 */
94#ifndef GV_NOTQUAL
95# define GV_NOTQUAL 0
96#endif
97#ifndef newSV
98# define newSV(l) NEWSV(0,l)
99#endif
100#ifndef CvISXSUB_on
101# define CvISXSUB_on(cv) (void)cv
102#endif
103
104/* 5.8.7 */
105#ifndef SvRV_set
106# define SvRV_set(s,v) SvRV(s) = (v)
107#endif
108
109#if !__i386 && !__x86_64 && !__powerpc && !__m68k && !__alpha && !__mips && !__sparc64
110# undef CORO_STACKGUARD
111#endif
112
113#ifndef CORO_STACKGUARD
114# define CORO_STACKGUARD 0
115#endif
116
117/* prefer perl internal functions over our own? */
118#ifndef CORO_PREFER_PERL_FUNCTIONS
119# define CORO_PREFER_PERL_FUNCTIONS 0
120#endif
121
122/* The next macros try to return the current stack pointer, in an as
123 * portable way as possible. */
124#if __GNUC__ >= 4
125# define dSTACKLEVEL int stacklevel_dummy
126# define STACKLEVEL __builtin_frame_address (0)
127#else
128# define dSTACKLEVEL volatile void *stacklevel
129# define STACKLEVEL ((void *)&stacklevel)
130#endif
131
132#define IN_DESTRUCT (PL_main_cv == Nullcv)
133
134#if __GNUC__ >= 3
135# define attribute(x) __attribute__(x)
136# define expect(expr,value) __builtin_expect ((expr),(value))
137# define INLINE static inline
138#else
139# define attribute(x)
140# define expect(expr,value) (expr)
141# define INLINE static
142#endif
143
144#define expect_false(expr) expect ((expr) != 0, 0)
145#define expect_true(expr) expect ((expr) != 0, 1)
146
147#define NOINLINE attribute ((noinline))
148
149#include "CoroAPI.h"
150#define GCoroAPI (&coroapi) /* very sneaky */
151
152#ifdef USE_ITHREADS
153# if CORO_PTHREAD
154static void *coro_thx;
155# endif
156#endif
157
158static double (*nvtime)(); /* so why doesn't it take void? */
159
160/* we hijack an hopefully unused CV flag for our purposes */
161#define CVf_SLF 0x4000
162static OP *pp_slf (pTHX);
163
164static U32 cctx_gen;
165static size_t cctx_stacksize = CORO_STACKSIZE;
166static struct CoroAPI coroapi;
167static AV *main_mainstack; /* used to differentiate between $main and others */
168static JMPENV *main_top_env;
169static HV *coro_state_stash, *coro_stash;
170static volatile SV *coro_mortal; /* will be freed/thrown after next transfer */
171
172static GV *irsgv; /* $/ */
173static GV *stdoutgv; /* *STDOUT */
174static SV *rv_diehook;
175static SV *rv_warnhook;
176static HV *hv_sig; /* %SIG */
177
178/* async_pool helper stuff */
179static SV *sv_pool_rss;
180static SV *sv_pool_size;
181static SV *sv_async_pool_idle;
182static AV *av_async_pool;
183static SV *sv_Coro;
184static CV *cv_pool_handler;
185static CV *cv_coro_new;
186
187/* Coro::AnyEvent */
188static SV *sv_activity;
189
190static struct coro_cctx *cctx_first;
191static int cctx_count, cctx_idle;
192
193enum {
194 CC_MAPPED = 0x01,
195 CC_NOREUSE = 0x02, /* throw this away after tracing */
196 CC_TRACE = 0x04,
197 CC_TRACE_SUB = 0x08, /* trace sub calls */
198 CC_TRACE_LINE = 0x10, /* trace each statement */
199 CC_TRACE_ALL = CC_TRACE_SUB | CC_TRACE_LINE,
200};
201
202/* this is a structure representing a c-level coroutine */
203typedef struct coro_cctx
204{
205 struct coro_cctx *next;
206
207 /* the stack */
208 void *sptr;
209 size_t ssize;
210
211 /* cpu state */
212 void *idle_sp; /* sp of top-level transfer/schedule/cede call */
213 JMPENV *idle_te; /* same as idle_sp, but for top_env, TODO: remove once stable */
214 JMPENV *top_env;
215 coro_context cctx;
216
217 U32 gen;
218#if CORO_USE_VALGRIND
219 int valgrind_id;
220#endif
221 unsigned char flags;
222} coro_cctx;
223
224enum {
225 CF_RUNNING = 0x0001, /* coroutine is running */
226 CF_READY = 0x0002, /* coroutine is ready */
227 CF_NEW = 0x0004, /* has never been switched to */
228 CF_DESTROYED = 0x0008, /* coroutine data has been freed */
229};
230
231/* the structure where most of the perl state is stored, overlaid on the cxstack */
232typedef struct
233{
234 SV *defsv;
235 AV *defav;
236 SV *errsv;
237 SV *irsgv;
238#define VAR(name,type) type name;
239# include "state.h"
240#undef VAR
241} perl_slots;
242
243#define SLOT_COUNT ((sizeof (perl_slots) + sizeof (PERL_CONTEXT) - 1) / sizeof (PERL_CONTEXT))
244
245/* this is a structure representing a perl-level coroutine */
11struct coro { 246struct coro {
12 U8 dowarn; 247 /* the C coroutine allocated to this perl coroutine, if any */
13 AV *defav; 248 coro_cctx *cctx;
14 249
15 PERL_SI *curstackinfo; 250 /* state data */
16 AV *curstack; 251 struct CoroSLF slf_frame; /* saved slf frame */
17 AV *mainstack; 252 AV *mainstack;
18 SV **stack_sp; 253 perl_slots *slot; /* basically the saved sp */
19 OP *op;
20 SV **curpad;
21 SV **stack_base;
22 SV **stack_max;
23 SV **tmps_stack;
24 I32 tmps_floor;
25 I32 tmps_ix;
26 I32 tmps_max;
27 I32 *markstack;
28 I32 *markstack_ptr;
29 I32 *markstack_max;
30 I32 *scopestack;
31 I32 scopestack_ix;
32 I32 scopestack_max;
33 ANY *savestack;
34 I32 savestack_ix;
35 I32 savestack_max;
36 OP **retstack;
37 I32 retstack_ix;
38 I32 retstack_max;
39 COP *curcop;
40 254
41 AV *args; 255 CV *startcv; /* the CV to execute */
256 AV *args; /* data associated with this coroutine (initial args) */
257 int refcnt; /* coroutines are refcounted, yes */
258 int flags; /* CF_ flags */
259 HV *hv; /* the perl hash associated with this coro, if any */
260 void (*on_destroy)(pTHX_ struct coro *coro);
261
262 /* statistics */
263 int usecount; /* number of transfers to this coro */
264
265 /* coro process data */
266 int prio;
267 SV *except; /* exception to be thrown */
268 SV *rouse_cb;
269
270 /* async_pool */
271 SV *saved_deffh;
272 SV *invoke_cb;
273 AV *invoke_av;
274
275 /* linked list */
276 struct coro *next, *prev;
42}; 277};
43 278
44typedef struct coro *Coro__State; 279typedef struct coro *Coro__State;
45typedef struct coro *Coro__State_or_hashref; 280typedef struct coro *Coro__State_or_hashref;
46 281
47static HV *padlist_cache; 282/* the following variables are effectively part of the perl context */
283/* and get copied between struct coro and these variables */
284/* the mainr easonw e don't support windows process emulation */
285static struct CoroSLF slf_frame; /* the current slf frame */
48 286
49/* mostly copied from op.c:cv_clone2 */ 287/** Coro ********************************************************************/
50STATIC AV * 288
51clone_padlist (AV *protopadlist) 289#define PRIO_MAX 3
290#define PRIO_HIGH 1
291#define PRIO_NORMAL 0
292#define PRIO_LOW -1
293#define PRIO_IDLE -3
294#define PRIO_MIN -4
295
296/* for Coro.pm */
297static SV *coro_current;
298static SV *coro_readyhook;
299static AV *coro_ready [PRIO_MAX - PRIO_MIN + 1];
300static CV *cv_coro_run, *cv_coro_terminate;
301static struct coro *coro_first;
302#define coro_nready coroapi.nready
303
304/** lowlevel stuff **********************************************************/
305
306static SV *
307coro_get_sv (pTHX_ const char *name, int create)
52{ 308{
53 AV *av; 309#if PERL_VERSION_ATLEAST (5,10,0)
54 I32 ix; 310 /* silence stupid and wrong 5.10 warning that I am unable to switch off */
55 AV *protopad_name = (AV *) * av_fetch (protopadlist, 0, FALSE); 311 get_sv (name, create);
56 AV *protopad = (AV *) * av_fetch (protopadlist, 1, FALSE); 312#endif
57 SV **pname = AvARRAY (protopad_name); 313 return get_sv (name, create);
58 SV **ppad = AvARRAY (protopad); 314}
59 I32 fname = AvFILLp (protopad_name); 315
60 I32 fpad = AvFILLp (protopad); 316static AV *
317coro_get_av (pTHX_ const char *name, int create)
318{
319#if PERL_VERSION_ATLEAST (5,10,0)
320 /* silence stupid and wrong 5.10 warning that I am unable to switch off */
321 get_av (name, create);
322#endif
323 return get_av (name, create);
324}
325
326static HV *
327coro_get_hv (pTHX_ const char *name, int create)
328{
329#if PERL_VERSION_ATLEAST (5,10,0)
330 /* silence stupid and wrong 5.10 warning that I am unable to switch off */
331 get_hv (name, create);
332#endif
333 return get_hv (name, create);
334}
335
336/* may croak */
337INLINE CV *
338coro_sv_2cv (pTHX_ SV *sv)
339{
340 HV *st;
341 GV *gvp;
342 return sv_2cv (sv, &st, &gvp, 0);
343}
344
345static AV *
346coro_clone_padlist (pTHX_ CV *cv)
347{
348 AV *padlist = CvPADLIST (cv);
61 AV *newpadlist, *newpad_name, *newpad; 349 AV *newpadlist, *newpad;
62 SV **npad;
63
64 newpad_name = newAV ();
65 for (ix = fname; ix >= 0; ix--)
66 av_store (newpad_name, ix, SvREFCNT_inc (pname[ix]));
67
68 newpad = newAV ();
69 av_fill (newpad, AvFILLp (protopad));
70 npad = AvARRAY (newpad);
71 350
72 newpadlist = newAV (); 351 newpadlist = newAV ();
73 AvREAL_off (newpadlist); 352 AvREAL_off (newpadlist);
74 av_store (newpadlist, 0, (SV *) newpad_name); 353#if PERL_VERSION_ATLEAST (5,10,0)
354 Perl_pad_push (aTHX_ padlist, AvFILLp (padlist) + 1);
355#else
356 Perl_pad_push (aTHX_ padlist, AvFILLp (padlist) + 1, 1);
357#endif
358 newpad = (AV *)AvARRAY (padlist)[AvFILLp (padlist)];
359 --AvFILLp (padlist);
360
361 av_store (newpadlist, 0, SvREFCNT_inc_NN (*av_fetch (padlist, 0, FALSE)));
75 av_store (newpadlist, 1, (SV *) newpad); 362 av_store (newpadlist, 1, (SV *)newpad);
76 363
77 av = newAV (); /* will be @_ */ 364 return newpadlist;
78 av_extend (av, 0); 365}
79 av_store (newpad, 0, (SV *) av);
80 AvFLAGS (av) = AVf_REIFY;
81 366
82 for (ix = fpad; ix > 0; ix--) 367static void
368free_padlist (pTHX_ AV *padlist)
369{
370 /* may be during global destruction */
371 if (SvREFCNT (padlist))
83 { 372 {
84 SV *namesv = (ix <= fname) ? pname[ix] : Nullsv; 373 I32 i = AvFILLp (padlist);
85 if (namesv && namesv != &PL_sv_undef) 374 while (i >= 0)
86 { 375 {
87 char *name = SvPVX (namesv); /* XXX */ 376 SV **svp = av_fetch (padlist, i--, FALSE);
88 if (SvFLAGS (namesv) & SVf_FAKE || *name == '&') 377 if (svp)
89 { /* lexical from outside? */
90 npad[ix] = SvREFCNT_inc (ppad[ix]);
91 } 378 {
92 else
93 { /* our own lexical */
94 SV *sv; 379 SV *sv;
95 if (*name == '&') 380 while (&PL_sv_undef != (sv = av_pop ((AV *)*svp)))
96 sv = SvREFCNT_inc (ppad[ix]); 381 SvREFCNT_dec (sv);
97 else if (*name == '@') 382
98 sv = (SV *) newAV (); 383 SvREFCNT_dec (*svp);
99 else if (*name == '%')
100 sv = (SV *) newHV ();
101 else
102 sv = NEWSV (0, 0);
103 if (!SvPADBUSY (sv))
104 SvPADMY_on (sv);
105 npad[ix] = sv;
106 } 384 }
107 } 385 }
108 else if (IS_PADGV (ppad[ix]) || IS_PADCONST (ppad[ix])) 386
109 { 387 SvREFCNT_dec ((SV*)padlist);
110 npad[ix] = SvREFCNT_inc (ppad[ix]); 388 }
111 } 389}
112 else 390
113 { 391static int
114 SV *sv = NEWSV (0, 0); 392coro_cv_free (pTHX_ SV *sv, MAGIC *mg)
115 SvPADTMP_on (sv); 393{
116 npad[ix] = sv; 394 AV *padlist;
117 } 395 AV *av = (AV *)mg->mg_obj;
396
397 /* casting is fun. */
398 while (&PL_sv_undef != (SV *)(padlist = (AV *)av_pop (av)))
399 free_padlist (aTHX_ padlist);
400
401 SvREFCNT_dec (av); /* sv_magicext increased the refcount */
402
403 return 0;
404}
405
406#define CORO_MAGIC_type_cv 26
407#define CORO_MAGIC_type_state PERL_MAGIC_ext
408
409static MGVTBL coro_cv_vtbl = {
410 0, 0, 0, 0,
411 coro_cv_free
412};
413
414#define CORO_MAGIC_NN(sv, type) \
415 (expect_true (SvMAGIC (sv)->mg_type == type) \
416 ? SvMAGIC (sv) \
417 : mg_find (sv, type))
418
419#define CORO_MAGIC(sv, type) \
420 (expect_true (SvMAGIC (sv)) \
421 ? CORO_MAGIC_NN (sv, type) \
422 : 0)
423
424#define CORO_MAGIC_cv(cv) CORO_MAGIC (((SV *)(cv)), CORO_MAGIC_type_cv)
425#define CORO_MAGIC_state(sv) CORO_MAGIC_NN (((SV *)(sv)), CORO_MAGIC_type_state)
426
427INLINE struct coro *
428SvSTATE_ (pTHX_ SV *coro)
429{
430 HV *stash;
431 MAGIC *mg;
432
433 if (SvROK (coro))
434 coro = SvRV (coro);
435
436 if (expect_false (SvTYPE (coro) != SVt_PVHV))
437 croak ("Coro::State object required");
438
439 stash = SvSTASH (coro);
440 if (expect_false (stash != coro_stash && stash != coro_state_stash))
118 } 441 {
119 442 /* very slow, but rare, check */
120#if 0 /* NONOTUNDERSTOOD */ 443 if (!sv_derived_from (sv_2mortal (newRV_inc (coro)), "Coro::State"))
121 /* Now that vars are all in place, clone nested closures. */ 444 croak ("Coro::State object required");
122
123 for (ix = fpad; ix > 0; ix--) {
124 SV* namesv = (ix <= fname) ? pname[ix] : Nullsv;
125 if (namesv
126 && namesv != &PL_sv_undef
127 && !(SvFLAGS(namesv) & SVf_FAKE)
128 && *SvPVX(namesv) == '&'
129 && CvCLONE(ppad[ix]))
130 {
131 CV *kid = cv_clone((CV*)ppad[ix]);
132 SvREFCNT_dec(ppad[ix]);
133 CvCLONE_on(kid);
134 SvPADMY_on(kid);
135 npad[ix] = (SV*)kid;
136 }
137 } 445 }
446
447 mg = CORO_MAGIC_state (coro);
448 return (struct coro *)mg->mg_ptr;
449}
450
451#define SvSTATE(sv) SvSTATE_ (aTHX_ (sv))
452
453/* faster than SvSTATE, but expects a coroutine hv */
454#define SvSTATE_hv(hv) ((struct coro *)CORO_MAGIC_NN ((SV *)hv, CORO_MAGIC_type_state)->mg_ptr)
455#define SvSTATE_current SvSTATE_hv (SvRV (coro_current))
456
457/* the next two functions merely cache the padlists */
458static void
459get_padlist (pTHX_ CV *cv)
460{
461 MAGIC *mg = CORO_MAGIC_cv (cv);
462 AV *av;
463
464 if (expect_true (mg && AvFILLp ((av = (AV *)mg->mg_obj)) >= 0))
465 CvPADLIST (cv) = (AV *)AvARRAY (av)[AvFILLp (av)--];
466 else
467 {
468#if CORO_PREFER_PERL_FUNCTIONS
469 /* this is probably cleaner? but also slower! */
470 /* in practise, it seems to be less stable */
471 CV *cp = Perl_cv_clone (aTHX_ cv);
472 CvPADLIST (cv) = CvPADLIST (cp);
473 CvPADLIST (cp) = 0;
474 SvREFCNT_dec (cp);
475#else
476 CvPADLIST (cv) = coro_clone_padlist (aTHX_ cv);
138#endif 477#endif
139 478 }
140 return newpadlist;
141} 479}
142 480
143STATIC AV * 481static void
144free_padlist (AV *padlist) 482put_padlist (pTHX_ CV *cv)
145{ 483{
146 /* may be during global destruction */ 484 MAGIC *mg = CORO_MAGIC_cv (cv);
147 if (SvREFCNT(padlist)) 485 AV *av;
486
487 if (expect_false (!mg))
488 mg = sv_magicext ((SV *)cv, (SV *)newAV (), CORO_MAGIC_type_cv, &coro_cv_vtbl, 0, 0);
489
490 av = (AV *)mg->mg_obj;
491
492 if (expect_false (AvFILLp (av) >= AvMAX (av)))
493 av_extend (av, AvMAX (av) + 1);
494
495 AvARRAY (av)[++AvFILLp (av)] = (SV *)CvPADLIST (cv);
496}
497
498/** load & save, init *******************************************************/
499
500static void
501load_perl (pTHX_ Coro__State c)
502{
503 perl_slots *slot = c->slot;
504 c->slot = 0;
505
506 PL_mainstack = c->mainstack;
507
508 GvSV (PL_defgv) = slot->defsv;
509 GvAV (PL_defgv) = slot->defav;
510 GvSV (PL_errgv) = slot->errsv;
511 GvSV (irsgv) = slot->irsgv;
512
513 #define VAR(name,type) PL_ ## name = slot->name;
514 # include "state.h"
515 #undef VAR
516
148 { 517 {
149 I32 i = AvFILLp(padlist); 518 dSP;
150 while (i >= 0) 519
520 CV *cv;
521
522 /* now do the ugly restore mess */
523 while (expect_true (cv = (CV *)POPs))
151 { 524 {
152 SV **svp = av_fetch(padlist, i--, FALSE); 525 put_padlist (aTHX_ cv); /* mark this padlist as available */
153 SV *sv = svp ? *svp : Nullsv; 526 CvDEPTH (cv) = PTR2IV (POPs);
154 if (sv) 527 CvPADLIST (cv) = (AV *)POPs;
155 SvREFCNT_dec(sv);
156 } 528 }
157 529
158 SvREFCNT_dec((SV*)padlist); 530 PUTBACK;
159 } 531 }
160}
161 532
162STATIC AV * 533 slf_frame = c->slf_frame;
163unuse_padlist (AV *padlist) 534 CORO_THROW = c->except;
164{
165 free_padlist (padlist);
166} 535}
167 536
168static void 537static void
169SAVE(pTHX_ Coro__State c) 538save_perl (pTHX_ Coro__State c)
170{ 539{
540 c->except = CORO_THROW;
541 c->slf_frame = slf_frame;
542
171 { 543 {
172 dSP; 544 dSP;
173 I32 cxix = cxstack_ix; 545 I32 cxix = cxstack_ix;
546 PERL_CONTEXT *ccstk = cxstack;
174 PERL_SI *top_si = PL_curstackinfo; 547 PERL_SI *top_si = PL_curstackinfo;
175 PERL_CONTEXT *ccstk = cxstack;
176 548
177 /* 549 /*
178 * the worst thing you can imagine happens first - we have to save 550 * the worst thing you can imagine happens first - we have to save
179 * (and reinitialize) all cv's in the whole callchain :( 551 * (and reinitialize) all cv's in the whole callchain :(
180 */ 552 */
181 553
182 PUSHs (Nullsv); 554 XPUSHs (Nullsv);
183 /* this loop was inspired by pp_caller */ 555 /* this loop was inspired by pp_caller */
184 for (;;) 556 for (;;)
185 { 557 {
186 while (cxix >= 0) 558 while (expect_true (cxix >= 0))
187 { 559 {
188 PERL_CONTEXT *cx = &ccstk[--cxix]; 560 PERL_CONTEXT *cx = &ccstk[cxix--];
189 561
190 if (CxTYPE(cx) == CXt_SUB) 562 if (expect_true (CxTYPE (cx) == CXt_SUB || CxTYPE (cx) == CXt_FORMAT))
191 { 563 {
192 CV *cv = cx->blk_sub.cv; 564 CV *cv = cx->blk_sub.cv;
565
193 if (CvDEPTH(cv)) 566 if (expect_true (CvDEPTH (cv)))
194 { 567 {
195#ifdef USE_THREADS
196 XPUSHs ((SV *)CvOWNER(cv));
197#endif
198 EXTEND (SP, 3); 568 EXTEND (SP, 3);
199 PUSHs ((SV *)CvDEPTH(cv));
200 PUSHs ((SV *)CvPADLIST(cv)); 569 PUSHs ((SV *)CvPADLIST (cv));
570 PUSHs (INT2PTR (SV *, (IV)CvDEPTH (cv)));
201 PUSHs ((SV *)cv); 571 PUSHs ((SV *)cv);
202 572
203 CvPADLIST(cv) = clone_padlist (CvPADLIST(cv));
204
205 CvDEPTH(cv) = 0; 573 CvDEPTH (cv) = 0;
206#ifdef USE_THREADS 574 get_padlist (aTHX_ cv);
207 CvOWNER(cv) = 0;
208 error must unlock this cv etc.. etc...
209 if you are here wondering about this error message then
210 the reason is that it will not work as advertised yet
211#endif
212 } 575 }
213 } 576 }
214 else if (CxTYPE(cx) == CXt_FORMAT) 577 }
578
579 if (expect_true (top_si->si_type == PERLSI_MAIN))
580 break;
581
582 top_si = top_si->si_prev;
583 ccstk = top_si->si_cxstack;
584 cxix = top_si->si_cxix;
585 }
586
587 PUTBACK;
588 }
589
590 /* allocate some space on the context stack for our purposes */
591 /* we manually unroll here, as usually 2 slots is enough */
592 if (SLOT_COUNT >= 1) CXINC;
593 if (SLOT_COUNT >= 2) CXINC;
594 if (SLOT_COUNT >= 3) CXINC;
595 {
596 int i;
597 for (i = 3; i < SLOT_COUNT; ++i)
598 CXINC;
599 }
600 cxstack_ix -= SLOT_COUNT; /* undo allocation */
601
602 c->mainstack = PL_mainstack;
603
604 {
605 perl_slots *slot = c->slot = (perl_slots *)(cxstack + cxstack_ix + 1);
606
607 slot->defav = GvAV (PL_defgv);
608 slot->defsv = DEFSV;
609 slot->errsv = ERRSV;
610 slot->irsgv = GvSV (irsgv);
611
612 #define VAR(name,type) slot->name = PL_ ## name;
613 # include "state.h"
614 #undef VAR
615 }
616}
617
618/*
619 * allocate various perl stacks. This is almost an exact copy
620 * of perl.c:init_stacks, except that it uses less memory
621 * on the (sometimes correct) assumption that coroutines do
622 * not usually need a lot of stackspace.
623 */
624#if CORO_PREFER_PERL_FUNCTIONS
625# define coro_init_stacks(thx) init_stacks ()
626#else
627static void
628coro_init_stacks (pTHX)
629{
630 PL_curstackinfo = new_stackinfo(32, 8);
631 PL_curstackinfo->si_type = PERLSI_MAIN;
632 PL_curstack = PL_curstackinfo->si_stack;
633 PL_mainstack = PL_curstack; /* remember in case we switch stacks */
634
635 PL_stack_base = AvARRAY(PL_curstack);
636 PL_stack_sp = PL_stack_base;
637 PL_stack_max = PL_stack_base + AvMAX(PL_curstack);
638
639 New(50,PL_tmps_stack,32,SV*);
640 PL_tmps_floor = -1;
641 PL_tmps_ix = -1;
642 PL_tmps_max = 32;
643
644 New(54,PL_markstack,16,I32);
645 PL_markstack_ptr = PL_markstack;
646 PL_markstack_max = PL_markstack + 16;
647
648#ifdef SET_MARK_OFFSET
649 SET_MARK_OFFSET;
650#endif
651
652 New(54,PL_scopestack,8,I32);
653 PL_scopestack_ix = 0;
654 PL_scopestack_max = 8;
655
656 New(54,PL_savestack,24,ANY);
657 PL_savestack_ix = 0;
658 PL_savestack_max = 24;
659
660#if !PERL_VERSION_ATLEAST (5,10,0)
661 New(54,PL_retstack,4,OP*);
662 PL_retstack_ix = 0;
663 PL_retstack_max = 4;
664#endif
665}
666#endif
667
668/*
669 * destroy the stacks, the callchain etc...
670 */
671static void
672coro_destruct_stacks (pTHX)
673{
674 while (PL_curstackinfo->si_next)
675 PL_curstackinfo = PL_curstackinfo->si_next;
676
677 while (PL_curstackinfo)
678 {
679 PERL_SI *p = PL_curstackinfo->si_prev;
680
681 if (!IN_DESTRUCT)
682 SvREFCNT_dec (PL_curstackinfo->si_stack);
683
684 Safefree (PL_curstackinfo->si_cxstack);
685 Safefree (PL_curstackinfo);
686 PL_curstackinfo = p;
687 }
688
689 Safefree (PL_tmps_stack);
690 Safefree (PL_markstack);
691 Safefree (PL_scopestack);
692 Safefree (PL_savestack);
693#if !PERL_VERSION_ATLEAST (5,10,0)
694 Safefree (PL_retstack);
695#endif
696}
697
698#define CORO_RSS \
699 rss += sizeof (SYM (curstackinfo)); \
700 rss += (SYM (curstackinfo->si_cxmax) + 1) * sizeof (PERL_CONTEXT); \
701 rss += sizeof (SV) + sizeof (struct xpvav) + (1 + AvMAX (SYM (curstack))) * sizeof (SV *); \
702 rss += SYM (tmps_max) * sizeof (SV *); \
703 rss += (SYM (markstack_max) - SYM (markstack_ptr)) * sizeof (I32); \
704 rss += SYM (scopestack_max) * sizeof (I32); \
705 rss += SYM (savestack_max) * sizeof (ANY);
706
707static size_t
708coro_rss (pTHX_ struct coro *coro)
709{
710 size_t rss = sizeof (*coro);
711
712 if (coro->mainstack)
713 {
714 if (coro->flags & CF_RUNNING)
715 {
716 #define SYM(sym) PL_ ## sym
717 CORO_RSS;
718 #undef SYM
719 }
720 else
721 {
722 #define SYM(sym) coro->slot->sym
723 CORO_RSS;
724 #undef SYM
725 }
726 }
727
728 return rss;
729}
730
731/** coroutine stack handling ************************************************/
732
733static int (*orig_sigelem_get) (pTHX_ SV *sv, MAGIC *mg);
734static int (*orig_sigelem_set) (pTHX_ SV *sv, MAGIC *mg);
735static int (*orig_sigelem_clr) (pTHX_ SV *sv, MAGIC *mg);
736
737/* apparently < 5.8.8 */
738#ifndef MgPV_nolen_const
739#define MgPV_nolen_const(mg) (((((int)(mg)->mg_len)) == HEf_SVKEY) ? \
740 SvPV_nolen((SV*)((mg)->mg_ptr)) : \
741 (const char*)(mg)->mg_ptr)
742#endif
743
744/*
745 * This overrides the default magic get method of %SIG elements.
746 * The original one doesn't provide for reading back of PL_diehook/PL_warnhook
747 * and instead of tryign to save and restore the hash elements, we just provide
748 * readback here.
749 * We only do this when the hook is != 0, as they are often set to 0 temporarily,
750 * not expecting this to actually change the hook. This is a potential problem
751 * when a schedule happens then, but we ignore this.
752 */
753static int
754coro_sigelem_get (pTHX_ SV *sv, MAGIC *mg)
755{
756 const char *s = MgPV_nolen_const (mg);
757
758 if (*s == '_')
759 {
760 SV **svp = 0;
761
762 if (strEQ (s, "__DIE__" )) svp = &PL_diehook;
763 if (strEQ (s, "__WARN__")) svp = &PL_warnhook;
764
765 if (svp)
766 {
767 sv_setsv (sv, *svp ? *svp : &PL_sv_undef);
768 return 0;
769 }
770 }
771
772 return orig_sigelem_get ? orig_sigelem_get (aTHX_ sv, mg) : 0;
773}
774
775static int
776coro_sigelem_clr (pTHX_ SV *sv, MAGIC *mg)
777{
778 const char *s = MgPV_nolen_const (mg);
779
780 if (*s == '_')
781 {
782 SV **svp = 0;
783
784 if (strEQ (s, "__DIE__" )) svp = &PL_diehook;
785 if (strEQ (s, "__WARN__")) svp = &PL_warnhook;
786
787 if (svp)
788 {
789 SV *old = *svp;
790 *svp = 0;
791 SvREFCNT_dec (old);
792 return 0;
793 }
794 }
795
796 return orig_sigelem_clr ? orig_sigelem_clr (aTHX_ sv, mg) : 0;
797}
798
799static int
800coro_sigelem_set (pTHX_ SV *sv, MAGIC *mg)
801{
802 const char *s = MgPV_nolen_const (mg);
803
804 if (*s == '_')
805 {
806 SV **svp = 0;
807
808 if (strEQ (s, "__DIE__" )) svp = &PL_diehook;
809 if (strEQ (s, "__WARN__")) svp = &PL_warnhook;
810
811 if (svp)
812 {
813 SV *old = *svp;
814 *svp = newSVsv (sv);
815 SvREFCNT_dec (old);
816 return 0;
817 }
818 }
819
820 return orig_sigelem_set ? orig_sigelem_set (aTHX_ sv, mg) : 0;
821}
822
823static void
824prepare_nop (pTHX_ struct coro_transfer_args *ta)
825{
826 /* kind of mega-hacky, but works */
827 ta->next = ta->prev = (struct coro *)ta;
828}
829
830static int
831slf_check_nop (pTHX_ struct CoroSLF *frame)
832{
833 return 0;
834}
835
836static UNOP coro_setup_op;
837
838static void NOINLINE /* noinline to keep it out of the transfer fast path */
839coro_setup (pTHX_ struct coro *coro)
840{
841 /*
842 * emulate part of the perl startup here.
843 */
844 coro_init_stacks (aTHX);
845
846 PL_runops = RUNOPS_DEFAULT;
847 PL_curcop = &PL_compiling;
848 PL_in_eval = EVAL_NULL;
849 PL_comppad = 0;
850 PL_curpm = 0;
851 PL_curpad = 0;
852 PL_localizing = 0;
853 PL_dirty = 0;
854 PL_restartop = 0;
855#if PERL_VERSION_ATLEAST (5,10,0)
856 PL_parser = 0;
857#endif
858
859 /* recreate the die/warn hooks */
860 PL_diehook = 0; SvSetMagicSV (*hv_fetch (hv_sig, "__DIE__" , sizeof ("__DIE__" ) - 1, 1), rv_diehook );
861 PL_warnhook = 0; SvSetMagicSV (*hv_fetch (hv_sig, "__WARN__", sizeof ("__WARN__") - 1, 1), rv_warnhook);
862
863 GvSV (PL_defgv) = newSV (0);
864 GvAV (PL_defgv) = coro->args; coro->args = 0;
865 GvSV (PL_errgv) = newSV (0);
866 GvSV (irsgv) = newSVpvn ("\n", 1); sv_magic (GvSV (irsgv), (SV *)irsgv, PERL_MAGIC_sv, "/", 0);
867 PL_rs = newSVsv (GvSV (irsgv));
868 PL_defoutgv = (GV *)SvREFCNT_inc_NN (stdoutgv);
869
870 {
871 dSP;
872 UNOP myop;
873
874 Zero (&myop, 1, UNOP);
875 myop.op_next = Nullop;
876 myop.op_type = OP_ENTERSUB;
877 myop.op_flags = OPf_WANT_VOID;
878
879 PUSHMARK (SP);
880 PUSHs ((SV *)coro->startcv);
881 PUTBACK;
882 PL_op = (OP *)&myop;
883 PL_op = PL_ppaddr[OP_ENTERSUB](aTHX);
884 }
885
886 /* this newly created coroutine might be run on an existing cctx which most
887 * likely was suspended in pp_slf, so we have to emulate entering pp_slf here.
888 */
889 slf_frame.prepare = prepare_nop; /* provide a nop function for an eventual pp_slf */
890 slf_frame.check = slf_check_nop; /* signal pp_slf to not repeat */
891
892 /* and we have to provide the pp_slf op in any case, so pp_slf can skip it */
893 coro_setup_op.op_next = PL_op;
894 coro_setup_op.op_type = OP_CUSTOM;
895 coro_setup_op.op_ppaddr = pp_slf;
896 /* no flags etc. required, as an init function won't be called */
897
898 PL_op = (OP *)&coro_setup_op;
899
900 /* copy throw, in case it was set before coro_setup */
901 CORO_THROW = coro->except;
902}
903
904static void
905coro_destruct (pTHX_ struct coro *coro)
906{
907 if (!IN_DESTRUCT)
908 {
909 /* restore all saved variables and stuff */
910 LEAVE_SCOPE (0);
911 assert (PL_tmps_floor == -1);
912
913 /* free all temporaries */
914 FREETMPS;
915 assert (PL_tmps_ix == -1);
916
917 /* unwind all extra stacks */
918 POPSTACK_TO (PL_mainstack);
919
920 /* unwind main stack */
921 dounwind (-1);
922 }
923
924 SvREFCNT_dec (GvSV (PL_defgv));
925 SvREFCNT_dec (GvAV (PL_defgv));
926 SvREFCNT_dec (GvSV (PL_errgv));
927 SvREFCNT_dec (PL_defoutgv);
928 SvREFCNT_dec (PL_rs);
929 SvREFCNT_dec (GvSV (irsgv));
930
931 SvREFCNT_dec (PL_diehook);
932 SvREFCNT_dec (PL_warnhook);
933
934 SvREFCNT_dec (coro->saved_deffh);
935 SvREFCNT_dec (coro->rouse_cb);
936 SvREFCNT_dec (coro->invoke_cb);
937 SvREFCNT_dec (coro->invoke_av);
938
939 coro_destruct_stacks (aTHX);
940}
941
942INLINE void
943free_coro_mortal (pTHX)
944{
945 if (expect_true (coro_mortal))
946 {
947 SvREFCNT_dec (coro_mortal);
948 coro_mortal = 0;
949 }
950}
951
952static int
953runops_trace (pTHX)
954{
955 COP *oldcop = 0;
956 int oldcxix = -2;
957 struct coro *coro = SvSTATE_current; /* trace cctx is tied to specific coro */
958 coro_cctx *cctx = coro->cctx;
959
960 while ((PL_op = CALL_FPTR (PL_op->op_ppaddr) (aTHX)))
961 {
962 PERL_ASYNC_CHECK ();
963
964 if (cctx->flags & CC_TRACE_ALL)
965 {
966 if (PL_op->op_type == OP_LEAVESUB && cctx->flags & CC_TRACE_SUB)
967 {
968 PERL_CONTEXT *cx = &cxstack[cxstack_ix];
969 SV **bot, **top;
970 AV *av = newAV (); /* return values */
971 SV **cb;
972 dSP;
973
974 GV *gv = CvGV (cx->blk_sub.cv);
975 SV *fullname = sv_2mortal (newSV (0));
976 if (isGV (gv))
977 gv_efullname3 (fullname, gv, 0);
978
979 bot = PL_stack_base + cx->blk_oldsp + 1;
980 top = cx->blk_gimme == G_ARRAY ? SP + 1
981 : cx->blk_gimme == G_SCALAR ? bot + 1
982 : bot;
983
984 av_extend (av, top - bot);
985 while (bot < top)
986 av_push (av, SvREFCNT_inc_NN (*bot++));
987
988 PL_runops = RUNOPS_DEFAULT;
989 ENTER;
990 SAVETMPS;
991 EXTEND (SP, 3);
992 PUSHMARK (SP);
993 PUSHs (&PL_sv_no);
994 PUSHs (fullname);
995 PUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
996 PUTBACK;
997 cb = hv_fetch ((HV *)SvRV (coro_current), "_trace_sub_cb", sizeof ("_trace_sub_cb") - 1, 0);
998 if (cb) call_sv (*cb, G_KEEPERR | G_EVAL | G_VOID | G_DISCARD);
999 SPAGAIN;
1000 FREETMPS;
1001 LEAVE;
1002 PL_runops = runops_trace;
1003 }
1004
1005 if (oldcop != PL_curcop)
1006 {
1007 oldcop = PL_curcop;
1008
1009 if (PL_curcop != &PL_compiling)
1010 {
1011 SV **cb;
1012
1013 if (oldcxix != cxstack_ix && cctx->flags & CC_TRACE_SUB)
1014 {
1015 PERL_CONTEXT *cx = &cxstack[cxstack_ix];
1016
1017 if (CxTYPE (cx) == CXt_SUB && oldcxix < cxstack_ix)
1018 {
1019 runops_proc_t old_runops = PL_runops;
1020 dSP;
1021 GV *gv = CvGV (cx->blk_sub.cv);
1022 SV *fullname = sv_2mortal (newSV (0));
1023
1024 if (isGV (gv))
1025 gv_efullname3 (fullname, gv, 0);
1026
1027 PL_runops = RUNOPS_DEFAULT;
1028 ENTER;
1029 SAVETMPS;
1030 EXTEND (SP, 3);
1031 PUSHMARK (SP);
1032 PUSHs (&PL_sv_yes);
1033 PUSHs (fullname);
1034 PUSHs (CxHASARGS (cx) ? sv_2mortal (newRV_inc ((SV *)cx->blk_sub.argarray)) : &PL_sv_undef);
1035 PUTBACK;
1036 cb = hv_fetch ((HV *)SvRV (coro_current), "_trace_sub_cb", sizeof ("_trace_sub_cb") - 1, 0);
1037 if (cb) call_sv (*cb, G_KEEPERR | G_EVAL | G_VOID | G_DISCARD);
1038 SPAGAIN;
1039 FREETMPS;
1040 LEAVE;
1041 PL_runops = runops_trace;
1042 }
1043
1044 oldcxix = cxstack_ix;
1045 }
1046
1047 if (cctx->flags & CC_TRACE_LINE)
1048 {
1049 dSP;
1050
1051 PL_runops = RUNOPS_DEFAULT;
1052 ENTER;
1053 SAVETMPS;
1054 EXTEND (SP, 3);
1055 PL_runops = RUNOPS_DEFAULT;
1056 PUSHMARK (SP);
1057 PUSHs (sv_2mortal (newSVpv (OutCopFILE (oldcop), 0)));
1058 PUSHs (sv_2mortal (newSViv (CopLINE (oldcop))));
1059 PUTBACK;
1060 cb = hv_fetch ((HV *)SvRV (coro_current), "_trace_line_cb", sizeof ("_trace_line_cb") - 1, 0);
1061 if (cb) call_sv (*cb, G_KEEPERR | G_EVAL | G_VOID | G_DISCARD);
1062 SPAGAIN;
1063 FREETMPS;
1064 LEAVE;
1065 PL_runops = runops_trace;
1066 }
1067 }
1068 }
1069 }
1070 }
1071
1072 TAINT_NOT;
1073 return 0;
1074}
1075
1076static struct coro_cctx *cctx_ssl_cctx;
1077static struct CoroSLF cctx_ssl_frame;
1078
1079static void
1080slf_prepare_set_stacklevel (pTHX_ struct coro_transfer_args *ta)
1081{
1082 ta->prev = (struct coro *)cctx_ssl_cctx;
1083 ta->next = 0;
1084}
1085
1086static int
1087slf_check_set_stacklevel (pTHX_ struct CoroSLF *frame)
1088{
1089 *frame = cctx_ssl_frame;
1090
1091 return frame->check (aTHX_ frame); /* execute the restored frame - there must be one */
1092}
1093
1094/* initialises PL_top_env and injects a pseudo-slf-call to set the stacklevel */
1095static void NOINLINE
1096cctx_prepare (pTHX_ coro_cctx *cctx)
1097{
1098 PL_top_env = &PL_start_env;
1099
1100 if (cctx->flags & CC_TRACE)
1101 PL_runops = runops_trace;
1102
1103 /* we already must be executing an SLF op, there is no other valid way
1104 * that can lead to creation of a new cctx */
1105 assert (("FATAL: can't prepare slf-less cctx in Coro module (please report)",
1106 slf_frame.prepare && PL_op->op_ppaddr == pp_slf));
1107
1108 /* we must emulate leaving pp_slf, which is done inside slf_check_set_stacklevel */
1109 cctx_ssl_cctx = cctx;
1110 cctx_ssl_frame = slf_frame;
1111
1112 slf_frame.prepare = slf_prepare_set_stacklevel;
1113 slf_frame.check = slf_check_set_stacklevel;
1114}
1115
1116/* the tail of transfer: execute stuff we can only do after a transfer */
1117INLINE void
1118transfer_tail (pTHX)
1119{
1120 free_coro_mortal (aTHX);
1121}
1122
1123/*
1124 * this is a _very_ stripped down perl interpreter ;)
1125 */
1126static void
1127cctx_run (void *arg)
1128{
1129#ifdef USE_ITHREADS
1130# if CORO_PTHREAD
1131 PERL_SET_CONTEXT (coro_thx);
1132# endif
1133#endif
1134 {
1135 dTHX;
1136
1137 /* normally we would need to skip the entersub here */
1138 /* not doing so will re-execute it, which is exactly what we want */
1139 /* PL_nop = PL_nop->op_next */
1140
1141 /* inject a fake subroutine call to cctx_init */
1142 cctx_prepare (aTHX_ (coro_cctx *)arg);
1143
1144 /* cctx_run is the alternative tail of transfer() */
1145 transfer_tail (aTHX);
1146
1147 /* somebody or something will hit me for both perl_run and PL_restartop */
1148 PL_restartop = PL_op;
1149 perl_run (PL_curinterp);
1150 /*
1151 * Unfortunately, there is no way to get at the return values of the
1152 * coro body here, as perl_run destroys these
1153 */
1154
1155 /*
1156 * If perl-run returns we assume exit() was being called or the coro
1157 * fell off the end, which seems to be the only valid (non-bug)
1158 * reason for perl_run to return. We try to exit by jumping to the
1159 * bootstrap-time "top" top_env, as we cannot restore the "main"
1160 * coroutine as Coro has no such concept
1161 */
1162 PL_top_env = main_top_env;
1163 JMPENV_JUMP (2); /* I do not feel well about the hardcoded 2 at all */
1164 }
1165}
1166
1167static coro_cctx *
1168cctx_new ()
1169{
1170 coro_cctx *cctx;
1171
1172 ++cctx_count;
1173 New (0, cctx, 1, coro_cctx);
1174
1175 cctx->gen = cctx_gen;
1176 cctx->flags = 0;
1177 cctx->idle_sp = 0; /* can be accessed by transfer between cctx_run and set_stacklevel, on throw */
1178
1179 return cctx;
1180}
1181
1182/* create a new cctx only suitable as source */
1183static coro_cctx *
1184cctx_new_empty ()
1185{
1186 coro_cctx *cctx = cctx_new ();
1187
1188 cctx->sptr = 0;
1189 coro_create (&cctx->cctx, 0, 0, 0, 0);
1190
1191 return cctx;
1192}
1193
1194/* create a new cctx suitable as destination/running a perl interpreter */
1195static coro_cctx *
1196cctx_new_run ()
1197{
1198 coro_cctx *cctx = cctx_new ();
1199 void *stack_start;
1200 size_t stack_size;
1201
1202#if HAVE_MMAP
1203 cctx->ssize = ((cctx_stacksize * sizeof (long) + PAGESIZE - 1) / PAGESIZE + CORO_STACKGUARD) * PAGESIZE;
1204 /* mmap supposedly does allocate-on-write for us */
1205 cctx->sptr = mmap (0, cctx->ssize, PROT_EXEC|PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);
1206
1207 if (cctx->sptr != (void *)-1)
1208 {
1209 #if CORO_STACKGUARD
1210 mprotect (cctx->sptr, CORO_STACKGUARD * PAGESIZE, PROT_NONE);
1211 #endif
1212 stack_start = (char *)cctx->sptr + CORO_STACKGUARD * PAGESIZE;
1213 stack_size = cctx->ssize - CORO_STACKGUARD * PAGESIZE;
1214 cctx->flags |= CC_MAPPED;
1215 }
1216 else
1217#endif
1218 {
1219 cctx->ssize = cctx_stacksize * (long)sizeof (long);
1220 New (0, cctx->sptr, cctx_stacksize, long);
1221
1222 if (!cctx->sptr)
1223 {
1224 perror ("FATAL: unable to allocate stack for coroutine, exiting.");
1225 _exit (EXIT_FAILURE);
1226 }
1227
1228 stack_start = cctx->sptr;
1229 stack_size = cctx->ssize;
1230 }
1231
1232 #if CORO_USE_VALGRIND
1233 cctx->valgrind_id = VALGRIND_STACK_REGISTER ((char *)stack_start, (char *)stack_start + stack_size);
1234 #endif
1235
1236 coro_create (&cctx->cctx, cctx_run, (void *)cctx, stack_start, stack_size);
1237
1238 return cctx;
1239}
1240
1241static void
1242cctx_destroy (coro_cctx *cctx)
1243{
1244 if (!cctx)
1245 return;
1246
1247 --cctx_count;
1248 coro_destroy (&cctx->cctx);
1249
1250 /* coro_transfer creates new, empty cctx's */
1251 if (cctx->sptr)
1252 {
1253 #if CORO_USE_VALGRIND
1254 VALGRIND_STACK_DEREGISTER (cctx->valgrind_id);
1255 #endif
1256
1257#if HAVE_MMAP
1258 if (cctx->flags & CC_MAPPED)
1259 munmap (cctx->sptr, cctx->ssize);
1260 else
1261#endif
1262 Safefree (cctx->sptr);
1263 }
1264
1265 Safefree (cctx);
1266}
1267
1268/* wether this cctx should be destructed */
1269#define CCTX_EXPIRED(cctx) ((cctx)->gen != cctx_gen || ((cctx)->flags & CC_NOREUSE))
1270
1271static coro_cctx *
1272cctx_get (pTHX)
1273{
1274 while (expect_true (cctx_first))
1275 {
1276 coro_cctx *cctx = cctx_first;
1277 cctx_first = cctx->next;
1278 --cctx_idle;
1279
1280 if (expect_true (!CCTX_EXPIRED (cctx)))
1281 return cctx;
1282
1283 cctx_destroy (cctx);
1284 }
1285
1286 return cctx_new_run ();
1287}
1288
1289static void
1290cctx_put (coro_cctx *cctx)
1291{
1292 assert (("FATAL: cctx_put called on non-initialised cctx in Coro (please report)", cctx->sptr));
1293
1294 /* free another cctx if overlimit */
1295 if (expect_false (cctx_idle >= cctx_max_idle))
1296 {
1297 coro_cctx *first = cctx_first;
1298 cctx_first = first->next;
1299 --cctx_idle;
1300
1301 cctx_destroy (first);
1302 }
1303
1304 ++cctx_idle;
1305 cctx->next = cctx_first;
1306 cctx_first = cctx;
1307}
1308
1309/** coroutine switching *****************************************************/
1310
1311static void
1312transfer_check (pTHX_ struct coro *prev, struct coro *next)
1313{
1314 /* TODO: throwing up here is considered harmful */
1315
1316 if (expect_true (prev != next))
1317 {
1318 if (expect_false (!(prev->flags & (CF_RUNNING | CF_NEW))))
1319 croak ("Coro::State::transfer called with non-running/new prev Coro::State, but can only transfer from running or new states,");
1320
1321 if (expect_false (next->flags & CF_RUNNING))
1322 croak ("Coro::State::transfer called with running next Coro::State, but can only transfer to inactive states,");
1323
1324 if (expect_false (next->flags & CF_DESTROYED))
1325 croak ("Coro::State::transfer called with destroyed next Coro::State, but can only transfer to inactive states,");
1326
1327#if !PERL_VERSION_ATLEAST (5,10,0)
1328 if (expect_false (PL_lex_state != LEX_NOTPARSING))
1329 croak ("Coro::State::transfer called while parsing, but this is not supported in your perl version,");
1330#endif
1331 }
1332}
1333
1334/* always use the TRANSFER macro */
1335static void NOINLINE /* noinline so we have a fixed stackframe */
1336transfer (pTHX_ struct coro *prev, struct coro *next, int force_cctx)
1337{
1338 dSTACKLEVEL;
1339
1340 /* sometimes transfer is only called to set idle_sp */
1341 if (expect_false (!next))
1342 {
1343 ((coro_cctx *)prev)->idle_sp = STACKLEVEL;
1344 assert (((coro_cctx *)prev)->idle_te = PL_top_env); /* just for the side-effect when asserts are enabled */
1345 }
1346 else if (expect_true (prev != next))
1347 {
1348 coro_cctx *prev__cctx;
1349
1350 if (expect_false (prev->flags & CF_NEW))
1351 {
1352 /* create a new empty/source context */
1353 prev->cctx = cctx_new_empty ();
1354 prev->flags &= ~CF_NEW;
1355 prev->flags |= CF_RUNNING;
1356 }
1357
1358 prev->flags &= ~CF_RUNNING;
1359 next->flags |= CF_RUNNING;
1360
1361 /* first get rid of the old state */
1362 save_perl (aTHX_ prev);
1363
1364 if (expect_false (next->flags & CF_NEW))
1365 {
1366 /* need to start coroutine */
1367 next->flags &= ~CF_NEW;
1368 /* setup coroutine call */
1369 coro_setup (aTHX_ next);
1370 }
1371 else
1372 load_perl (aTHX_ next);
1373
1374 prev__cctx = prev->cctx;
1375
1376 /* possibly untie and reuse the cctx */
1377 if (expect_true (
1378 prev__cctx->idle_sp == STACKLEVEL
1379 && !(prev__cctx->flags & CC_TRACE)
1380 && !force_cctx
1381 ))
1382 {
1383 /* I assume that stacklevel is a stronger indicator than PL_top_env changes */
1384 assert (("FATAL: current top_env must equal previous top_env in Coro (please report)", PL_top_env == prev__cctx->idle_te));
1385
1386 prev->cctx = 0;
1387
1388 /* if the cctx is about to be destroyed we need to make sure we won't see it in cctx_get */
1389 /* without this the next cctx_get might destroy the prev__cctx while still in use */
1390 if (expect_false (CCTX_EXPIRED (prev__cctx)))
1391 if (!next->cctx)
1392 next->cctx = cctx_get (aTHX);
1393
1394 cctx_put (prev__cctx);
1395 }
1396
1397 ++next->usecount;
1398
1399 if (expect_true (!next->cctx))
1400 next->cctx = cctx_get (aTHX);
1401
1402 if (expect_false (prev__cctx != next->cctx))
1403 {
1404 prev__cctx->top_env = PL_top_env;
1405 PL_top_env = next->cctx->top_env;
1406 coro_transfer (&prev__cctx->cctx, &next->cctx->cctx);
1407 }
1408
1409 transfer_tail (aTHX);
1410 }
1411}
1412
1413#define TRANSFER(ta, force_cctx) transfer (aTHX_ (ta).prev, (ta).next, (force_cctx))
1414#define TRANSFER_CHECK(ta) transfer_check (aTHX_ (ta).prev, (ta).next)
1415
1416/** high level stuff ********************************************************/
1417
1418static int
1419coro_state_destroy (pTHX_ struct coro *coro)
1420{
1421 if (coro->flags & CF_DESTROYED)
1422 return 0;
1423
1424 if (coro->on_destroy)
1425 coro->on_destroy (aTHX_ coro);
1426
1427 coro->flags |= CF_DESTROYED;
1428
1429 if (coro->flags & CF_READY)
1430 {
1431 /* reduce nready, as destroying a ready coro effectively unreadies it */
1432 /* alternative: look through all ready queues and remove the coro */
1433 --coro_nready;
1434 }
1435 else
1436 coro->flags |= CF_READY; /* make sure it is NOT put into the readyqueue */
1437
1438 if (coro->mainstack && coro->mainstack != main_mainstack)
1439 {
1440 struct coro temp;
1441
1442 assert (("FATAL: tried to destroy currently running coroutine (please report)", !(coro->flags & CF_RUNNING)));
1443
1444 save_perl (aTHX_ &temp);
1445 load_perl (aTHX_ coro);
1446
1447 coro_destruct (aTHX_ coro);
1448
1449 load_perl (aTHX_ &temp);
1450
1451 coro->slot = 0;
1452 }
1453
1454 cctx_destroy (coro->cctx);
1455 SvREFCNT_dec (coro->startcv);
1456 SvREFCNT_dec (coro->args);
1457 SvREFCNT_dec (CORO_THROW);
1458
1459 if (coro->next) coro->next->prev = coro->prev;
1460 if (coro->prev) coro->prev->next = coro->next;
1461 if (coro == coro_first) coro_first = coro->next;
1462
1463 return 1;
1464}
1465
1466static int
1467coro_state_free (pTHX_ SV *sv, MAGIC *mg)
1468{
1469 struct coro *coro = (struct coro *)mg->mg_ptr;
1470 mg->mg_ptr = 0;
1471
1472 coro->hv = 0;
1473
1474 if (--coro->refcnt < 0)
1475 {
1476 coro_state_destroy (aTHX_ coro);
1477 Safefree (coro);
1478 }
1479
1480 return 0;
1481}
1482
1483static int
1484coro_state_dup (pTHX_ MAGIC *mg, CLONE_PARAMS *params)
1485{
1486 struct coro *coro = (struct coro *)mg->mg_ptr;
1487
1488 ++coro->refcnt;
1489
1490 return 0;
1491}
1492
1493static MGVTBL coro_state_vtbl = {
1494 0, 0, 0, 0,
1495 coro_state_free,
1496 0,
1497#ifdef MGf_DUP
1498 coro_state_dup,
1499#else
1500# define MGf_DUP 0
1501#endif
1502};
1503
1504static void
1505prepare_transfer (pTHX_ struct coro_transfer_args *ta, SV *prev_sv, SV *next_sv)
1506{
1507 ta->prev = SvSTATE (prev_sv);
1508 ta->next = SvSTATE (next_sv);
1509 TRANSFER_CHECK (*ta);
1510}
1511
1512static void
1513api_transfer (pTHX_ SV *prev_sv, SV *next_sv)
1514{
1515 struct coro_transfer_args ta;
1516
1517 prepare_transfer (aTHX_ &ta, prev_sv, next_sv);
1518 TRANSFER (ta, 1);
1519}
1520
1521/*****************************************************************************/
1522/* gensub: simple closure generation utility */
1523
1524#define GENSUB_ARG CvXSUBANY (cv).any_ptr
1525
1526/* create a closure from XS, returns a code reference */
1527/* the arg can be accessed via GENSUB_ARG from the callback */
1528/* the callback must use dXSARGS/XSRETURN */
1529static SV *
1530gensub (pTHX_ void (*xsub)(pTHX_ CV *), void *arg)
1531{
1532 CV *cv = (CV *)newSV (0);
1533
1534 sv_upgrade ((SV *)cv, SVt_PVCV);
1535
1536 CvANON_on (cv);
1537 CvISXSUB_on (cv);
1538 CvXSUB (cv) = xsub;
1539 GENSUB_ARG = arg;
1540
1541 return newRV_noinc ((SV *)cv);
1542}
1543
1544/** Coro ********************************************************************/
1545
1546INLINE void
1547coro_enq (pTHX_ struct coro *coro)
1548{
1549 av_push (coro_ready [coro->prio - PRIO_MIN], SvREFCNT_inc_NN (coro->hv));
1550}
1551
1552INLINE SV *
1553coro_deq (pTHX)
1554{
1555 int prio;
1556
1557 for (prio = PRIO_MAX - PRIO_MIN + 1; --prio >= 0; )
1558 if (AvFILLp (coro_ready [prio]) >= 0)
1559 return av_shift (coro_ready [prio]);
1560
1561 return 0;
1562}
1563
1564static int
1565api_ready (pTHX_ SV *coro_sv)
1566{
1567 struct coro *coro;
1568 SV *sv_hook;
1569 void (*xs_hook)(void);
1570
1571 if (SvROK (coro_sv))
1572 coro_sv = SvRV (coro_sv);
1573
1574 coro = SvSTATE (coro_sv);
1575
1576 if (coro->flags & CF_READY)
1577 return 0;
1578
1579 coro->flags |= CF_READY;
1580
1581 sv_hook = coro_nready ? 0 : coro_readyhook;
1582 xs_hook = coro_nready ? 0 : coroapi.readyhook;
1583
1584 coro_enq (aTHX_ coro);
1585 ++coro_nready;
1586
1587 if (sv_hook)
1588 {
1589 dSP;
1590
1591 ENTER;
1592 SAVETMPS;
1593
1594 PUSHMARK (SP);
1595 PUTBACK;
1596 call_sv (sv_hook, G_VOID | G_DISCARD);
1597
1598 FREETMPS;
1599 LEAVE;
1600 }
1601
1602 if (xs_hook)
1603 xs_hook ();
1604
1605 return 1;
1606}
1607
1608static int
1609api_is_ready (pTHX_ SV *coro_sv)
1610{
1611 return !!(SvSTATE (coro_sv)->flags & CF_READY);
1612}
1613
1614INLINE void
1615prepare_schedule (pTHX_ struct coro_transfer_args *ta)
1616{
1617 SV *prev_sv, *next_sv;
1618
1619 for (;;)
1620 {
1621 next_sv = coro_deq (aTHX);
1622
1623 /* nothing to schedule: call the idle handler */
1624 if (expect_false (!next_sv))
1625 {
1626 dSP;
1627
1628 ENTER;
1629 SAVETMPS;
1630
1631 PUSHMARK (SP);
1632 PUTBACK;
1633 call_sv (get_sv ("Coro::idle", FALSE), G_VOID | G_DISCARD);
1634
1635 FREETMPS;
1636 LEAVE;
1637 continue;
1638 }
1639
1640 ta->next = SvSTATE_hv (next_sv);
1641
1642 /* cannot transfer to destroyed coros, skip and look for next */
1643 if (expect_false (ta->next->flags & CF_DESTROYED))
1644 {
1645 SvREFCNT_dec (next_sv);
1646 /* coro_nready has already been taken care of by destroy */
1647 continue;
1648 }
1649
1650 --coro_nready;
1651 break;
1652 }
1653
1654 /* free this only after the transfer */
1655 prev_sv = SvRV (coro_current);
1656 ta->prev = SvSTATE_hv (prev_sv);
1657 TRANSFER_CHECK (*ta);
1658 assert (("FATAL: next coroutine isn't marked as ready in Coro (please report)", ta->next->flags & CF_READY));
1659 ta->next->flags &= ~CF_READY;
1660 SvRV_set (coro_current, next_sv);
1661
1662 free_coro_mortal (aTHX);
1663 coro_mortal = prev_sv;
1664}
1665
1666INLINE void
1667prepare_cede (pTHX_ struct coro_transfer_args *ta)
1668{
1669 api_ready (aTHX_ coro_current);
1670 prepare_schedule (aTHX_ ta);
1671}
1672
1673INLINE void
1674prepare_cede_notself (pTHX_ struct coro_transfer_args *ta)
1675{
1676 SV *prev = SvRV (coro_current);
1677
1678 if (coro_nready)
1679 {
1680 prepare_schedule (aTHX_ ta);
1681 api_ready (aTHX_ prev);
1682 }
1683 else
1684 prepare_nop (aTHX_ ta);
1685}
1686
1687static void
1688api_schedule (pTHX)
1689{
1690 struct coro_transfer_args ta;
1691
1692 prepare_schedule (aTHX_ &ta);
1693 TRANSFER (ta, 1);
1694}
1695
1696static int
1697api_cede (pTHX)
1698{
1699 struct coro_transfer_args ta;
1700
1701 prepare_cede (aTHX_ &ta);
1702
1703 if (expect_true (ta.prev != ta.next))
1704 {
1705 TRANSFER (ta, 1);
1706 return 1;
1707 }
1708 else
1709 return 0;
1710}
1711
1712static int
1713api_cede_notself (pTHX)
1714{
1715 if (coro_nready)
1716 {
1717 struct coro_transfer_args ta;
1718
1719 prepare_cede_notself (aTHX_ &ta);
1720 TRANSFER (ta, 1);
1721 return 1;
1722 }
1723 else
1724 return 0;
1725}
1726
1727static void
1728api_trace (pTHX_ SV *coro_sv, int flags)
1729{
1730 struct coro *coro = SvSTATE (coro_sv);
1731
1732 if (flags & CC_TRACE)
1733 {
1734 if (!coro->cctx)
1735 coro->cctx = cctx_new_run ();
1736 else if (!(coro->cctx->flags & CC_TRACE))
1737 croak ("cannot enable tracing on coroutine with custom stack,");
1738
1739 coro->cctx->flags |= CC_NOREUSE | (flags & (CC_TRACE | CC_TRACE_ALL));
1740 }
1741 else if (coro->cctx && coro->cctx->flags & CC_TRACE)
1742 {
1743 coro->cctx->flags &= ~(CC_TRACE | CC_TRACE_ALL);
1744
1745 if (coro->flags & CF_RUNNING)
1746 PL_runops = RUNOPS_DEFAULT;
1747 else
1748 coro->slot->runops = RUNOPS_DEFAULT;
1749 }
1750}
1751
1752/*****************************************************************************/
1753/* async pool handler */
1754
1755static int
1756slf_check_pool_handler (pTHX_ struct CoroSLF *frame)
1757{
1758 HV *hv = (HV *)SvRV (coro_current);
1759 struct coro *coro = (struct coro *)frame->data;
1760
1761 if (!coro->invoke_cb)
1762 return 1; /* loop till we have invoke */
1763 else
1764 {
1765 int i, len;
1766
1767 hv_store (hv, "desc", sizeof ("desc") - 1,
1768 newSVpvn ("[async_pool]", sizeof ("[async_pool]") - 1), 0);
1769
1770 coro->saved_deffh = SvREFCNT_inc_NN ((SV *)PL_defoutgv);
1771
1772 len = av_len (coro->invoke_av);
1773
1774 {
1775 dSP;
1776 XPUSHs (sv_2mortal (coro->invoke_cb)); coro->invoke_cb = 0;
1777 PUTBACK;
1778 }
1779
1780 SvREFCNT_dec (GvAV (PL_defgv));
1781 GvAV (PL_defgv) = coro->invoke_av;
1782 coro->invoke_av = 0;
1783
1784 return 0;
1785 }
1786}
1787
1788static void
1789slf_init_pool_handler (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
1790{
1791 HV *hv = (HV *)SvRV (coro_current);
1792 struct coro *coro = SvSTATE_hv ((SV *)hv);
1793
1794 if (expect_true (coro->saved_deffh))
1795 {
1796 /* subsequent iteration */
1797 SvREFCNT_dec ((SV *)PL_defoutgv); PL_defoutgv = (GV *)coro->saved_deffh;
1798 coro->saved_deffh = 0;
1799
1800 if (coro_rss (aTHX_ coro) > SvUV (sv_pool_rss)
1801 || av_len (av_async_pool) + 1 >= SvIV (sv_pool_size))
1802 {
1803 coro->invoke_cb = SvREFCNT_inc_NN ((SV *)cv_coro_terminate);
1804 coro->invoke_av = newAV ();
1805
1806 frame->prepare = prepare_nop;
1807 }
1808 else
1809 {
1810 av_clear (GvAV (PL_defgv));
1811 hv_store (hv, "desc", sizeof ("desc") - 1, SvREFCNT_inc_NN (sv_async_pool_idle), 0);
1812
1813 coro->prio = 0;
1814
1815 if (coro->cctx && (coro->cctx->flags & CC_TRACE))
1816 api_trace (aTHX_ coro_current, 0);
1817
1818 frame->prepare = prepare_schedule;
1819 av_push (av_async_pool, SvREFCNT_inc (hv));
1820 }
1821 }
1822 else
1823 {
1824 /* first iteration, simply fall through */
1825 frame->prepare = prepare_nop;
1826 }
1827
1828 frame->check = slf_check_pool_handler;
1829 frame->data = (void *)coro;
1830}
1831
1832/*****************************************************************************/
1833/* rouse callback */
1834
1835#define CORO_MAGIC_type_rouse PERL_MAGIC_ext
1836
1837static void
1838coro_rouse_callback (pTHX_ CV *cv)
1839{
1840 dXSARGS;
1841 SV *data = (SV *)GENSUB_ARG;
1842
1843 if (SvTYPE (SvRV (data)) != SVt_PVAV)
1844 {
1845 /* first call, set args */
1846 int i;
1847 AV *av = newAV ();
1848 SV *coro = SvRV (data);
1849
1850 SvRV_set (data, (SV *)av);
1851 api_ready (aTHX_ coro);
1852 SvREFCNT_dec (coro);
1853
1854 /* better take a full copy of the arguments */
1855 while (items--)
1856 av_store (av, items, newSVsv (ST (items)));
1857 }
1858
1859 XSRETURN_EMPTY;
1860}
1861
1862static int
1863slf_check_rouse_wait (pTHX_ struct CoroSLF *frame)
1864{
1865 SV *data = (SV *)frame->data;
1866
1867 if (CORO_THROW)
1868 return 0;
1869
1870 if (SvTYPE (SvRV (data)) != SVt_PVAV)
1871 return 1;
1872
1873 /* now push all results on the stack */
1874 {
1875 dSP;
1876 AV *av = (AV *)SvRV (data);
1877 int i;
1878
1879 EXTEND (SP, AvFILLp (av) + 1);
1880 for (i = 0; i <= AvFILLp (av); ++i)
1881 PUSHs (sv_2mortal (AvARRAY (av)[i]));
1882
1883 /* we have stolen the elements, so ste length to zero and free */
1884 AvFILLp (av) = -1;
1885 av_undef (av);
1886
1887 PUTBACK;
1888 }
1889
1890 return 0;
1891}
1892
1893static void
1894slf_init_rouse_wait (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
1895{
1896 SV *cb;
1897
1898 if (items)
1899 cb = arg [0];
1900 else
1901 {
1902 struct coro *coro = SvSTATE_current;
1903
1904 if (!coro->rouse_cb)
1905 croak ("Coro::rouse_wait called without rouse callback, and no default rouse callback found either,");
1906
1907 cb = sv_2mortal (coro->rouse_cb);
1908 coro->rouse_cb = 0;
1909 }
1910
1911 if (!SvROK (cb)
1912 || SvTYPE (SvRV (cb)) != SVt_PVCV
1913 || CvXSUB ((CV *)SvRV (cb)) != coro_rouse_callback)
1914 croak ("Coro::rouse_wait called with illegal callback argument,");
1915
1916 {
1917 CV *cv = (CV *)SvRV (cb); /* for GENSUB_ARG */
1918 SV *data = (SV *)GENSUB_ARG;
1919
1920 frame->data = (void *)data;
1921 frame->prepare = SvTYPE (SvRV (data)) == SVt_PVAV ? prepare_nop : prepare_schedule;
1922 frame->check = slf_check_rouse_wait;
1923 }
1924}
1925
1926static SV *
1927coro_new_rouse_cb (pTHX)
1928{
1929 HV *hv = (HV *)SvRV (coro_current);
1930 struct coro *coro = SvSTATE_hv (hv);
1931 SV *data = newRV_inc ((SV *)hv);
1932 SV *cb = gensub (aTHX_ coro_rouse_callback, (void *)data);
1933
1934 sv_magicext (SvRV (cb), data, CORO_MAGIC_type_rouse, 0, 0, 0);
1935 SvREFCNT_dec (data); /* magicext increases the refcount */
1936
1937 SvREFCNT_dec (coro->rouse_cb);
1938 coro->rouse_cb = SvREFCNT_inc_NN (cb);
1939
1940 return cb;
1941}
1942
1943/*****************************************************************************/
1944/* schedule-like-function opcode (SLF) */
1945
1946static UNOP slf_restore; /* restore stack as entersub did, for first-re-run */
1947static const CV *slf_cv;
1948static SV **slf_argv;
1949static int slf_argc, slf_arga; /* count, allocated */
1950static I32 slf_ax; /* top of stack, for restore */
1951
1952/* this restores the stack in the case we patched the entersub, to */
1953/* recreate the stack frame as perl will on following calls */
1954/* since entersub cleared the stack */
1955static OP *
1956pp_restore (pTHX)
1957{
1958 int i;
1959 SV **SP = PL_stack_base + slf_ax;
1960
1961 PUSHMARK (SP);
1962
1963 EXTEND (SP, slf_argc + 1);
1964
1965 for (i = 0; i < slf_argc; ++i)
1966 PUSHs (sv_2mortal (slf_argv [i]));
1967
1968 PUSHs ((SV *)CvGV (slf_cv));
1969
1970 RETURNOP (slf_restore.op_first);
1971}
1972
1973static void
1974slf_prepare_transfer (pTHX_ struct coro_transfer_args *ta)
1975{
1976 SV **arg = (SV **)slf_frame.data;
1977
1978 prepare_transfer (aTHX_ ta, arg [0], arg [1]);
1979}
1980
1981static void
1982slf_init_transfer (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
1983{
1984 if (items != 2)
1985 croak ("Coro::State::transfer (prev, next) expects two arguments, not %d,", items);
1986
1987 frame->prepare = slf_prepare_transfer;
1988 frame->check = slf_check_nop;
1989 frame->data = (void *)arg; /* let's hope it will stay valid */
1990}
1991
1992static void
1993slf_init_schedule (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
1994{
1995 frame->prepare = prepare_schedule;
1996 frame->check = slf_check_nop;
1997}
1998
1999static void
2000slf_init_cede (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2001{
2002 frame->prepare = prepare_cede;
2003 frame->check = slf_check_nop;
2004}
2005
2006static void
2007slf_init_cede_notself (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2008{
2009 frame->prepare = prepare_cede_notself;
2010 frame->check = slf_check_nop;
2011}
2012
2013/*
2014 * these not obviously related functions are all rolled into one
2015 * function to increase chances that they all will call transfer with the same
2016 * stack offset
2017 * SLF stands for "schedule-like-function".
2018 */
2019static OP *
2020pp_slf (pTHX)
2021{
2022 I32 checkmark; /* mark SP to see how many elements check has pushed */
2023
2024 /* set up the slf frame, unless it has already been set-up */
2025 /* the latter happens when a new coro has been started */
2026 /* or when a new cctx was attached to an existing coroutine */
2027 if (expect_true (!slf_frame.prepare))
2028 {
2029 /* first iteration */
2030 dSP;
2031 SV **arg = PL_stack_base + TOPMARK + 1;
2032 int items = SP - arg; /* args without function object */
2033 SV *gv = *sp;
2034
2035 /* do a quick consistency check on the "function" object, and if it isn't */
2036 /* for us, divert to the real entersub */
2037 if (SvTYPE (gv) != SVt_PVGV
2038 || !GvCV (gv)
2039 || !(CvFLAGS (GvCV (gv)) & CVf_SLF))
2040 return PL_ppaddr[OP_ENTERSUB](aTHX);
2041
2042 if (!(PL_op->op_flags & OPf_STACKED))
2043 {
2044 /* ampersand-form of call, use @_ instead of stack */
2045 AV *av = GvAV (PL_defgv);
2046 arg = AvARRAY (av);
2047 items = AvFILLp (av) + 1;
2048 }
2049
2050 /* now call the init function, which needs to set up slf_frame */
2051 ((coro_slf_cb)CvXSUBANY (GvCV (gv)).any_ptr)
2052 (aTHX_ &slf_frame, GvCV (gv), arg, items);
2053
2054 /* pop args */
2055 SP = PL_stack_base + POPMARK;
2056
2057 PUTBACK;
2058 }
2059
2060 /* now that we have a slf_frame, interpret it! */
2061 /* we use a callback system not to make the code needlessly */
2062 /* complicated, but so we can run multiple perl coros from one cctx */
2063
2064 do
2065 {
2066 struct coro_transfer_args ta;
2067
2068 slf_frame.prepare (aTHX_ &ta);
2069 TRANSFER (ta, 0);
2070
2071 checkmark = PL_stack_sp - PL_stack_base;
2072 }
2073 while (slf_frame.check (aTHX_ &slf_frame));
2074
2075 slf_frame.prepare = 0; /* invalidate the frame, we are done processing it */
2076
2077 /* exception handling */
2078 if (expect_false (CORO_THROW))
2079 {
2080 SV *exception = sv_2mortal (CORO_THROW);
2081
2082 CORO_THROW = 0;
2083 sv_setsv (ERRSV, exception);
2084 croak (0);
2085 }
2086
2087 /* return value handling - mostly like entersub */
2088 /* make sure we put something on the stack in scalar context */
2089 if (GIMME_V == G_SCALAR)
2090 {
2091 dSP;
2092 SV **bot = PL_stack_base + checkmark;
2093
2094 if (sp == bot) /* too few, push undef */
2095 bot [1] = &PL_sv_undef;
2096 else if (sp != bot + 1) /* too many, take last one */
2097 bot [1] = *sp;
2098
2099 SP = bot + 1;
2100
2101 PUTBACK;
2102 }
2103
2104 return NORMAL;
2105}
2106
2107static void
2108api_execute_slf (pTHX_ CV *cv, coro_slf_cb init_cb, I32 ax)
2109{
2110 int i;
2111 SV **arg = PL_stack_base + ax;
2112 int items = PL_stack_sp - arg + 1;
2113
2114 assert (("FATAL: SLF call with illegal CV value", !CvANON (cv)));
2115
2116 if (PL_op->op_ppaddr != PL_ppaddr [OP_ENTERSUB]
2117 && PL_op->op_ppaddr != pp_slf)
2118 croak ("FATAL: Coro SLF calls can only be made normally, not via goto or any other means, caught");
2119
2120 CvFLAGS (cv) |= CVf_SLF;
2121 CvXSUBANY (cv).any_ptr = (void *)init_cb;
2122 slf_cv = cv;
2123
2124 /* we patch the op, and then re-run the whole call */
2125 /* we have to put the same argument on the stack for this to work */
2126 /* and this will be done by pp_restore */
2127 slf_restore.op_next = (OP *)&slf_restore;
2128 slf_restore.op_type = OP_CUSTOM;
2129 slf_restore.op_ppaddr = pp_restore;
2130 slf_restore.op_first = PL_op;
2131
2132 slf_ax = ax - 1; /* undo the ax++ inside dAXMARK */
2133
2134 if (PL_op->op_flags & OPf_STACKED)
2135 {
2136 if (items > slf_arga)
2137 {
2138 slf_arga = items;
2139 free (slf_argv);
2140 slf_argv = malloc (slf_arga * sizeof (SV *));
2141 }
2142
2143 slf_argc = items;
2144
2145 for (i = 0; i < items; ++i)
2146 slf_argv [i] = SvREFCNT_inc (arg [i]);
2147 }
2148 else
2149 slf_argc = 0;
2150
2151 PL_op->op_ppaddr = pp_slf;
2152 PL_op->op_type = OP_CUSTOM; /* maybe we should leave it at entersub? */
2153
2154 PL_op = (OP *)&slf_restore;
2155}
2156
2157/*****************************************************************************/
2158/* PerlIO::cede */
2159
2160typedef struct
2161{
2162 PerlIOBuf base;
2163 NV next, every;
2164} PerlIOCede;
2165
2166static IV
2167PerlIOCede_pushed (pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
2168{
2169 PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
2170
2171 self->every = SvCUR (arg) ? SvNV (arg) : 0.01;
2172 self->next = nvtime () + self->every;
2173
2174 return PerlIOBuf_pushed (aTHX_ f, mode, Nullsv, tab);
2175}
2176
2177static SV *
2178PerlIOCede_getarg (pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)
2179{
2180 PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
2181
2182 return newSVnv (self->every);
2183}
2184
2185static IV
2186PerlIOCede_flush (pTHX_ PerlIO *f)
2187{
2188 PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
2189 double now = nvtime ();
2190
2191 if (now >= self->next)
2192 {
2193 api_cede (aTHX);
2194 self->next = now + self->every;
2195 }
2196
2197 return PerlIOBuf_flush (aTHX_ f);
2198}
2199
2200static PerlIO_funcs PerlIO_cede =
2201{
2202 sizeof(PerlIO_funcs),
2203 "cede",
2204 sizeof(PerlIOCede),
2205 PERLIO_K_DESTRUCT | PERLIO_K_RAW,
2206 PerlIOCede_pushed,
2207 PerlIOBuf_popped,
2208 PerlIOBuf_open,
2209 PerlIOBase_binmode,
2210 PerlIOCede_getarg,
2211 PerlIOBase_fileno,
2212 PerlIOBuf_dup,
2213 PerlIOBuf_read,
2214 PerlIOBuf_unread,
2215 PerlIOBuf_write,
2216 PerlIOBuf_seek,
2217 PerlIOBuf_tell,
2218 PerlIOBuf_close,
2219 PerlIOCede_flush,
2220 PerlIOBuf_fill,
2221 PerlIOBase_eof,
2222 PerlIOBase_error,
2223 PerlIOBase_clearerr,
2224 PerlIOBase_setlinebuf,
2225 PerlIOBuf_get_base,
2226 PerlIOBuf_bufsiz,
2227 PerlIOBuf_get_ptr,
2228 PerlIOBuf_get_cnt,
2229 PerlIOBuf_set_ptrcnt,
2230};
2231
2232/*****************************************************************************/
2233/* Coro::Semaphore & Coro::Signal */
2234
2235static SV *
2236coro_waitarray_new (pTHX_ int count)
2237{
2238 /* a semaphore contains a counter IV in $sem->[0] and any waiters after that */
2239 AV *av = newAV ();
2240 SV **ary;
2241
2242 /* unfortunately, building manually saves memory */
2243 Newx (ary, 2, SV *);
2244 AvALLOC (av) = ary;
2245 /*AvARRAY (av) = ary;*/
2246 SvPVX ((SV *)av) = (char *)ary; /* 5.8.8 needs this syntax instead of AvARRAY = ary */
2247 AvMAX (av) = 1;
2248 AvFILLp (av) = 0;
2249 ary [0] = newSViv (count);
2250
2251 return newRV_noinc ((SV *)av);
2252}
2253
2254/* semaphore */
2255
2256static void
2257coro_semaphore_adjust (pTHX_ AV *av, IV adjust)
2258{
2259 SV *count_sv = AvARRAY (av)[0];
2260 IV count = SvIVX (count_sv);
2261
2262 count += adjust;
2263 SvIVX (count_sv) = count;
2264
2265 /* now wake up as many waiters as are expected to lock */
2266 while (count > 0 && AvFILLp (av) > 0)
2267 {
2268 SV *cb;
2269
2270 /* swap first two elements so we can shift a waiter */
2271 AvARRAY (av)[0] = AvARRAY (av)[1];
2272 AvARRAY (av)[1] = count_sv;
2273 cb = av_shift (av);
2274
2275 if (SvOBJECT (cb))
2276 {
2277 api_ready (aTHX_ cb);
2278 --count;
2279 }
2280 else if (SvTYPE (cb) == SVt_PVCV)
2281 {
2282 dSP;
2283 PUSHMARK (SP);
2284 XPUSHs (sv_2mortal (newRV_inc ((SV *)av)));
2285 PUTBACK;
2286 call_sv (cb, G_VOID | G_DISCARD | G_EVAL | G_KEEPERR);
2287 }
2288
2289 SvREFCNT_dec (cb);
2290 }
2291}
2292
2293static void
2294coro_semaphore_on_destroy (pTHX_ struct coro *coro)
2295{
2296 /* call $sem->adjust (0) to possibly wake up some other waiters */
2297 coro_semaphore_adjust (aTHX_ (AV *)coro->slf_frame.data, 0);
2298}
2299
2300static int
2301slf_check_semaphore_down_or_wait (pTHX_ struct CoroSLF *frame, int acquire)
2302{
2303 AV *av = (AV *)frame->data;
2304 SV *count_sv = AvARRAY (av)[0];
2305
2306 /* if we are about to throw, don't actually acquire the lock, just throw */
2307 if (CORO_THROW)
2308 return 0;
2309 else if (SvIVX (count_sv) > 0)
2310 {
2311 SvSTATE_current->on_destroy = 0;
2312
2313 if (acquire)
2314 SvIVX (count_sv) = SvIVX (count_sv) - 1;
2315 else
2316 coro_semaphore_adjust (aTHX_ av, 0);
2317
2318 return 0;
2319 }
2320 else
2321 {
2322 int i;
2323 /* if we were woken up but can't down, we look through the whole */
2324 /* waiters list and only add us if we aren't in there already */
2325 /* this avoids some degenerate memory usage cases */
2326
2327 for (i = 1; i <= AvFILLp (av); ++i)
2328 if (AvARRAY (av)[i] == SvRV (coro_current))
2329 return 1;
2330
2331 av_push (av, SvREFCNT_inc (SvRV (coro_current)));
2332 return 1;
2333 }
2334}
2335
2336static int
2337slf_check_semaphore_down (pTHX_ struct CoroSLF *frame)
2338{
2339 return slf_check_semaphore_down_or_wait (aTHX_ frame, 1);
2340}
2341
2342static int
2343slf_check_semaphore_wait (pTHX_ struct CoroSLF *frame)
2344{
2345 return slf_check_semaphore_down_or_wait (aTHX_ frame, 0);
2346}
2347
2348static void
2349slf_init_semaphore_down_or_wait (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2350{
2351 AV *av = (AV *)SvRV (arg [0]);
2352
2353 if (SvIVX (AvARRAY (av)[0]) > 0)
2354 {
2355 frame->data = (void *)av;
2356 frame->prepare = prepare_nop;
2357 }
2358 else
2359 {
2360 av_push (av, SvREFCNT_inc (SvRV (coro_current)));
2361
2362 frame->data = (void *)sv_2mortal (SvREFCNT_inc ((SV *)av));
2363 frame->prepare = prepare_schedule;
2364
2365 /* to avoid race conditions when a woken-up coro gets terminated */
2366 /* we arrange for a temporary on_destroy that calls adjust (0) */
2367 SvSTATE_current->on_destroy = coro_semaphore_on_destroy;
2368 }
2369}
2370
2371static void
2372slf_init_semaphore_down (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2373{
2374 slf_init_semaphore_down_or_wait (aTHX_ frame, cv, arg, items);
2375 frame->check = slf_check_semaphore_down;
2376}
2377
2378static void
2379slf_init_semaphore_wait (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2380{
2381 if (items >= 2)
2382 {
2383 /* callback form */
2384 AV *av = (AV *)SvRV (arg [0]);
2385 CV *cb_cv = coro_sv_2cv (aTHX_ arg [1]);
2386
2387 av_push (av, (SV *)SvREFCNT_inc_NN (cb_cv));
2388
2389 if (SvIVX (AvARRAY (av)[0]) > 0)
2390 coro_semaphore_adjust (aTHX_ av, 0);
2391
2392 frame->prepare = prepare_nop;
2393 frame->check = slf_check_nop;
2394 }
2395 else
2396 {
2397 slf_init_semaphore_down_or_wait (aTHX_ frame, cv, arg, items);
2398 frame->check = slf_check_semaphore_wait;
2399 }
2400}
2401
2402/* signal */
2403
2404static void
2405coro_signal_wake (pTHX_ AV *av, int count)
2406{
2407 SvIVX (AvARRAY (av)[0]) = 0;
2408
2409 /* now signal count waiters */
2410 while (count > 0 && AvFILLp (av) > 0)
2411 {
2412 SV *cb;
2413
2414 /* swap first two elements so we can shift a waiter */
2415 cb = AvARRAY (av)[0];
2416 AvARRAY (av)[0] = AvARRAY (av)[1];
2417 AvARRAY (av)[1] = cb;
2418
2419 cb = av_shift (av);
2420
2421 api_ready (aTHX_ cb);
2422 sv_setiv (cb, 0); /* signal waiter */
2423 SvREFCNT_dec (cb);
2424
2425 --count;
2426 }
2427}
2428
2429static int
2430slf_check_signal_wait (pTHX_ struct CoroSLF *frame)
2431{
2432 /* if we are about to throw, also stop waiting */
2433 return SvROK ((SV *)frame->data) && !CORO_THROW;
2434}
2435
2436static void
2437slf_init_signal_wait (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2438{
2439 AV *av = (AV *)SvRV (arg [0]);
2440
2441 if (SvIVX (AvARRAY (av)[0]))
2442 {
2443 SvIVX (AvARRAY (av)[0]) = 0;
2444 frame->prepare = prepare_nop;
2445 frame->check = slf_check_nop;
2446 }
2447 else
2448 {
2449 SV *waiter = newRV_inc (SvRV (coro_current)); /* owned by signal av */
2450
2451 av_push (av, waiter);
2452
2453 frame->data = (void *)sv_2mortal (SvREFCNT_inc_NN (waiter)); /* owned by process */
2454 frame->prepare = prepare_schedule;
2455 frame->check = slf_check_signal_wait;
2456 }
2457}
2458
2459/*****************************************************************************/
2460/* Coro::AIO */
2461
2462#define CORO_MAGIC_type_aio PERL_MAGIC_ext
2463
2464/* helper storage struct */
2465struct io_state
2466{
2467 int errorno;
2468 I32 laststype; /* U16 in 5.10.0 */
2469 int laststatval;
2470 Stat_t statcache;
2471};
2472
2473static void
2474coro_aio_callback (pTHX_ CV *cv)
2475{
2476 dXSARGS;
2477 AV *state = (AV *)GENSUB_ARG;
2478 SV *coro = av_pop (state);
2479 SV *data_sv = newSV (sizeof (struct io_state));
2480
2481 av_extend (state, items - 1);
2482
2483 sv_upgrade (data_sv, SVt_PV);
2484 SvCUR_set (data_sv, sizeof (struct io_state));
2485 SvPOK_only (data_sv);
2486
2487 {
2488 struct io_state *data = (struct io_state *)SvPVX (data_sv);
2489
2490 data->errorno = errno;
2491 data->laststype = PL_laststype;
2492 data->laststatval = PL_laststatval;
2493 data->statcache = PL_statcache;
2494 }
2495
2496 /* now build the result vector out of all the parameters and the data_sv */
2497 {
2498 int i;
2499
2500 for (i = 0; i < items; ++i)
2501 av_push (state, SvREFCNT_inc_NN (ST (i)));
2502 }
2503
2504 av_push (state, data_sv);
2505
2506 api_ready (aTHX_ coro);
2507 SvREFCNT_dec (coro);
2508 SvREFCNT_dec ((AV *)state);
2509}
2510
2511static int
2512slf_check_aio_req (pTHX_ struct CoroSLF *frame)
2513{
2514 AV *state = (AV *)frame->data;
2515
2516 /* if we are about to throw, return early */
2517 /* this does not cancel the aio request, but at least */
2518 /* it quickly returns */
2519 if (CORO_THROW)
2520 return 0;
2521
2522 /* one element that is an RV? repeat! */
2523 if (AvFILLp (state) == 0 && SvROK (AvARRAY (state)[0]))
2524 return 1;
2525
2526 /* restore status */
2527 {
2528 SV *data_sv = av_pop (state);
2529 struct io_state *data = (struct io_state *)SvPVX (data_sv);
2530
2531 errno = data->errorno;
2532 PL_laststype = data->laststype;
2533 PL_laststatval = data->laststatval;
2534 PL_statcache = data->statcache;
2535
2536 SvREFCNT_dec (data_sv);
2537 }
2538
2539 /* push result values */
2540 {
2541 dSP;
2542 int i;
2543
2544 EXTEND (SP, AvFILLp (state) + 1);
2545 for (i = 0; i <= AvFILLp (state); ++i)
2546 PUSHs (sv_2mortal (SvREFCNT_inc_NN (AvARRAY (state)[i])));
2547
2548 PUTBACK;
2549 }
2550
2551 return 0;
2552}
2553
2554static void
2555slf_init_aio_req (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2556{
2557 AV *state = (AV *)sv_2mortal ((SV *)newAV ());
2558 SV *coro_hv = SvRV (coro_current);
2559 struct coro *coro = SvSTATE_hv (coro_hv);
2560
2561 /* put our coroutine id on the state arg */
2562 av_push (state, SvREFCNT_inc_NN (coro_hv));
2563
2564 /* first see whether we have a non-zero priority and set it as AIO prio */
2565 if (coro->prio)
2566 {
2567 dSP;
2568
2569 static SV *prio_cv;
2570 static SV *prio_sv;
2571
2572 if (expect_false (!prio_cv))
2573 {
2574 prio_cv = (SV *)get_cv ("IO::AIO::aioreq_pri", 0);
2575 prio_sv = newSViv (0);
2576 }
2577
2578 PUSHMARK (SP);
2579 sv_setiv (prio_sv, coro->prio);
2580 XPUSHs (prio_sv);
2581
2582 PUTBACK;
2583 call_sv (prio_cv, G_VOID | G_DISCARD);
2584 }
2585
2586 /* now call the original request */
2587 {
2588 dSP;
2589 CV *req = (CV *)CORO_MAGIC_NN ((SV *)cv, CORO_MAGIC_type_aio)->mg_obj;
2590 int i;
2591
2592 PUSHMARK (SP);
2593
2594 /* first push all args to the stack */
2595 EXTEND (SP, items + 1);
2596
2597 for (i = 0; i < items; ++i)
2598 PUSHs (arg [i]);
2599
2600 /* now push the callback closure */
2601 PUSHs (sv_2mortal (gensub (aTHX_ coro_aio_callback, (void *)SvREFCNT_inc_NN ((SV *)state))));
2602
2603 /* now call the AIO function - we assume our request is uncancelable */
2604 PUTBACK;
2605 call_sv ((SV *)req, G_VOID | G_DISCARD);
2606 }
2607
2608 /* now that the requets is going, we loop toll we have a result */
2609 frame->data = (void *)state;
2610 frame->prepare = prepare_schedule;
2611 frame->check = slf_check_aio_req;
2612}
2613
2614static void
2615coro_aio_req_xs (pTHX_ CV *cv)
2616{
2617 dXSARGS;
2618
2619 CORO_EXECUTE_SLF_XS (slf_init_aio_req);
2620
2621 XSRETURN_EMPTY;
2622}
2623
2624/*****************************************************************************/
2625
2626MODULE = Coro::State PACKAGE = Coro::State PREFIX = api_
2627
2628PROTOTYPES: DISABLE
2629
2630BOOT:
2631{
2632#ifdef USE_ITHREADS
2633# if CORO_PTHREAD
2634 coro_thx = PERL_GET_CONTEXT;
2635# endif
2636#endif
2637 BOOT_PAGESIZE;
2638
2639 irsgv = gv_fetchpv ("/" , GV_ADD|GV_NOTQUAL, SVt_PV);
2640 stdoutgv = gv_fetchpv ("STDOUT", GV_ADD|GV_NOTQUAL, SVt_PVIO);
2641
2642 orig_sigelem_get = PL_vtbl_sigelem.svt_get; PL_vtbl_sigelem.svt_get = coro_sigelem_get;
2643 orig_sigelem_set = PL_vtbl_sigelem.svt_set; PL_vtbl_sigelem.svt_set = coro_sigelem_set;
2644 orig_sigelem_clr = PL_vtbl_sigelem.svt_clear; PL_vtbl_sigelem.svt_clear = coro_sigelem_clr;
2645
2646 hv_sig = coro_get_hv (aTHX_ "SIG", TRUE);
2647 rv_diehook = newRV_inc ((SV *)gv_fetchpv ("Coro::State::diehook" , 0, SVt_PVCV));
2648 rv_warnhook = newRV_inc ((SV *)gv_fetchpv ("Coro::State::warnhook", 0, SVt_PVCV));
2649
2650 coro_state_stash = gv_stashpv ("Coro::State", TRUE);
2651
2652 newCONSTSUB (coro_state_stash, "CC_TRACE" , newSViv (CC_TRACE));
2653 newCONSTSUB (coro_state_stash, "CC_TRACE_SUB" , newSViv (CC_TRACE_SUB));
2654 newCONSTSUB (coro_state_stash, "CC_TRACE_LINE", newSViv (CC_TRACE_LINE));
2655 newCONSTSUB (coro_state_stash, "CC_TRACE_ALL" , newSViv (CC_TRACE_ALL));
2656
2657 main_mainstack = PL_mainstack;
2658 main_top_env = PL_top_env;
2659
2660 while (main_top_env->je_prev)
2661 main_top_env = main_top_env->je_prev;
2662
2663 {
2664 SV *slf = sv_2mortal (newSViv (PTR2IV (pp_slf)));
2665
2666 if (!PL_custom_op_names) PL_custom_op_names = newHV ();
2667 hv_store_ent (PL_custom_op_names, slf,
2668 newSVpv ("coro_slf", 0), 0);
2669
2670 if (!PL_custom_op_descs) PL_custom_op_descs = newHV ();
2671 hv_store_ent (PL_custom_op_descs, slf,
2672 newSVpv ("coro schedule like function", 0), 0);
2673 }
2674
2675 coroapi.ver = CORO_API_VERSION;
2676 coroapi.rev = CORO_API_REVISION;
2677
2678 coroapi.transfer = api_transfer;
2679
2680 coroapi.sv_state = SvSTATE_;
2681 coroapi.execute_slf = api_execute_slf;
2682 coroapi.prepare_nop = prepare_nop;
2683 coroapi.prepare_schedule = prepare_schedule;
2684 coroapi.prepare_cede = prepare_cede;
2685 coroapi.prepare_cede_notself = prepare_cede_notself;
2686
2687 {
2688 SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
2689
2690 if (!svp) croak ("Time::HiRes is required");
2691 if (!SvIOK (*svp)) croak ("Time::NVtime isn't a function pointer");
2692
2693 nvtime = INT2PTR (double (*)(), SvIV (*svp));
2694 }
2695
2696 assert (("PRIO_NORMAL must be 0", !PRIO_NORMAL));
2697}
2698
2699SV *
2700new (char *klass, ...)
2701 ALIAS:
2702 Coro::new = 1
2703 CODE:
2704{
2705 struct coro *coro;
2706 MAGIC *mg;
2707 HV *hv;
2708 CV *cb;
2709 int i;
2710
2711 if (items > 1)
2712 {
2713 cb = coro_sv_2cv (aTHX_ ST (1));
2714
2715 if (!ix)
215 { 2716 {
216 /* I never used formats, so how should I know how these are implemented? */ 2717 if (CvISXSUB (cb))
217 /* my bold guess is as a simple, plain sub... */ 2718 croak ("Coro::State doesn't support XS functions as coroutine start, caught");
218 croak ("CXt_FORMAT not yet handled. Don't switch coroutines from within formats"); 2719
2720 if (!CvROOT (cb))
2721 croak ("Coro::State doesn't support autoloaded or undefined functions as coroutine start, caught");
219 } 2722 }
220 } 2723 }
221 2724
222 if (top_si->si_type == PERLSI_MAIN)
223 break;
224
225 top_si = top_si->si_prev;
226 ccstk = top_si->si_cxstack;
227 cxix = top_si->si_cxix;
228 }
229
230 PUTBACK;
231 }
232
233 c->dowarn = PL_dowarn;
234 c->defav = GvAV (PL_defgv);
235 c->curstackinfo = PL_curstackinfo;
236 c->curstack = PL_curstack;
237 c->mainstack = PL_mainstack;
238 c->stack_sp = PL_stack_sp;
239 c->op = PL_op;
240 c->curpad = PL_curpad;
241 c->stack_base = PL_stack_base;
242 c->stack_max = PL_stack_max;
243 c->tmps_stack = PL_tmps_stack;
244 c->tmps_floor = PL_tmps_floor;
245 c->tmps_ix = PL_tmps_ix;
246 c->tmps_max = PL_tmps_max;
247 c->markstack = PL_markstack;
248 c->markstack_ptr = PL_markstack_ptr;
249 c->markstack_max = PL_markstack_max;
250 c->scopestack = PL_scopestack;
251 c->scopestack_ix = PL_scopestack_ix;
252 c->scopestack_max = PL_scopestack_max;
253 c->savestack = PL_savestack;
254 c->savestack_ix = PL_savestack_ix;
255 c->savestack_max = PL_savestack_max;
256 c->retstack = PL_retstack;
257 c->retstack_ix = PL_retstack_ix;
258 c->retstack_max = PL_retstack_max;
259 c->curcop = PL_curcop;
260}
261
262static void
263LOAD(pTHX_ Coro__State c)
264{
265 PL_dowarn = c->dowarn;
266 GvAV (PL_defgv) = c->defav;
267 PL_curstackinfo = c->curstackinfo;
268 PL_curstack = c->curstack;
269 PL_mainstack = c->mainstack;
270 PL_stack_sp = c->stack_sp;
271 PL_op = c->op;
272 PL_curpad = c->curpad;
273 PL_stack_base = c->stack_base;
274 PL_stack_max = c->stack_max;
275 PL_tmps_stack = c->tmps_stack;
276 PL_tmps_floor = c->tmps_floor;
277 PL_tmps_ix = c->tmps_ix;
278 PL_tmps_max = c->tmps_max;
279 PL_markstack = c->markstack;
280 PL_markstack_ptr = c->markstack_ptr;
281 PL_markstack_max = c->markstack_max;
282 PL_scopestack = c->scopestack;
283 PL_scopestack_ix = c->scopestack_ix;
284 PL_scopestack_max = c->scopestack_max;
285 PL_savestack = c->savestack;
286 PL_savestack_ix = c->savestack_ix;
287 PL_savestack_max = c->savestack_max;
288 PL_retstack = c->retstack;
289 PL_retstack_ix = c->retstack_ix;
290 PL_retstack_max = c->retstack_max;
291 PL_curcop = c->curcop;
292
293 {
294 dSP;
295 CV *cv;
296
297 /* now do the ugly restore mess */
298 while ((cv = (CV *)POPs))
299 {
300 AV *padlist = (AV *)POPs;
301
302 unuse_padlist (CvPADLIST(cv));
303 CvPADLIST(cv) = padlist;
304 CvDEPTH(cv) = (I32)POPs;
305
306#ifdef USE_THREADS
307 CvOWNER(cv) = (struct perl_thread *)POPs;
308 error does not work either
309#endif
310 }
311
312 PUTBACK;
313 }
314}
315
316/* this is an EXACT copy of S_nuke_stacks in perl.c, which is unfortunately static */
317STATIC void
318S_nuke_stacks(pTHX)
319{
320 while (PL_curstackinfo->si_next)
321 PL_curstackinfo = PL_curstackinfo->si_next;
322 while (PL_curstackinfo) {
323 PERL_SI *p = PL_curstackinfo->si_prev;
324 /* curstackinfo->si_stack got nuked by sv_free_arenas() */
325 Safefree(PL_curstackinfo->si_cxstack);
326 Safefree(PL_curstackinfo);
327 PL_curstackinfo = p;
328 }
329 Safefree(PL_tmps_stack);
330 Safefree(PL_markstack);
331 Safefree(PL_scopestack);
332 Safefree(PL_savestack);
333 Safefree(PL_retstack);
334}
335
336#define SUB_INIT "Coro::State::_newcoro"
337
338MODULE = Coro::State PACKAGE = Coro::State
339
340PROTOTYPES: ENABLE
341
342BOOT:
343 if (!padlist_cache)
344 padlist_cache = newHV ();
345
346Coro::State
347_newprocess(args)
348 SV * args
349 PROTOTYPE: $
350 CODE:
351 Coro__State coro;
352
353 if (!SvROK (args) || SvTYPE (SvRV (args)) != SVt_PVAV)
354 croak ("Coro::State::newprocess expects an arrayref");
355
356 New (0, coro, 1, struct coro); 2725 Newz (0, coro, 1, struct coro);
2726 coro->args = newAV ();
2727 coro->flags = CF_NEW;
357 2728
358 coro->mainstack = 0; /* actual work is done inside transfer */ 2729 if (coro_first) coro_first->prev = coro;
359 coro->args = (AV *)SvREFCNT_inc (SvRV (args)); 2730 coro->next = coro_first;
2731 coro_first = coro;
360 2732
361 RETVAL = coro; 2733 coro->hv = hv = newHV ();
2734 mg = sv_magicext ((SV *)hv, 0, CORO_MAGIC_type_state, &coro_state_vtbl, (char *)coro, 0);
2735 mg->mg_flags |= MGf_DUP;
2736 RETVAL = sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));
2737
2738 if (items > 1)
2739 {
2740 av_extend (coro->args, items - 1 + ix - 1);
2741
2742 if (ix)
2743 {
2744 av_push (coro->args, SvREFCNT_inc_NN ((SV *)cb));
2745 cb = cv_coro_run;
2746 }
2747
2748 coro->startcv = (CV *)SvREFCNT_inc_NN ((SV *)cb);
2749
2750 for (i = 2; i < items; i++)
2751 av_push (coro->args, newSVsv (ST (i)));
2752 }
2753}
362 OUTPUT: 2754 OUTPUT:
363 RETVAL 2755 RETVAL
364 2756
365void 2757void
366transfer(prev,next) 2758transfer (...)
367 Coro::State_or_hashref prev 2759 PROTOTYPE: $$
368 Coro::State_or_hashref next 2760 CODE:
369 CODE: 2761 CORO_EXECUTE_SLF_XS (slf_init_transfer);
370 2762
371 if (prev != next) 2763bool
2764_destroy (SV *coro_sv)
2765 CODE:
2766 RETVAL = coro_state_destroy (aTHX_ SvSTATE (coro_sv));
2767 OUTPUT:
2768 RETVAL
2769
2770void
2771_exit (int code)
2772 PROTOTYPE: $
2773 CODE:
2774 _exit (code);
2775
2776int
2777cctx_stacksize (int new_stacksize = 0)
2778 PROTOTYPE: ;$
2779 CODE:
2780 RETVAL = cctx_stacksize;
2781 if (new_stacksize)
372 { 2782 {
373 PUTBACK; 2783 cctx_stacksize = new_stacksize;
374 SAVE (aTHX_ prev); 2784 ++cctx_gen;
375
376 /* 2785 }
377 * this could be done in newprocess which would lead to 2786 OUTPUT:
378 * extremely elegant and fast (just PUTBACK/SAVE/LOAD/SPAGAIN) 2787 RETVAL
379 * code here, but lazy allocation of stacks has also 2788
380 * some virtues and the overhead of the if() is nil. 2789int
2790cctx_max_idle (int max_idle = 0)
2791 PROTOTYPE: ;$
2792 CODE:
2793 RETVAL = cctx_max_idle;
2794 if (max_idle > 1)
2795 cctx_max_idle = max_idle;
2796 OUTPUT:
2797 RETVAL
2798
2799int
2800cctx_count ()
2801 PROTOTYPE:
2802 CODE:
2803 RETVAL = cctx_count;
2804 OUTPUT:
2805 RETVAL
2806
2807int
2808cctx_idle ()
2809 PROTOTYPE:
2810 CODE:
2811 RETVAL = cctx_idle;
2812 OUTPUT:
2813 RETVAL
2814
2815void
2816list ()
2817 PROTOTYPE:
2818 PPCODE:
2819{
2820 struct coro *coro;
2821 for (coro = coro_first; coro; coro = coro->next)
2822 if (coro->hv)
2823 XPUSHs (sv_2mortal (newRV_inc ((SV *)coro->hv)));
2824}
2825
2826void
2827call (Coro::State coro, SV *coderef)
2828 ALIAS:
2829 eval = 1
2830 CODE:
2831{
2832 if (coro->mainstack && ((coro->flags & CF_RUNNING) || coro->slot))
381 */ 2833 {
382 if (next->mainstack) 2834 struct coro temp;
2835
2836 if (!(coro->flags & CF_RUNNING))
383 { 2837 {
384 LOAD (aTHX_ next); 2838 PUTBACK;
385 next->mainstack = 0; /* unnecessary but much cleaner */ 2839 save_perl (aTHX_ &temp);
2840 load_perl (aTHX_ coro);
2841 }
2842
2843 {
2844 dSP;
2845 ENTER;
2846 SAVETMPS;
2847 PUTBACK;
2848 PUSHSTACK;
2849 PUSHMARK (SP);
2850
2851 if (ix)
2852 eval_sv (coderef, 0);
2853 else
2854 call_sv (coderef, G_KEEPERR | G_EVAL | G_VOID | G_DISCARD);
2855
2856 POPSTACK;
2857 SPAGAIN;
2858 FREETMPS;
2859 LEAVE;
2860 PUTBACK;
2861 }
2862
2863 if (!(coro->flags & CF_RUNNING))
2864 {
2865 save_perl (aTHX_ coro);
2866 load_perl (aTHX_ &temp);
386 SPAGAIN; 2867 SPAGAIN;
387 } 2868 }
388 else
389 {
390 /*
391 * emulate part of the perl startup here.
392 */
393 UNOP myop;
394
395 init_stacks ();
396 PL_op = (OP *)&myop;
397 /*PL_curcop = 0;*/
398 GvAV (PL_defgv) = (SV *)SvREFCNT_inc (next->args);
399
400 SPAGAIN;
401 Zero(&myop, 1, UNOP);
402 myop.op_next = Nullop;
403 myop.op_flags = OPf_WANT_VOID;
404
405 PUSHMARK(SP);
406 XPUSHs ((SV*)get_cv(SUB_INIT, TRUE));
407 PUTBACK;
408 /*
409 * the next line is slightly wrong, as PL_op->op_next
410 * is actually being executed so we skip the first op.
411 * that doesn't matter, though, since it is only
412 * pp_nextstate and we never return...
413 */
414 PL_op = Perl_pp_entersub(aTHX);
415 SPAGAIN;
416
417 ENTER;
418 }
419 } 2869 }
2870}
2871
2872SV *
2873is_ready (Coro::State coro)
2874 PROTOTYPE: $
2875 ALIAS:
2876 is_ready = CF_READY
2877 is_running = CF_RUNNING
2878 is_new = CF_NEW
2879 is_destroyed = CF_DESTROYED
2880 CODE:
2881 RETVAL = boolSV (coro->flags & ix);
2882 OUTPUT:
2883 RETVAL
420 2884
421void 2885void
422DESTROY(coro) 2886throw (Coro::State self, SV *throw = &PL_sv_undef)
423 Coro::State coro 2887 PROTOTYPE: $;$
424 CODE: 2888 CODE:
2889{
2890 struct coro *current = SvSTATE_current;
2891 SV **throwp = self == current ? &CORO_THROW : &self->except;
2892 SvREFCNT_dec (*throwp);
2893 *throwp = SvOK (throw) ? newSVsv (throw) : 0;
2894}
425 2895
426 if (coro->mainstack) 2896void
2897api_trace (SV *coro, int flags = CC_TRACE | CC_TRACE_SUB)
2898 PROTOTYPE: $;$
2899 C_ARGS: aTHX_ coro, flags
2900
2901SV *
2902has_cctx (Coro::State coro)
2903 PROTOTYPE: $
2904 CODE:
2905 RETVAL = boolSV (!!coro->cctx);
2906 OUTPUT:
2907 RETVAL
2908
2909int
2910is_traced (Coro::State coro)
2911 PROTOTYPE: $
2912 CODE:
2913 RETVAL = (coro->cctx ? coro->cctx->flags : 0) & CC_TRACE_ALL;
2914 OUTPUT:
2915 RETVAL
2916
2917UV
2918rss (Coro::State coro)
2919 PROTOTYPE: $
2920 ALIAS:
2921 usecount = 1
2922 CODE:
2923 switch (ix)
2924 {
2925 case 0: RETVAL = coro_rss (aTHX_ coro); break;
2926 case 1: RETVAL = coro->usecount; break;
2927 }
2928 OUTPUT:
2929 RETVAL
2930
2931void
2932force_cctx ()
2933 PROTOTYPE:
2934 CODE:
2935 SvSTATE_current->cctx->idle_sp = 0;
2936
2937void
2938swap_defsv (Coro::State self)
2939 PROTOTYPE: $
2940 ALIAS:
2941 swap_defav = 1
2942 CODE:
2943 if (!self->slot)
2944 croak ("cannot swap state with coroutine that has no saved state,");
2945 else
427 { 2946 {
428 struct coro temp; 2947 SV **src = ix ? (SV **)&GvAV (PL_defgv) : &GvSV (PL_defgv);
2948 SV **dst = ix ? (SV **)&self->slot->defav : (SV **)&self->slot->defsv;
429 2949
2950 SV *tmp = *src; *src = *dst; *dst = tmp;
2951 }
2952
2953
2954MODULE = Coro::State PACKAGE = Coro
2955
2956BOOT:
2957{
2958 int i;
2959
2960 av_async_pool = coro_get_av (aTHX_ "Coro::async_pool", TRUE);
2961 sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE);
2962 sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE);
2963 cv_coro_run = get_cv ( "Coro::_terminate", GV_ADD);
2964 cv_coro_terminate = get_cv ( "Coro::terminate", GV_ADD);
2965 coro_current = coro_get_sv (aTHX_ "Coro::current" , FALSE);
2966 SvREADONLY_on (coro_current);
2967
2968 sv_async_pool_idle = newSVpv ("[async pool idle]", 0); SvREADONLY_on (sv_async_pool_idle);
2969 sv_Coro = newSVpv ("Coro", 0); SvREADONLY_on (sv_Coro);
2970 cv_pool_handler = get_cv ("Coro::_pool_handler", 0); SvREADONLY_on (cv_pool_handler);
2971 cv_coro_new = get_cv ("Coro::new", 0); SvREADONLY_on (cv_coro_new);
2972
2973 coro_stash = gv_stashpv ("Coro", TRUE);
2974
2975 newCONSTSUB (coro_stash, "PRIO_MAX", newSViv (PRIO_MAX));
2976 newCONSTSUB (coro_stash, "PRIO_HIGH", newSViv (PRIO_HIGH));
2977 newCONSTSUB (coro_stash, "PRIO_NORMAL", newSViv (PRIO_NORMAL));
2978 newCONSTSUB (coro_stash, "PRIO_LOW", newSViv (PRIO_LOW));
2979 newCONSTSUB (coro_stash, "PRIO_IDLE", newSViv (PRIO_IDLE));
2980 newCONSTSUB (coro_stash, "PRIO_MIN", newSViv (PRIO_MIN));
2981
2982 for (i = PRIO_MAX - PRIO_MIN + 1; i--; )
2983 coro_ready[i] = newAV ();
2984
2985 {
2986 SV *sv = coro_get_sv (aTHX_ "Coro::API", TRUE);
2987
2988 coroapi.schedule = api_schedule;
2989 coroapi.cede = api_cede;
2990 coroapi.cede_notself = api_cede_notself;
2991 coroapi.ready = api_ready;
2992 coroapi.is_ready = api_is_ready;
2993 coroapi.nready = coro_nready;
2994 coroapi.current = coro_current;
2995
2996 /*GCoroAPI = &coroapi;*/
2997 sv_setiv (sv, (IV)&coroapi);
2998 SvREADONLY_on (sv);
2999 }
3000}
3001
3002void
3003schedule (...)
3004 CODE:
3005 CORO_EXECUTE_SLF_XS (slf_init_schedule);
3006
3007void
3008cede (...)
3009 CODE:
3010 CORO_EXECUTE_SLF_XS (slf_init_cede);
3011
3012void
3013cede_notself (...)
3014 CODE:
3015 CORO_EXECUTE_SLF_XS (slf_init_cede_notself);
3016
3017void
3018_set_current (SV *current)
3019 PROTOTYPE: $
3020 CODE:
3021 SvREFCNT_dec (SvRV (coro_current));
3022 SvRV_set (coro_current, SvREFCNT_inc_NN (SvRV (current)));
3023
3024void
3025_set_readyhook (SV *hook)
3026 PROTOTYPE: $
3027 CODE:
3028 SvREFCNT_dec (coro_readyhook);
3029 coro_readyhook = SvOK (hook) ? newSVsv (hook) : 0;
3030
3031int
3032prio (Coro::State coro, int newprio = 0)
3033 PROTOTYPE: $;$
3034 ALIAS:
3035 nice = 1
3036 CODE:
3037{
3038 RETVAL = coro->prio;
3039
3040 if (items > 1)
3041 {
3042 if (ix)
3043 newprio = coro->prio - newprio;
3044
3045 if (newprio < PRIO_MIN) newprio = PRIO_MIN;
3046 if (newprio > PRIO_MAX) newprio = PRIO_MAX;
3047
3048 coro->prio = newprio;
3049 }
3050}
3051 OUTPUT:
3052 RETVAL
3053
3054SV *
3055ready (SV *self)
3056 PROTOTYPE: $
3057 CODE:
3058 RETVAL = boolSV (api_ready (aTHX_ self));
3059 OUTPUT:
3060 RETVAL
3061
3062int
3063nready (...)
3064 PROTOTYPE:
3065 CODE:
3066 RETVAL = coro_nready;
3067 OUTPUT:
3068 RETVAL
3069
3070void
3071_pool_handler (...)
3072 CODE:
3073 CORO_EXECUTE_SLF_XS (slf_init_pool_handler);
3074
3075void
3076async_pool (SV *cv, ...)
3077 PROTOTYPE: &@
3078 PPCODE:
3079{
3080 HV *hv = (HV *)av_pop (av_async_pool);
3081 AV *av = newAV ();
3082 SV *cb = ST (0);
3083 int i;
3084
3085 av_extend (av, items - 2);
3086 for (i = 1; i < items; ++i)
3087 av_push (av, SvREFCNT_inc_NN (ST (i)));
3088
3089 if ((SV *)hv == &PL_sv_undef)
3090 {
3091 PUSHMARK (SP);
3092 EXTEND (SP, 2);
3093 PUSHs (sv_Coro);
3094 PUSHs ((SV *)cv_pool_handler);
430 PUTBACK; 3095 PUTBACK;
431 SAVE(aTHX_ (&temp)); 3096 call_sv (cv_coro_new, G_SCALAR);
432 LOAD(aTHX_ coro);
433
434 S_nuke_stacks ();
435 SvREFCNT_dec ((SV *)GvAV (PL_defgv));
436
437 LOAD((&temp));
438 SPAGAIN; 3097 SPAGAIN;
3098
3099 hv = (HV *)SvREFCNT_inc_NN (SvRV (POPs));
439 } 3100 }
440 3101
3102 {
3103 struct coro *coro = SvSTATE_hv (hv);
3104
3105 assert (!coro->invoke_cb);
3106 assert (!coro->invoke_av);
3107 coro->invoke_cb = SvREFCNT_inc (cb);
3108 coro->invoke_av = av;
3109 }
3110
3111 api_ready ((SV *)hv);
3112
3113 if (GIMME_V != G_VOID)
3114 XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv)));
3115 else
441 SvREFCNT_dec (coro->args); 3116 SvREFCNT_dec (hv);
442 Safefree (coro); 3117}
443 3118
3119SV *
3120rouse_cb ()
3121 PROTOTYPE:
3122 CODE:
3123 RETVAL = coro_new_rouse_cb (aTHX);
3124 OUTPUT:
3125 RETVAL
444 3126
3127void
3128rouse_wait (...)
3129 PROTOTYPE: ;$
3130 PPCODE:
3131 CORO_EXECUTE_SLF_XS (slf_init_rouse_wait);
3132
3133
3134MODULE = Coro::State PACKAGE = PerlIO::cede
3135
3136BOOT:
3137 PerlIO_define_layer (aTHX_ &PerlIO_cede);
3138
3139
3140MODULE = Coro::State PACKAGE = Coro::Semaphore
3141
3142SV *
3143new (SV *klass, SV *count = 0)
3144 CODE:
3145 RETVAL = sv_bless (
3146 coro_waitarray_new (aTHX_ count && SvOK (count) ? SvIV (count) : 1),
3147 GvSTASH (CvGV (cv))
3148 );
3149 OUTPUT:
3150 RETVAL
3151
3152# helper for Coro::Channel
3153SV *
3154_alloc (int count)
3155 CODE:
3156 RETVAL = coro_waitarray_new (aTHX_ count);
3157 OUTPUT:
3158 RETVAL
3159
3160SV *
3161count (SV *self)
3162 CODE:
3163 RETVAL = newSVsv (AvARRAY ((AV *)SvRV (self))[0]);
3164 OUTPUT:
3165 RETVAL
3166
3167void
3168up (SV *self, int adjust = 1)
3169 ALIAS:
3170 adjust = 1
3171 CODE:
3172 coro_semaphore_adjust (aTHX_ (AV *)SvRV (self), ix ? adjust : 1);
3173
3174void
3175down (...)
3176 CODE:
3177 CORO_EXECUTE_SLF_XS (slf_init_semaphore_down);
3178
3179void
3180wait (...)
3181 CODE:
3182 CORO_EXECUTE_SLF_XS (slf_init_semaphore_wait);
3183
3184void
3185try (SV *self)
3186 PPCODE:
3187{
3188 AV *av = (AV *)SvRV (self);
3189 SV *count_sv = AvARRAY (av)[0];
3190 IV count = SvIVX (count_sv);
3191
3192 if (count > 0)
3193 {
3194 --count;
3195 SvIVX (count_sv) = count;
3196 XSRETURN_YES;
3197 }
3198 else
3199 XSRETURN_NO;
3200}
3201
3202void
3203waiters (SV *self)
3204 PPCODE:
3205{
3206 AV *av = (AV *)SvRV (self);
3207 int wcount = AvFILLp (av) + 1 - 1;
3208
3209 if (GIMME_V == G_SCALAR)
3210 XPUSHs (sv_2mortal (newSViv (wcount)));
3211 else
3212 {
3213 int i;
3214 EXTEND (SP, wcount);
3215 for (i = 1; i <= wcount; ++i)
3216 PUSHs (sv_2mortal (newRV_inc (AvARRAY (av)[i])));
3217 }
3218}
3219
3220MODULE = Coro::State PACKAGE = Coro::Signal
3221
3222SV *
3223new (SV *klass)
3224 CODE:
3225 RETVAL = sv_bless (
3226 coro_waitarray_new (aTHX_ 0),
3227 GvSTASH (CvGV (cv))
3228 );
3229 OUTPUT:
3230 RETVAL
3231
3232void
3233wait (...)
3234 CODE:
3235 CORO_EXECUTE_SLF_XS (slf_init_signal_wait);
3236
3237void
3238broadcast (SV *self)
3239 CODE:
3240{
3241 AV *av = (AV *)SvRV (self);
3242 coro_signal_wake (aTHX_ av, AvFILLp (av));
3243}
3244
3245void
3246send (SV *self)
3247 CODE:
3248{
3249 AV *av = (AV *)SvRV (self);
3250
3251 if (AvFILLp (av))
3252 coro_signal_wake (aTHX_ av, 1);
3253 else
3254 SvIVX (AvARRAY (av)[0]) = 1; /* remember the signal */
3255}
3256
3257IV
3258awaited (SV *self)
3259 CODE:
3260 RETVAL = AvFILLp ((AV *)SvRV (self)) + 1 - 1;
3261 OUTPUT:
3262 RETVAL
3263
3264
3265MODULE = Coro::State PACKAGE = Coro::AnyEvent
3266
3267BOOT:
3268 sv_activity = coro_get_sv (aTHX_ "Coro::AnyEvent::ACTIVITY", TRUE);
3269
3270void
3271_schedule (...)
3272 CODE:
3273{
3274 static int incede;
3275
3276 api_cede_notself (aTHX);
3277
3278 ++incede;
3279 while (coro_nready >= incede && api_cede (aTHX))
3280 ;
3281
3282 sv_setsv (sv_activity, &PL_sv_undef);
3283 if (coro_nready >= incede)
3284 {
3285 PUSHMARK (SP);
3286 PUTBACK;
3287 call_pv ("Coro::AnyEvent::_activity", G_KEEPERR | G_EVAL | G_VOID | G_DISCARD);
3288 }
3289
3290 --incede;
3291}
3292
3293
3294MODULE = Coro::State PACKAGE = Coro::AIO
3295
3296void
3297_register (char *target, char *proto, SV *req)
3298 CODE:
3299{
3300 CV *req_cv = coro_sv_2cv (aTHX_ req);
3301 /* newXSproto doesn't return the CV on 5.8 */
3302 CV *slf_cv = newXS (target, coro_aio_req_xs, __FILE__);
3303 sv_setpv ((SV *)slf_cv, proto);
3304 sv_magicext ((SV *)slf_cv, (SV *)req_cv, CORO_MAGIC_type_aio, 0, 0, 0);
3305}
3306

Diff Legend

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