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.5 by root, Tue Jul 17 02:55:29 2001 UTC vs.
Revision 1.313 by root, Thu Nov 20 03:22:59 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
162/* the next tow functions merely cache the padlists */ 533 slf_frame = c->slf_frame;
163STATIC void 534 CORO_THROW = c->except;
164get_padlist (CV *cv)
165{
166 SV **he = hv_fetch (padlist_cache, (void *)&cv, sizeof (CV *), 0);
167
168 if (he && AvFILLp ((AV *)*he) >= 0)
169 CvPADLIST (cv) = (AV *)av_pop ((AV *)*he);
170 else
171 CvPADLIST (cv) = clone_padlist (CvPADLIST (cv));
172} 535}
173 536
174STATIC void
175put_padlist (CV *cv)
176{
177 SV **he = hv_fetch (padlist_cache, (void *)&cv, sizeof (CV *), 1);
178
179 if (SvTYPE (*he) != SVt_PVAV)
180 {
181 SvREFCNT_dec (*he);
182 *he = (SV *)newAV ();
183 }
184
185 av_push ((AV *)*he, (SV *)CvPADLIST (cv));
186}
187
188static void 537static void
189SAVE(pTHX_ Coro__State c) 538save_perl (pTHX_ Coro__State c)
190{ 539{
540 c->except = CORO_THROW;
541 c->slf_frame = slf_frame;
542
191 { 543 {
192 dSP; 544 dSP;
193 I32 cxix = cxstack_ix; 545 I32 cxix = cxstack_ix;
546 PERL_CONTEXT *ccstk = cxstack;
194 PERL_SI *top_si = PL_curstackinfo; 547 PERL_SI *top_si = PL_curstackinfo;
195 PERL_CONTEXT *ccstk = cxstack;
196 548
197 /* 549 /*
198 * 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
199 * (and reinitialize) all cv's in the whole callchain :( 551 * (and reinitialize) all cv's in the whole callchain :(
200 */ 552 */
201 553
202 PUSHs (Nullsv); 554 XPUSHs (Nullsv);
203 /* this loop was inspired by pp_caller */ 555 /* this loop was inspired by pp_caller */
204 for (;;) 556 for (;;)
205 { 557 {
206 while (cxix >= 0) 558 while (expect_true (cxix >= 0))
207 { 559 {
208 PERL_CONTEXT *cx = &ccstk[cxix--]; 560 PERL_CONTEXT *cx = &ccstk[cxix--];
209 561
210 if (CxTYPE(cx) == CXt_SUB) 562 if (expect_true (CxTYPE (cx) == CXt_SUB || CxTYPE (cx) == CXt_FORMAT))
211 { 563 {
212 CV *cv = cx->blk_sub.cv; 564 CV *cv = cx->blk_sub.cv;
565
213 if (CvDEPTH(cv)) 566 if (expect_true (CvDEPTH (cv)))
214 { 567 {
215#ifdef USE_THREADS
216 XPUSHs ((SV *)CvOWNER(cv));
217#endif
218 EXTEND (SP, 3); 568 EXTEND (SP, 3);
219 PUSHs ((SV *)CvDEPTH(cv));
220 PUSHs ((SV *)CvPADLIST(cv)); 569 PUSHs ((SV *)CvPADLIST (cv));
570 PUSHs (INT2PTR (SV *, (IV)CvDEPTH (cv)));
221 PUSHs ((SV *)cv); 571 PUSHs ((SV *)cv);
222 572
223 get_padlist (cv);
224
225 CvDEPTH(cv) = 0; 573 CvDEPTH (cv) = 0;
226#ifdef USE_THREADS 574 get_padlist (aTHX_ cv);
227 CvOWNER(cv) = 0;
228 error must unlock this cv etc.. etc...
229 if you are here wondering about this error message then
230 the reason is that it will not work as advertised yet
231#endif
232 } 575 }
233 } 576 }
234 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 hv_store (hv, "desc", sizeof ("desc") - 1,
1766 newSVpvn ("[async_pool]", sizeof ("[async_pool]") - 1), 0);
1767
1768 coro->saved_deffh = SvREFCNT_inc_NN ((SV *)PL_defoutgv);
1769
1770 {
1771 dSP;
1772 XPUSHs (sv_2mortal (coro->invoke_cb)); coro->invoke_cb = 0;
1773 PUTBACK;
1774 }
1775
1776 SvREFCNT_dec (GvAV (PL_defgv));
1777 GvAV (PL_defgv) = coro->invoke_av;
1778 coro->invoke_av = 0;
1779
1780 return 0;
1781 }
1782}
1783
1784static void
1785slf_init_pool_handler (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
1786{
1787 HV *hv = (HV *)SvRV (coro_current);
1788 struct coro *coro = SvSTATE_hv ((SV *)hv);
1789
1790 if (expect_true (coro->saved_deffh))
1791 {
1792 /* subsequent iteration */
1793 SvREFCNT_dec ((SV *)PL_defoutgv); PL_defoutgv = (GV *)coro->saved_deffh;
1794 coro->saved_deffh = 0;
1795
1796 if (coro_rss (aTHX_ coro) > SvUV (sv_pool_rss)
1797 || av_len (av_async_pool) + 1 >= SvIV (sv_pool_size))
1798 {
1799 coro->invoke_cb = SvREFCNT_inc_NN ((SV *)cv_coro_terminate);
1800 coro->invoke_av = newAV ();
1801
1802 frame->prepare = prepare_nop;
1803 }
1804 else
1805 {
1806 av_clear (GvAV (PL_defgv));
1807 hv_store (hv, "desc", sizeof ("desc") - 1, SvREFCNT_inc_NN (sv_async_pool_idle), 0);
1808
1809 coro->prio = 0;
1810
1811 if (coro->cctx && (coro->cctx->flags & CC_TRACE))
1812 api_trace (aTHX_ coro_current, 0);
1813
1814 frame->prepare = prepare_schedule;
1815 av_push (av_async_pool, SvREFCNT_inc (hv));
1816 }
1817 }
1818 else
1819 {
1820 /* first iteration, simply fall through */
1821 frame->prepare = prepare_nop;
1822 }
1823
1824 frame->check = slf_check_pool_handler;
1825 frame->data = (void *)coro;
1826}
1827
1828/*****************************************************************************/
1829/* rouse callback */
1830
1831#define CORO_MAGIC_type_rouse PERL_MAGIC_ext
1832
1833static void
1834coro_rouse_callback (pTHX_ CV *cv)
1835{
1836 dXSARGS;
1837 SV *data = (SV *)GENSUB_ARG;
1838
1839 if (SvTYPE (SvRV (data)) != SVt_PVAV)
1840 {
1841 /* first call, set args */
1842 AV *av = newAV ();
1843 SV *coro = SvRV (data);
1844
1845 SvRV_set (data, (SV *)av);
1846 api_ready (aTHX_ coro);
1847 SvREFCNT_dec (coro);
1848
1849 /* better take a full copy of the arguments */
1850 while (items--)
1851 av_store (av, items, newSVsv (ST (items)));
1852 }
1853
1854 XSRETURN_EMPTY;
1855}
1856
1857static int
1858slf_check_rouse_wait (pTHX_ struct CoroSLF *frame)
1859{
1860 SV *data = (SV *)frame->data;
1861
1862 if (CORO_THROW)
1863 return 0;
1864
1865 if (SvTYPE (SvRV (data)) != SVt_PVAV)
1866 return 1;
1867
1868 /* now push all results on the stack */
1869 {
1870 dSP;
1871 AV *av = (AV *)SvRV (data);
1872 int i;
1873
1874 EXTEND (SP, AvFILLp (av) + 1);
1875 for (i = 0; i <= AvFILLp (av); ++i)
1876 PUSHs (sv_2mortal (AvARRAY (av)[i]));
1877
1878 /* we have stolen the elements, so ste length to zero and free */
1879 AvFILLp (av) = -1;
1880 av_undef (av);
1881
1882 PUTBACK;
1883 }
1884
1885 return 0;
1886}
1887
1888static void
1889slf_init_rouse_wait (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
1890{
1891 SV *cb;
1892
1893 if (items)
1894 cb = arg [0];
1895 else
1896 {
1897 struct coro *coro = SvSTATE_current;
1898
1899 if (!coro->rouse_cb)
1900 croak ("Coro::rouse_wait called without rouse callback, and no default rouse callback found either,");
1901
1902 cb = sv_2mortal (coro->rouse_cb);
1903 coro->rouse_cb = 0;
1904 }
1905
1906 if (!SvROK (cb)
1907 || SvTYPE (SvRV (cb)) != SVt_PVCV
1908 || CvXSUB ((CV *)SvRV (cb)) != coro_rouse_callback)
1909 croak ("Coro::rouse_wait called with illegal callback argument,");
1910
1911 {
1912 CV *cv = (CV *)SvRV (cb); /* for GENSUB_ARG */
1913 SV *data = (SV *)GENSUB_ARG;
1914
1915 frame->data = (void *)data;
1916 frame->prepare = SvTYPE (SvRV (data)) == SVt_PVAV ? prepare_nop : prepare_schedule;
1917 frame->check = slf_check_rouse_wait;
1918 }
1919}
1920
1921static SV *
1922coro_new_rouse_cb (pTHX)
1923{
1924 HV *hv = (HV *)SvRV (coro_current);
1925 struct coro *coro = SvSTATE_hv (hv);
1926 SV *data = newRV_inc ((SV *)hv);
1927 SV *cb = gensub (aTHX_ coro_rouse_callback, (void *)data);
1928
1929 sv_magicext (SvRV (cb), data, CORO_MAGIC_type_rouse, 0, 0, 0);
1930 SvREFCNT_dec (data); /* magicext increases the refcount */
1931
1932 SvREFCNT_dec (coro->rouse_cb);
1933 coro->rouse_cb = SvREFCNT_inc_NN (cb);
1934
1935 return cb;
1936}
1937
1938/*****************************************************************************/
1939/* schedule-like-function opcode (SLF) */
1940
1941static UNOP slf_restore; /* restore stack as entersub did, for first-re-run */
1942static const CV *slf_cv;
1943static SV **slf_argv;
1944static int slf_argc, slf_arga; /* count, allocated */
1945static I32 slf_ax; /* top of stack, for restore */
1946
1947/* this restores the stack in the case we patched the entersub, to */
1948/* recreate the stack frame as perl will on following calls */
1949/* since entersub cleared the stack */
1950static OP *
1951pp_restore (pTHX)
1952{
1953 int i;
1954 SV **SP = PL_stack_base + slf_ax;
1955
1956 PUSHMARK (SP);
1957
1958 EXTEND (SP, slf_argc + 1);
1959
1960 for (i = 0; i < slf_argc; ++i)
1961 PUSHs (sv_2mortal (slf_argv [i]));
1962
1963 PUSHs ((SV *)CvGV (slf_cv));
1964
1965 RETURNOP (slf_restore.op_first);
1966}
1967
1968static void
1969slf_prepare_transfer (pTHX_ struct coro_transfer_args *ta)
1970{
1971 SV **arg = (SV **)slf_frame.data;
1972
1973 prepare_transfer (aTHX_ ta, arg [0], arg [1]);
1974}
1975
1976static void
1977slf_init_transfer (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
1978{
1979 if (items != 2)
1980 croak ("Coro::State::transfer (prev, next) expects two arguments, not %d,", items);
1981
1982 frame->prepare = slf_prepare_transfer;
1983 frame->check = slf_check_nop;
1984 frame->data = (void *)arg; /* let's hope it will stay valid */
1985}
1986
1987static void
1988slf_init_schedule (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
1989{
1990 frame->prepare = prepare_schedule;
1991 frame->check = slf_check_nop;
1992}
1993
1994static void
1995slf_init_cede (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
1996{
1997 frame->prepare = prepare_cede;
1998 frame->check = slf_check_nop;
1999}
2000
2001static void
2002slf_init_cede_notself (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2003{
2004 frame->prepare = prepare_cede_notself;
2005 frame->check = slf_check_nop;
2006}
2007
2008/*
2009 * these not obviously related functions are all rolled into one
2010 * function to increase chances that they all will call transfer with the same
2011 * stack offset
2012 * SLF stands for "schedule-like-function".
2013 */
2014static OP *
2015pp_slf (pTHX)
2016{
2017 I32 checkmark; /* mark SP to see how many elements check has pushed */
2018
2019 /* set up the slf frame, unless it has already been set-up */
2020 /* the latter happens when a new coro has been started */
2021 /* or when a new cctx was attached to an existing coroutine */
2022 if (expect_true (!slf_frame.prepare))
2023 {
2024 /* first iteration */
2025 dSP;
2026 SV **arg = PL_stack_base + TOPMARK + 1;
2027 int items = SP - arg; /* args without function object */
2028 SV *gv = *sp;
2029
2030 /* do a quick consistency check on the "function" object, and if it isn't */
2031 /* for us, divert to the real entersub */
2032 if (SvTYPE (gv) != SVt_PVGV
2033 || !GvCV (gv)
2034 || !(CvFLAGS (GvCV (gv)) & CVf_SLF))
2035 return PL_ppaddr[OP_ENTERSUB](aTHX);
2036
2037 if (!(PL_op->op_flags & OPf_STACKED))
2038 {
2039 /* ampersand-form of call, use @_ instead of stack */
2040 AV *av = GvAV (PL_defgv);
2041 arg = AvARRAY (av);
2042 items = AvFILLp (av) + 1;
2043 }
2044
2045 /* now call the init function, which needs to set up slf_frame */
2046 ((coro_slf_cb)CvXSUBANY (GvCV (gv)).any_ptr)
2047 (aTHX_ &slf_frame, GvCV (gv), arg, items);
2048
2049 /* pop args */
2050 SP = PL_stack_base + POPMARK;
2051
2052 PUTBACK;
2053 }
2054
2055 /* now that we have a slf_frame, interpret it! */
2056 /* we use a callback system not to make the code needlessly */
2057 /* complicated, but so we can run multiple perl coros from one cctx */
2058
2059 do
2060 {
2061 struct coro_transfer_args ta;
2062
2063 slf_frame.prepare (aTHX_ &ta);
2064 TRANSFER (ta, 0);
2065
2066 checkmark = PL_stack_sp - PL_stack_base;
2067 }
2068 while (slf_frame.check (aTHX_ &slf_frame));
2069
2070 slf_frame.prepare = 0; /* invalidate the frame, we are done processing it */
2071
2072 /* exception handling */
2073 if (expect_false (CORO_THROW))
2074 {
2075 SV *exception = sv_2mortal (CORO_THROW);
2076
2077 CORO_THROW = 0;
2078 sv_setsv (ERRSV, exception);
2079 croak (0);
2080 }
2081
2082 /* return value handling - mostly like entersub */
2083 /* make sure we put something on the stack in scalar context */
2084 if (GIMME_V == G_SCALAR)
2085 {
2086 dSP;
2087 SV **bot = PL_stack_base + checkmark;
2088
2089 if (sp == bot) /* too few, push undef */
2090 bot [1] = &PL_sv_undef;
2091 else if (sp != bot + 1) /* too many, take last one */
2092 bot [1] = *sp;
2093
2094 SP = bot + 1;
2095
2096 PUTBACK;
2097 }
2098
2099 return NORMAL;
2100}
2101
2102static void
2103api_execute_slf (pTHX_ CV *cv, coro_slf_cb init_cb, I32 ax)
2104{
2105 int i;
2106 SV **arg = PL_stack_base + ax;
2107 int items = PL_stack_sp - arg + 1;
2108
2109 assert (("FATAL: SLF call with illegal CV value", !CvANON (cv)));
2110
2111 if (PL_op->op_ppaddr != PL_ppaddr [OP_ENTERSUB]
2112 && PL_op->op_ppaddr != pp_slf)
2113 croak ("FATAL: Coro SLF calls can only be made normally, not via goto or any other means, caught");
2114
2115 CvFLAGS (cv) |= CVf_SLF;
2116 CvXSUBANY (cv).any_ptr = (void *)init_cb;
2117 slf_cv = cv;
2118
2119 /* we patch the op, and then re-run the whole call */
2120 /* we have to put the same argument on the stack for this to work */
2121 /* and this will be done by pp_restore */
2122 slf_restore.op_next = (OP *)&slf_restore;
2123 slf_restore.op_type = OP_CUSTOM;
2124 slf_restore.op_ppaddr = pp_restore;
2125 slf_restore.op_first = PL_op;
2126
2127 slf_ax = ax - 1; /* undo the ax++ inside dAXMARK */
2128
2129 if (PL_op->op_flags & OPf_STACKED)
2130 {
2131 if (items > slf_arga)
2132 {
2133 slf_arga = items;
2134 free (slf_argv);
2135 slf_argv = malloc (slf_arga * sizeof (SV *));
2136 }
2137
2138 slf_argc = items;
2139
2140 for (i = 0; i < items; ++i)
2141 slf_argv [i] = SvREFCNT_inc (arg [i]);
2142 }
2143 else
2144 slf_argc = 0;
2145
2146 PL_op->op_ppaddr = pp_slf;
2147 PL_op->op_type = OP_CUSTOM; /* maybe we should leave it at entersub? */
2148
2149 PL_op = (OP *)&slf_restore;
2150}
2151
2152/*****************************************************************************/
2153/* PerlIO::cede */
2154
2155typedef struct
2156{
2157 PerlIOBuf base;
2158 NV next, every;
2159} PerlIOCede;
2160
2161static IV
2162PerlIOCede_pushed (pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
2163{
2164 PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
2165
2166 self->every = SvCUR (arg) ? SvNV (arg) : 0.01;
2167 self->next = nvtime () + self->every;
2168
2169 return PerlIOBuf_pushed (aTHX_ f, mode, Nullsv, tab);
2170}
2171
2172static SV *
2173PerlIOCede_getarg (pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)
2174{
2175 PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
2176
2177 return newSVnv (self->every);
2178}
2179
2180static IV
2181PerlIOCede_flush (pTHX_ PerlIO *f)
2182{
2183 PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
2184 double now = nvtime ();
2185
2186 if (now >= self->next)
2187 {
2188 api_cede (aTHX);
2189 self->next = now + self->every;
2190 }
2191
2192 return PerlIOBuf_flush (aTHX_ f);
2193}
2194
2195static PerlIO_funcs PerlIO_cede =
2196{
2197 sizeof(PerlIO_funcs),
2198 "cede",
2199 sizeof(PerlIOCede),
2200 PERLIO_K_DESTRUCT | PERLIO_K_RAW,
2201 PerlIOCede_pushed,
2202 PerlIOBuf_popped,
2203 PerlIOBuf_open,
2204 PerlIOBase_binmode,
2205 PerlIOCede_getarg,
2206 PerlIOBase_fileno,
2207 PerlIOBuf_dup,
2208 PerlIOBuf_read,
2209 PerlIOBuf_unread,
2210 PerlIOBuf_write,
2211 PerlIOBuf_seek,
2212 PerlIOBuf_tell,
2213 PerlIOBuf_close,
2214 PerlIOCede_flush,
2215 PerlIOBuf_fill,
2216 PerlIOBase_eof,
2217 PerlIOBase_error,
2218 PerlIOBase_clearerr,
2219 PerlIOBase_setlinebuf,
2220 PerlIOBuf_get_base,
2221 PerlIOBuf_bufsiz,
2222 PerlIOBuf_get_ptr,
2223 PerlIOBuf_get_cnt,
2224 PerlIOBuf_set_ptrcnt,
2225};
2226
2227/*****************************************************************************/
2228/* Coro::Semaphore & Coro::Signal */
2229
2230static SV *
2231coro_waitarray_new (pTHX_ int count)
2232{
2233 /* a semaphore contains a counter IV in $sem->[0] and any waiters after that */
2234 AV *av = newAV ();
2235 SV **ary;
2236
2237 /* unfortunately, building manually saves memory */
2238 Newx (ary, 2, SV *);
2239 AvALLOC (av) = ary;
2240 /*AvARRAY (av) = ary;*/
2241 SvPVX ((SV *)av) = (char *)ary; /* 5.8.8 needs this syntax instead of AvARRAY = ary */
2242 AvMAX (av) = 1;
2243 AvFILLp (av) = 0;
2244 ary [0] = newSViv (count);
2245
2246 return newRV_noinc ((SV *)av);
2247}
2248
2249/* semaphore */
2250
2251static void
2252coro_semaphore_adjust (pTHX_ AV *av, IV adjust)
2253{
2254 SV *count_sv = AvARRAY (av)[0];
2255 IV count = SvIVX (count_sv);
2256
2257 count += adjust;
2258 SvIVX (count_sv) = count;
2259
2260 /* now wake up as many waiters as are expected to lock */
2261 while (count > 0 && AvFILLp (av) > 0)
2262 {
2263 SV *cb;
2264
2265 /* swap first two elements so we can shift a waiter */
2266 AvARRAY (av)[0] = AvARRAY (av)[1];
2267 AvARRAY (av)[1] = count_sv;
2268 cb = av_shift (av);
2269
2270 if (SvOBJECT (cb))
2271 {
2272 api_ready (aTHX_ cb);
2273 --count;
2274 }
2275 else if (SvTYPE (cb) == SVt_PVCV)
2276 {
2277 dSP;
2278 PUSHMARK (SP);
2279 XPUSHs (sv_2mortal (newRV_inc ((SV *)av)));
2280 PUTBACK;
2281 call_sv (cb, G_VOID | G_DISCARD | G_EVAL | G_KEEPERR);
2282 }
2283
2284 SvREFCNT_dec (cb);
2285 }
2286}
2287
2288static void
2289coro_semaphore_on_destroy (pTHX_ struct coro *coro)
2290{
2291 /* call $sem->adjust (0) to possibly wake up some other waiters */
2292 coro_semaphore_adjust (aTHX_ (AV *)coro->slf_frame.data, 0);
2293}
2294
2295static int
2296slf_check_semaphore_down_or_wait (pTHX_ struct CoroSLF *frame, int acquire)
2297{
2298 AV *av = (AV *)frame->data;
2299 SV *count_sv = AvARRAY (av)[0];
2300
2301 /* if we are about to throw, don't actually acquire the lock, just throw */
2302 if (CORO_THROW)
2303 return 0;
2304 else if (SvIVX (count_sv) > 0)
2305 {
2306 SvSTATE_current->on_destroy = 0;
2307
2308 if (acquire)
2309 SvIVX (count_sv) = SvIVX (count_sv) - 1;
2310 else
2311 coro_semaphore_adjust (aTHX_ av, 0);
2312
2313 return 0;
2314 }
2315 else
2316 {
2317 int i;
2318 /* if we were woken up but can't down, we look through the whole */
2319 /* waiters list and only add us if we aren't in there already */
2320 /* this avoids some degenerate memory usage cases */
2321
2322 for (i = 1; i <= AvFILLp (av); ++i)
2323 if (AvARRAY (av)[i] == SvRV (coro_current))
2324 return 1;
2325
2326 av_push (av, SvREFCNT_inc (SvRV (coro_current)));
2327 return 1;
2328 }
2329}
2330
2331static int
2332slf_check_semaphore_down (pTHX_ struct CoroSLF *frame)
2333{
2334 return slf_check_semaphore_down_or_wait (aTHX_ frame, 1);
2335}
2336
2337static int
2338slf_check_semaphore_wait (pTHX_ struct CoroSLF *frame)
2339{
2340 return slf_check_semaphore_down_or_wait (aTHX_ frame, 0);
2341}
2342
2343static void
2344slf_init_semaphore_down_or_wait (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2345{
2346 AV *av = (AV *)SvRV (arg [0]);
2347
2348 if (SvIVX (AvARRAY (av)[0]) > 0)
2349 {
2350 frame->data = (void *)av;
2351 frame->prepare = prepare_nop;
2352 }
2353 else
2354 {
2355 av_push (av, SvREFCNT_inc (SvRV (coro_current)));
2356
2357 frame->data = (void *)sv_2mortal (SvREFCNT_inc ((SV *)av));
2358 frame->prepare = prepare_schedule;
2359
2360 /* to avoid race conditions when a woken-up coro gets terminated */
2361 /* we arrange for a temporary on_destroy that calls adjust (0) */
2362 SvSTATE_current->on_destroy = coro_semaphore_on_destroy;
2363 }
2364}
2365
2366static void
2367slf_init_semaphore_down (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2368{
2369 slf_init_semaphore_down_or_wait (aTHX_ frame, cv, arg, items);
2370 frame->check = slf_check_semaphore_down;
2371}
2372
2373static void
2374slf_init_semaphore_wait (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2375{
2376 if (items >= 2)
2377 {
2378 /* callback form */
2379 AV *av = (AV *)SvRV (arg [0]);
2380 CV *cb_cv = coro_sv_2cv (aTHX_ arg [1]);
2381
2382 av_push (av, (SV *)SvREFCNT_inc_NN (cb_cv));
2383
2384 if (SvIVX (AvARRAY (av)[0]) > 0)
2385 coro_semaphore_adjust (aTHX_ av, 0);
2386
2387 frame->prepare = prepare_nop;
2388 frame->check = slf_check_nop;
2389 }
2390 else
2391 {
2392 slf_init_semaphore_down_or_wait (aTHX_ frame, cv, arg, items);
2393 frame->check = slf_check_semaphore_wait;
2394 }
2395}
2396
2397/* signal */
2398
2399static void
2400coro_signal_wake (pTHX_ AV *av, int count)
2401{
2402 SvIVX (AvARRAY (av)[0]) = 0;
2403
2404 /* now signal count waiters */
2405 while (count > 0 && AvFILLp (av) > 0)
2406 {
2407 SV *cb;
2408
2409 /* swap first two elements so we can shift a waiter */
2410 cb = AvARRAY (av)[0];
2411 AvARRAY (av)[0] = AvARRAY (av)[1];
2412 AvARRAY (av)[1] = cb;
2413
2414 cb = av_shift (av);
2415
2416 api_ready (aTHX_ cb);
2417 sv_setiv (cb, 0); /* signal waiter */
2418 SvREFCNT_dec (cb);
2419
2420 --count;
2421 }
2422}
2423
2424static int
2425slf_check_signal_wait (pTHX_ struct CoroSLF *frame)
2426{
2427 /* if we are about to throw, also stop waiting */
2428 return SvROK ((SV *)frame->data) && !CORO_THROW;
2429}
2430
2431static void
2432slf_init_signal_wait (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2433{
2434 AV *av = (AV *)SvRV (arg [0]);
2435
2436 if (SvIVX (AvARRAY (av)[0]))
2437 {
2438 SvIVX (AvARRAY (av)[0]) = 0;
2439 frame->prepare = prepare_nop;
2440 frame->check = slf_check_nop;
2441 }
2442 else
2443 {
2444 SV *waiter = newRV_inc (SvRV (coro_current)); /* owned by signal av */
2445
2446 av_push (av, waiter);
2447
2448 frame->data = (void *)sv_2mortal (SvREFCNT_inc_NN (waiter)); /* owned by process */
2449 frame->prepare = prepare_schedule;
2450 frame->check = slf_check_signal_wait;
2451 }
2452}
2453
2454/*****************************************************************************/
2455/* Coro::AIO */
2456
2457#define CORO_MAGIC_type_aio PERL_MAGIC_ext
2458
2459/* helper storage struct */
2460struct io_state
2461{
2462 int errorno;
2463 I32 laststype; /* U16 in 5.10.0 */
2464 int laststatval;
2465 Stat_t statcache;
2466};
2467
2468static void
2469coro_aio_callback (pTHX_ CV *cv)
2470{
2471 dXSARGS;
2472 AV *state = (AV *)GENSUB_ARG;
2473 SV *coro = av_pop (state);
2474 SV *data_sv = newSV (sizeof (struct io_state));
2475
2476 av_extend (state, items - 1);
2477
2478 sv_upgrade (data_sv, SVt_PV);
2479 SvCUR_set (data_sv, sizeof (struct io_state));
2480 SvPOK_only (data_sv);
2481
2482 {
2483 struct io_state *data = (struct io_state *)SvPVX (data_sv);
2484
2485 data->errorno = errno;
2486 data->laststype = PL_laststype;
2487 data->laststatval = PL_laststatval;
2488 data->statcache = PL_statcache;
2489 }
2490
2491 /* now build the result vector out of all the parameters and the data_sv */
2492 {
2493 int i;
2494
2495 for (i = 0; i < items; ++i)
2496 av_push (state, SvREFCNT_inc_NN (ST (i)));
2497 }
2498
2499 av_push (state, data_sv);
2500
2501 api_ready (aTHX_ coro);
2502 SvREFCNT_dec (coro);
2503 SvREFCNT_dec ((AV *)state);
2504}
2505
2506static int
2507slf_check_aio_req (pTHX_ struct CoroSLF *frame)
2508{
2509 AV *state = (AV *)frame->data;
2510
2511 /* if we are about to throw, return early */
2512 /* this does not cancel the aio request, but at least */
2513 /* it quickly returns */
2514 if (CORO_THROW)
2515 return 0;
2516
2517 /* one element that is an RV? repeat! */
2518 if (AvFILLp (state) == 0 && SvROK (AvARRAY (state)[0]))
2519 return 1;
2520
2521 /* restore status */
2522 {
2523 SV *data_sv = av_pop (state);
2524 struct io_state *data = (struct io_state *)SvPVX (data_sv);
2525
2526 errno = data->errorno;
2527 PL_laststype = data->laststype;
2528 PL_laststatval = data->laststatval;
2529 PL_statcache = data->statcache;
2530
2531 SvREFCNT_dec (data_sv);
2532 }
2533
2534 /* push result values */
2535 {
2536 dSP;
2537 int i;
2538
2539 EXTEND (SP, AvFILLp (state) + 1);
2540 for (i = 0; i <= AvFILLp (state); ++i)
2541 PUSHs (sv_2mortal (SvREFCNT_inc_NN (AvARRAY (state)[i])));
2542
2543 PUTBACK;
2544 }
2545
2546 return 0;
2547}
2548
2549static void
2550slf_init_aio_req (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2551{
2552 AV *state = (AV *)sv_2mortal ((SV *)newAV ());
2553 SV *coro_hv = SvRV (coro_current);
2554 struct coro *coro = SvSTATE_hv (coro_hv);
2555
2556 /* put our coroutine id on the state arg */
2557 av_push (state, SvREFCNT_inc_NN (coro_hv));
2558
2559 /* first see whether we have a non-zero priority and set it as AIO prio */
2560 if (coro->prio)
2561 {
2562 dSP;
2563
2564 static SV *prio_cv;
2565 static SV *prio_sv;
2566
2567 if (expect_false (!prio_cv))
2568 {
2569 prio_cv = (SV *)get_cv ("IO::AIO::aioreq_pri", 0);
2570 prio_sv = newSViv (0);
2571 }
2572
2573 PUSHMARK (SP);
2574 sv_setiv (prio_sv, coro->prio);
2575 XPUSHs (prio_sv);
2576
2577 PUTBACK;
2578 call_sv (prio_cv, G_VOID | G_DISCARD);
2579 }
2580
2581 /* now call the original request */
2582 {
2583 dSP;
2584 CV *req = (CV *)CORO_MAGIC_NN ((SV *)cv, CORO_MAGIC_type_aio)->mg_obj;
2585 int i;
2586
2587 PUSHMARK (SP);
2588
2589 /* first push all args to the stack */
2590 EXTEND (SP, items + 1);
2591
2592 for (i = 0; i < items; ++i)
2593 PUSHs (arg [i]);
2594
2595 /* now push the callback closure */
2596 PUSHs (sv_2mortal (gensub (aTHX_ coro_aio_callback, (void *)SvREFCNT_inc_NN ((SV *)state))));
2597
2598 /* now call the AIO function - we assume our request is uncancelable */
2599 PUTBACK;
2600 call_sv ((SV *)req, G_VOID | G_DISCARD);
2601 }
2602
2603 /* now that the requets is going, we loop toll we have a result */
2604 frame->data = (void *)state;
2605 frame->prepare = prepare_schedule;
2606 frame->check = slf_check_aio_req;
2607}
2608
2609static void
2610coro_aio_req_xs (pTHX_ CV *cv)
2611{
2612 dXSARGS;
2613
2614 CORO_EXECUTE_SLF_XS (slf_init_aio_req);
2615
2616 XSRETURN_EMPTY;
2617}
2618
2619/*****************************************************************************/
2620
2621MODULE = Coro::State PACKAGE = Coro::State PREFIX = api_
2622
2623PROTOTYPES: DISABLE
2624
2625BOOT:
2626{
2627#ifdef USE_ITHREADS
2628# if CORO_PTHREAD
2629 coro_thx = PERL_GET_CONTEXT;
2630# endif
2631#endif
2632 BOOT_PAGESIZE;
2633
2634 irsgv = gv_fetchpv ("/" , GV_ADD|GV_NOTQUAL, SVt_PV);
2635 stdoutgv = gv_fetchpv ("STDOUT", GV_ADD|GV_NOTQUAL, SVt_PVIO);
2636
2637 orig_sigelem_get = PL_vtbl_sigelem.svt_get; PL_vtbl_sigelem.svt_get = coro_sigelem_get;
2638 orig_sigelem_set = PL_vtbl_sigelem.svt_set; PL_vtbl_sigelem.svt_set = coro_sigelem_set;
2639 orig_sigelem_clr = PL_vtbl_sigelem.svt_clear; PL_vtbl_sigelem.svt_clear = coro_sigelem_clr;
2640
2641 hv_sig = coro_get_hv (aTHX_ "SIG", TRUE);
2642 rv_diehook = newRV_inc ((SV *)gv_fetchpv ("Coro::State::diehook" , 0, SVt_PVCV));
2643 rv_warnhook = newRV_inc ((SV *)gv_fetchpv ("Coro::State::warnhook", 0, SVt_PVCV));
2644
2645 coro_state_stash = gv_stashpv ("Coro::State", TRUE);
2646
2647 newCONSTSUB (coro_state_stash, "CC_TRACE" , newSViv (CC_TRACE));
2648 newCONSTSUB (coro_state_stash, "CC_TRACE_SUB" , newSViv (CC_TRACE_SUB));
2649 newCONSTSUB (coro_state_stash, "CC_TRACE_LINE", newSViv (CC_TRACE_LINE));
2650 newCONSTSUB (coro_state_stash, "CC_TRACE_ALL" , newSViv (CC_TRACE_ALL));
2651
2652 main_mainstack = PL_mainstack;
2653 main_top_env = PL_top_env;
2654
2655 while (main_top_env->je_prev)
2656 main_top_env = main_top_env->je_prev;
2657
2658 {
2659 SV *slf = sv_2mortal (newSViv (PTR2IV (pp_slf)));
2660
2661 if (!PL_custom_op_names) PL_custom_op_names = newHV ();
2662 hv_store_ent (PL_custom_op_names, slf,
2663 newSVpv ("coro_slf", 0), 0);
2664
2665 if (!PL_custom_op_descs) PL_custom_op_descs = newHV ();
2666 hv_store_ent (PL_custom_op_descs, slf,
2667 newSVpv ("coro schedule like function", 0), 0);
2668 }
2669
2670 coroapi.ver = CORO_API_VERSION;
2671 coroapi.rev = CORO_API_REVISION;
2672
2673 coroapi.transfer = api_transfer;
2674
2675 coroapi.sv_state = SvSTATE_;
2676 coroapi.execute_slf = api_execute_slf;
2677 coroapi.prepare_nop = prepare_nop;
2678 coroapi.prepare_schedule = prepare_schedule;
2679 coroapi.prepare_cede = prepare_cede;
2680 coroapi.prepare_cede_notself = prepare_cede_notself;
2681
2682 {
2683 SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
2684
2685 if (!svp) croak ("Time::HiRes is required");
2686 if (!SvIOK (*svp)) croak ("Time::NVtime isn't a function pointer");
2687
2688 nvtime = INT2PTR (double (*)(), SvIV (*svp));
2689 }
2690
2691 assert (("PRIO_NORMAL must be 0", !PRIO_NORMAL));
2692}
2693
2694SV *
2695new (char *klass, ...)
2696 ALIAS:
2697 Coro::new = 1
2698 CODE:
2699{
2700 struct coro *coro;
2701 MAGIC *mg;
2702 HV *hv;
2703 CV *cb;
2704 int i;
2705
2706 if (items > 1)
2707 {
2708 cb = coro_sv_2cv (aTHX_ ST (1));
2709
2710 if (!ix)
235 { 2711 {
236 /* I never used formats, so how should I know how these are implemented? */ 2712 if (CvISXSUB (cb))
237 /* my bold guess is as a simple, plain sub... */ 2713 croak ("Coro::State doesn't support XS functions as coroutine start, caught");
238 croak ("CXt_FORMAT not yet handled. Don't switch coroutines from within formats"); 2714
2715 if (!CvROOT (cb))
2716 croak ("Coro::State doesn't support autoloaded or undefined functions as coroutine start, caught");
239 } 2717 }
240 } 2718 }
241 2719
242 if (top_si->si_type == PERLSI_MAIN)
243 break;
244
245 top_si = top_si->si_prev;
246 ccstk = top_si->si_cxstack;
247 cxix = top_si->si_cxix;
248 }
249
250 PUTBACK;
251 }
252
253 c->dowarn = PL_dowarn;
254 c->defav = GvAV (PL_defgv);
255 c->curstackinfo = PL_curstackinfo;
256 c->curstack = PL_curstack;
257 c->mainstack = PL_mainstack;
258 c->stack_sp = PL_stack_sp;
259 c->op = PL_op;
260 c->curpad = PL_curpad;
261 c->stack_base = PL_stack_base;
262 c->stack_max = PL_stack_max;
263 c->tmps_stack = PL_tmps_stack;
264 c->tmps_floor = PL_tmps_floor;
265 c->tmps_ix = PL_tmps_ix;
266 c->tmps_max = PL_tmps_max;
267 c->markstack = PL_markstack;
268 c->markstack_ptr = PL_markstack_ptr;
269 c->markstack_max = PL_markstack_max;
270 c->scopestack = PL_scopestack;
271 c->scopestack_ix = PL_scopestack_ix;
272 c->scopestack_max = PL_scopestack_max;
273 c->savestack = PL_savestack;
274 c->savestack_ix = PL_savestack_ix;
275 c->savestack_max = PL_savestack_max;
276 c->retstack = PL_retstack;
277 c->retstack_ix = PL_retstack_ix;
278 c->retstack_max = PL_retstack_max;
279 c->curcop = PL_curcop;
280}
281
282static void
283LOAD(pTHX_ Coro__State c)
284{
285 PL_dowarn = c->dowarn;
286 GvAV (PL_defgv) = c->defav;
287 PL_curstackinfo = c->curstackinfo;
288 PL_curstack = c->curstack;
289 PL_mainstack = c->mainstack;
290 PL_stack_sp = c->stack_sp;
291 PL_op = c->op;
292 PL_curpad = c->curpad;
293 PL_stack_base = c->stack_base;
294 PL_stack_max = c->stack_max;
295 PL_tmps_stack = c->tmps_stack;
296 PL_tmps_floor = c->tmps_floor;
297 PL_tmps_ix = c->tmps_ix;
298 PL_tmps_max = c->tmps_max;
299 PL_markstack = c->markstack;
300 PL_markstack_ptr = c->markstack_ptr;
301 PL_markstack_max = c->markstack_max;
302 PL_scopestack = c->scopestack;
303 PL_scopestack_ix = c->scopestack_ix;
304 PL_scopestack_max = c->scopestack_max;
305 PL_savestack = c->savestack;
306 PL_savestack_ix = c->savestack_ix;
307 PL_savestack_max = c->savestack_max;
308 PL_retstack = c->retstack;
309 PL_retstack_ix = c->retstack_ix;
310 PL_retstack_max = c->retstack_max;
311 PL_curcop = c->curcop;
312
313 {
314 dSP;
315 CV *cv;
316
317 /* now do the ugly restore mess */
318 while ((cv = (CV *)POPs))
319 {
320 AV *padlist = (AV *)POPs;
321
322 put_padlist (cv);
323 CvPADLIST(cv) = padlist;
324 CvDEPTH(cv) = (I32)POPs;
325
326#ifdef USE_THREADS
327 CvOWNER(cv) = (struct perl_thread *)POPs;
328 error does not work either
329#endif
330 }
331
332 PUTBACK;
333 }
334}
335
336/* this is an EXACT copy of S_nuke_stacks in perl.c, which is unfortunately static */
337STATIC void
338destroy_stacks(pTHX)
339{
340 /* die does this while calling POPSTACK, but I just don't see why. */
341 dounwind(-1);
342
343 /* is this ugly, I ask? */
344 while (PL_scopestack_ix)
345 LEAVE;
346
347 while (PL_curstackinfo->si_next)
348 PL_curstackinfo = PL_curstackinfo->si_next;
349
350 while (PL_curstackinfo)
351 {
352 PERL_SI *p = PL_curstackinfo->si_prev;
353
354 SvREFCNT_dec(PL_curstackinfo->si_stack);
355 Safefree(PL_curstackinfo->si_cxstack);
356 Safefree(PL_curstackinfo);
357 PL_curstackinfo = p;
358 }
359
360 if (PL_scopestack_ix != 0)
361 Perl_warner(aTHX_ WARN_INTERNAL,
362 "Unbalanced scopes: %ld more ENTERs than LEAVEs\n",
363 (long)PL_scopestack_ix);
364 if (PL_savestack_ix != 0)
365 Perl_warner(aTHX_ WARN_INTERNAL,
366 "Unbalanced saves: %ld more saves than restores\n",
367 (long)PL_savestack_ix);
368 if (PL_tmps_floor != -1)
369 Perl_warner(aTHX_ WARN_INTERNAL,"Unbalanced tmps: %ld more allocs than frees\n",
370 (long)PL_tmps_floor + 1);
371 /*
372 */
373 Safefree(PL_tmps_stack);
374 Safefree(PL_markstack);
375 Safefree(PL_scopestack);
376 Safefree(PL_savestack);
377 Safefree(PL_retstack);
378}
379
380#define SUB_INIT "Coro::State::_newcoro"
381
382MODULE = Coro::State PACKAGE = Coro::State
383
384PROTOTYPES: ENABLE
385
386BOOT:
387 if (!padlist_cache)
388 padlist_cache = newHV ();
389
390Coro::State
391_newprocess(args)
392 SV * args
393 PROTOTYPE: $
394 CODE:
395 Coro__State coro;
396
397 if (!SvROK (args) || SvTYPE (SvRV (args)) != SVt_PVAV)
398 croak ("Coro::State::newprocess expects an arrayref");
399
400 New (0, coro, 1, struct coro); 2720 Newz (0, coro, 1, struct coro);
2721 coro->args = newAV ();
2722 coro->flags = CF_NEW;
401 2723
402 coro->mainstack = 0; /* actual work is done inside transfer */ 2724 if (coro_first) coro_first->prev = coro;
403 coro->args = (AV *)SvREFCNT_inc (SvRV (args)); 2725 coro->next = coro_first;
2726 coro_first = coro;
404 2727
405 RETVAL = coro; 2728 coro->hv = hv = newHV ();
2729 mg = sv_magicext ((SV *)hv, 0, CORO_MAGIC_type_state, &coro_state_vtbl, (char *)coro, 0);
2730 mg->mg_flags |= MGf_DUP;
2731 RETVAL = sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));
2732
2733 if (items > 1)
2734 {
2735 av_extend (coro->args, items - 1 + ix - 1);
2736
2737 if (ix)
2738 {
2739 av_push (coro->args, SvREFCNT_inc_NN ((SV *)cb));
2740 cb = cv_coro_run;
2741 }
2742
2743 coro->startcv = (CV *)SvREFCNT_inc_NN ((SV *)cb);
2744
2745 for (i = 2; i < items; i++)
2746 av_push (coro->args, newSVsv (ST (i)));
2747 }
2748}
406 OUTPUT: 2749 OUTPUT:
407 RETVAL 2750 RETVAL
408 2751
409void 2752void
410transfer(prev,next) 2753transfer (...)
411 Coro::State_or_hashref prev 2754 PROTOTYPE: $$
412 Coro::State_or_hashref next 2755 CODE:
413 CODE: 2756 CORO_EXECUTE_SLF_XS (slf_init_transfer);
414 2757
415 if (prev != next) 2758bool
2759_destroy (SV *coro_sv)
2760 CODE:
2761 RETVAL = coro_state_destroy (aTHX_ SvSTATE (coro_sv));
2762 OUTPUT:
2763 RETVAL
2764
2765void
2766_exit (int code)
2767 PROTOTYPE: $
2768 CODE:
2769 _exit (code);
2770
2771int
2772cctx_stacksize (int new_stacksize = 0)
2773 PROTOTYPE: ;$
2774 CODE:
2775 RETVAL = cctx_stacksize;
2776 if (new_stacksize)
416 { 2777 {
417 PUTBACK; 2778 cctx_stacksize = new_stacksize;
418 SAVE (aTHX_ prev); 2779 ++cctx_gen;
419
420 /* 2780 }
421 * this could be done in newprocess which would lead to 2781 OUTPUT:
422 * extremely elegant and fast (just PUTBACK/SAVE/LOAD/SPAGAIN) 2782 RETVAL
423 * code here, but lazy allocation of stacks has also 2783
424 * some virtues and the overhead of the if() is nil. 2784int
2785cctx_max_idle (int max_idle = 0)
2786 PROTOTYPE: ;$
2787 CODE:
2788 RETVAL = cctx_max_idle;
2789 if (max_idle > 1)
2790 cctx_max_idle = max_idle;
2791 OUTPUT:
2792 RETVAL
2793
2794int
2795cctx_count ()
2796 PROTOTYPE:
2797 CODE:
2798 RETVAL = cctx_count;
2799 OUTPUT:
2800 RETVAL
2801
2802int
2803cctx_idle ()
2804 PROTOTYPE:
2805 CODE:
2806 RETVAL = cctx_idle;
2807 OUTPUT:
2808 RETVAL
2809
2810void
2811list ()
2812 PROTOTYPE:
2813 PPCODE:
2814{
2815 struct coro *coro;
2816 for (coro = coro_first; coro; coro = coro->next)
2817 if (coro->hv)
2818 XPUSHs (sv_2mortal (newRV_inc ((SV *)coro->hv)));
2819}
2820
2821void
2822call (Coro::State coro, SV *coderef)
2823 ALIAS:
2824 eval = 1
2825 CODE:
2826{
2827 if (coro->mainstack && ((coro->flags & CF_RUNNING) || coro->slot))
425 */ 2828 {
426 if (next->mainstack) 2829 struct coro temp;
2830
2831 if (!(coro->flags & CF_RUNNING))
427 { 2832 {
428 LOAD (aTHX_ next); 2833 PUTBACK;
429 next->mainstack = 0; /* unnecessary but much cleaner */ 2834 save_perl (aTHX_ &temp);
2835 load_perl (aTHX_ coro);
2836 }
2837
2838 {
2839 dSP;
2840 ENTER;
2841 SAVETMPS;
2842 PUTBACK;
2843 PUSHSTACK;
2844 PUSHMARK (SP);
2845
2846 if (ix)
2847 eval_sv (coderef, 0);
2848 else
2849 call_sv (coderef, G_KEEPERR | G_EVAL | G_VOID | G_DISCARD);
2850
2851 POPSTACK;
2852 SPAGAIN;
2853 FREETMPS;
2854 LEAVE;
2855 PUTBACK;
2856 }
2857
2858 if (!(coro->flags & CF_RUNNING))
2859 {
2860 save_perl (aTHX_ coro);
2861 load_perl (aTHX_ &temp);
430 SPAGAIN; 2862 SPAGAIN;
431 } 2863 }
432 else
433 {
434 /*
435 * emulate part of the perl startup here.
436 */
437 UNOP myop;
438
439 init_stacks (); /* from perl.c */
440 PL_op = (OP *)&myop;
441 /*PL_curcop = 0;*/
442 GvAV (PL_defgv) = (AV *)SvREFCNT_inc ((SV *)next->args);
443
444 SPAGAIN;
445 Zero(&myop, 1, UNOP);
446 myop.op_next = Nullop;
447 myop.op_flags = OPf_WANT_VOID;
448
449 PUSHMARK(SP);
450 XPUSHs ((SV*)get_cv(SUB_INIT, TRUE));
451 PUTBACK;
452 /*
453 * the next line is slightly wrong, as PL_op->op_next
454 * is actually being executed so we skip the first op.
455 * that doesn't matter, though, since it is only
456 * pp_nextstate and we never return...
457 */
458 PL_op = Perl_pp_entersub(aTHX);
459 SPAGAIN;
460
461 ENTER;
462 }
463 } 2864 }
2865}
2866
2867SV *
2868is_ready (Coro::State coro)
2869 PROTOTYPE: $
2870 ALIAS:
2871 is_ready = CF_READY
2872 is_running = CF_RUNNING
2873 is_new = CF_NEW
2874 is_destroyed = CF_DESTROYED
2875 CODE:
2876 RETVAL = boolSV (coro->flags & ix);
2877 OUTPUT:
2878 RETVAL
464 2879
465void 2880void
466DESTROY(coro) 2881throw (Coro::State self, SV *throw = &PL_sv_undef)
467 Coro::State coro 2882 PROTOTYPE: $;$
468 CODE: 2883 CODE:
2884{
2885 struct coro *current = SvSTATE_current;
2886 SV **throwp = self == current ? &CORO_THROW : &self->except;
2887 SvREFCNT_dec (*throwp);
2888 *throwp = SvOK (throw) ? newSVsv (throw) : 0;
2889}
469 2890
470 if (coro->mainstack) 2891void
2892api_trace (SV *coro, int flags = CC_TRACE | CC_TRACE_SUB)
2893 PROTOTYPE: $;$
2894 C_ARGS: aTHX_ coro, flags
2895
2896SV *
2897has_cctx (Coro::State coro)
2898 PROTOTYPE: $
2899 CODE:
2900 RETVAL = boolSV (!!coro->cctx);
2901 OUTPUT:
2902 RETVAL
2903
2904int
2905is_traced (Coro::State coro)
2906 PROTOTYPE: $
2907 CODE:
2908 RETVAL = (coro->cctx ? coro->cctx->flags : 0) & CC_TRACE_ALL;
2909 OUTPUT:
2910 RETVAL
2911
2912UV
2913rss (Coro::State coro)
2914 PROTOTYPE: $
2915 ALIAS:
2916 usecount = 1
2917 CODE:
2918 switch (ix)
2919 {
2920 case 0: RETVAL = coro_rss (aTHX_ coro); break;
2921 case 1: RETVAL = coro->usecount; break;
2922 }
2923 OUTPUT:
2924 RETVAL
2925
2926void
2927force_cctx ()
2928 PROTOTYPE:
2929 CODE:
2930 SvSTATE_current->cctx->idle_sp = 0;
2931
2932void
2933swap_defsv (Coro::State self)
2934 PROTOTYPE: $
2935 ALIAS:
2936 swap_defav = 1
2937 CODE:
2938 if (!self->slot)
2939 croak ("cannot swap state with coroutine that has no saved state,");
2940 else
471 { 2941 {
472 struct coro temp; 2942 SV **src = ix ? (SV **)&GvAV (PL_defgv) : &GvSV (PL_defgv);
2943 SV **dst = ix ? (SV **)&self->slot->defav : (SV **)&self->slot->defsv;
473 2944
2945 SV *tmp = *src; *src = *dst; *dst = tmp;
2946 }
2947
2948
2949MODULE = Coro::State PACKAGE = Coro
2950
2951BOOT:
2952{
2953 int i;
2954
2955 av_async_pool = coro_get_av (aTHX_ "Coro::async_pool", TRUE);
2956 sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE);
2957 sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE);
2958 cv_coro_run = get_cv ( "Coro::_terminate", GV_ADD);
2959 cv_coro_terminate = get_cv ( "Coro::terminate", GV_ADD);
2960 coro_current = coro_get_sv (aTHX_ "Coro::current" , FALSE);
2961 SvREADONLY_on (coro_current);
2962
2963 sv_async_pool_idle = newSVpv ("[async pool idle]", 0); SvREADONLY_on (sv_async_pool_idle);
2964 sv_Coro = newSVpv ("Coro", 0); SvREADONLY_on (sv_Coro);
2965 cv_pool_handler = get_cv ("Coro::_pool_handler", 0); SvREADONLY_on (cv_pool_handler);
2966 cv_coro_new = get_cv ("Coro::new", 0); SvREADONLY_on (cv_coro_new);
2967
2968 coro_stash = gv_stashpv ("Coro", TRUE);
2969
2970 newCONSTSUB (coro_stash, "PRIO_MAX", newSViv (PRIO_MAX));
2971 newCONSTSUB (coro_stash, "PRIO_HIGH", newSViv (PRIO_HIGH));
2972 newCONSTSUB (coro_stash, "PRIO_NORMAL", newSViv (PRIO_NORMAL));
2973 newCONSTSUB (coro_stash, "PRIO_LOW", newSViv (PRIO_LOW));
2974 newCONSTSUB (coro_stash, "PRIO_IDLE", newSViv (PRIO_IDLE));
2975 newCONSTSUB (coro_stash, "PRIO_MIN", newSViv (PRIO_MIN));
2976
2977 for (i = PRIO_MAX - PRIO_MIN + 1; i--; )
2978 coro_ready[i] = newAV ();
2979
2980 {
2981 SV *sv = coro_get_sv (aTHX_ "Coro::API", TRUE);
2982
2983 coroapi.schedule = api_schedule;
2984 coroapi.cede = api_cede;
2985 coroapi.cede_notself = api_cede_notself;
2986 coroapi.ready = api_ready;
2987 coroapi.is_ready = api_is_ready;
2988 coroapi.nready = coro_nready;
2989 coroapi.current = coro_current;
2990
2991 /*GCoroAPI = &coroapi;*/
2992 sv_setiv (sv, (IV)&coroapi);
2993 SvREADONLY_on (sv);
2994 }
2995}
2996
2997void
2998schedule (...)
2999 CODE:
3000 CORO_EXECUTE_SLF_XS (slf_init_schedule);
3001
3002void
3003cede (...)
3004 CODE:
3005 CORO_EXECUTE_SLF_XS (slf_init_cede);
3006
3007void
3008cede_notself (...)
3009 CODE:
3010 CORO_EXECUTE_SLF_XS (slf_init_cede_notself);
3011
3012void
3013_set_current (SV *current)
3014 PROTOTYPE: $
3015 CODE:
3016 SvREFCNT_dec (SvRV (coro_current));
3017 SvRV_set (coro_current, SvREFCNT_inc_NN (SvRV (current)));
3018
3019void
3020_set_readyhook (SV *hook)
3021 PROTOTYPE: $
3022 CODE:
3023 SvREFCNT_dec (coro_readyhook);
3024 coro_readyhook = SvOK (hook) ? newSVsv (hook) : 0;
3025
3026int
3027prio (Coro::State coro, int newprio = 0)
3028 PROTOTYPE: $;$
3029 ALIAS:
3030 nice = 1
3031 CODE:
3032{
3033 RETVAL = coro->prio;
3034
3035 if (items > 1)
3036 {
3037 if (ix)
3038 newprio = coro->prio - newprio;
3039
3040 if (newprio < PRIO_MIN) newprio = PRIO_MIN;
3041 if (newprio > PRIO_MAX) newprio = PRIO_MAX;
3042
3043 coro->prio = newprio;
3044 }
3045}
3046 OUTPUT:
3047 RETVAL
3048
3049SV *
3050ready (SV *self)
3051 PROTOTYPE: $
3052 CODE:
3053 RETVAL = boolSV (api_ready (aTHX_ self));
3054 OUTPUT:
3055 RETVAL
3056
3057int
3058nready (...)
3059 PROTOTYPE:
3060 CODE:
3061 RETVAL = coro_nready;
3062 OUTPUT:
3063 RETVAL
3064
3065void
3066_pool_handler (...)
3067 CODE:
3068 CORO_EXECUTE_SLF_XS (slf_init_pool_handler);
3069
3070void
3071async_pool (SV *cv, ...)
3072 PROTOTYPE: &@
3073 PPCODE:
3074{
3075 HV *hv = (HV *)av_pop (av_async_pool);
3076 AV *av = newAV ();
3077 SV *cb = ST (0);
3078 int i;
3079
3080 av_extend (av, items - 2);
3081 for (i = 1; i < items; ++i)
3082 av_push (av, SvREFCNT_inc_NN (ST (i)));
3083
3084 if ((SV *)hv == &PL_sv_undef)
3085 {
3086 PUSHMARK (SP);
3087 EXTEND (SP, 2);
3088 PUSHs (sv_Coro);
3089 PUSHs ((SV *)cv_pool_handler);
474 PUTBACK; 3090 PUTBACK;
475 SAVE(aTHX_ (&temp)); 3091 call_sv ((SV *)cv_coro_new, G_SCALAR);
476 LOAD(aTHX_ coro);
477
478 destroy_stacks ();
479 SvREFCNT_dec ((SV *)GvAV (PL_defgv));
480
481 LOAD((&temp));
482 SPAGAIN; 3092 SPAGAIN;
3093
3094 hv = (HV *)SvREFCNT_inc_NN (SvRV (POPs));
483 } 3095 }
484 3096
3097 {
3098 struct coro *coro = SvSTATE_hv (hv);
3099
3100 assert (!coro->invoke_cb);
3101 assert (!coro->invoke_av);
3102 coro->invoke_cb = SvREFCNT_inc (cb);
3103 coro->invoke_av = av;
3104 }
3105
3106 api_ready (aTHX_ (SV *)hv);
3107
3108 if (GIMME_V != G_VOID)
3109 XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv)));
3110 else
485 SvREFCNT_dec (coro->args); 3111 SvREFCNT_dec (hv);
486 Safefree (coro); 3112}
487 3113
3114SV *
3115rouse_cb ()
3116 PROTOTYPE:
3117 CODE:
3118 RETVAL = coro_new_rouse_cb (aTHX);
3119 OUTPUT:
3120 RETVAL
488 3121
3122void
3123rouse_wait (...)
3124 PROTOTYPE: ;$
3125 PPCODE:
3126 CORO_EXECUTE_SLF_XS (slf_init_rouse_wait);
3127
3128
3129MODULE = Coro::State PACKAGE = PerlIO::cede
3130
3131BOOT:
3132 PerlIO_define_layer (aTHX_ &PerlIO_cede);
3133
3134
3135MODULE = Coro::State PACKAGE = Coro::Semaphore
3136
3137SV *
3138new (SV *klass, SV *count = 0)
3139 CODE:
3140 RETVAL = sv_bless (
3141 coro_waitarray_new (aTHX_ count && SvOK (count) ? SvIV (count) : 1),
3142 GvSTASH (CvGV (cv))
3143 );
3144 OUTPUT:
3145 RETVAL
3146
3147# helper for Coro::Channel
3148SV *
3149_alloc (int count)
3150 CODE:
3151 RETVAL = coro_waitarray_new (aTHX_ count);
3152 OUTPUT:
3153 RETVAL
3154
3155SV *
3156count (SV *self)
3157 CODE:
3158 RETVAL = newSVsv (AvARRAY ((AV *)SvRV (self))[0]);
3159 OUTPUT:
3160 RETVAL
3161
3162void
3163up (SV *self, int adjust = 1)
3164 ALIAS:
3165 adjust = 1
3166 CODE:
3167 coro_semaphore_adjust (aTHX_ (AV *)SvRV (self), ix ? adjust : 1);
3168
3169void
3170down (...)
3171 CODE:
3172 CORO_EXECUTE_SLF_XS (slf_init_semaphore_down);
3173
3174void
3175wait (...)
3176 CODE:
3177 CORO_EXECUTE_SLF_XS (slf_init_semaphore_wait);
3178
3179void
3180try (SV *self)
3181 PPCODE:
3182{
3183 AV *av = (AV *)SvRV (self);
3184 SV *count_sv = AvARRAY (av)[0];
3185 IV count = SvIVX (count_sv);
3186
3187 if (count > 0)
3188 {
3189 --count;
3190 SvIVX (count_sv) = count;
3191 XSRETURN_YES;
3192 }
3193 else
3194 XSRETURN_NO;
3195}
3196
3197void
3198waiters (SV *self)
3199 PPCODE:
3200{
3201 AV *av = (AV *)SvRV (self);
3202 int wcount = AvFILLp (av) + 1 - 1;
3203
3204 if (GIMME_V == G_SCALAR)
3205 XPUSHs (sv_2mortal (newSViv (wcount)));
3206 else
3207 {
3208 int i;
3209 EXTEND (SP, wcount);
3210 for (i = 1; i <= wcount; ++i)
3211 PUSHs (sv_2mortal (newRV_inc (AvARRAY (av)[i])));
3212 }
3213}
3214
3215MODULE = Coro::State PACKAGE = Coro::Signal
3216
3217SV *
3218new (SV *klass)
3219 CODE:
3220 RETVAL = sv_bless (
3221 coro_waitarray_new (aTHX_ 0),
3222 GvSTASH (CvGV (cv))
3223 );
3224 OUTPUT:
3225 RETVAL
3226
3227void
3228wait (...)
3229 CODE:
3230 CORO_EXECUTE_SLF_XS (slf_init_signal_wait);
3231
3232void
3233broadcast (SV *self)
3234 CODE:
3235{
3236 AV *av = (AV *)SvRV (self);
3237 coro_signal_wake (aTHX_ av, AvFILLp (av));
3238}
3239
3240void
3241send (SV *self)
3242 CODE:
3243{
3244 AV *av = (AV *)SvRV (self);
3245
3246 if (AvFILLp (av))
3247 coro_signal_wake (aTHX_ av, 1);
3248 else
3249 SvIVX (AvARRAY (av)[0]) = 1; /* remember the signal */
3250}
3251
3252IV
3253awaited (SV *self)
3254 CODE:
3255 RETVAL = AvFILLp ((AV *)SvRV (self)) + 1 - 1;
3256 OUTPUT:
3257 RETVAL
3258
3259
3260MODULE = Coro::State PACKAGE = Coro::AnyEvent
3261
3262BOOT:
3263 sv_activity = coro_get_sv (aTHX_ "Coro::AnyEvent::ACTIVITY", TRUE);
3264
3265void
3266_schedule (...)
3267 CODE:
3268{
3269 static int incede;
3270
3271 api_cede_notself (aTHX);
3272
3273 ++incede;
3274 while (coro_nready >= incede && api_cede (aTHX))
3275 ;
3276
3277 sv_setsv (sv_activity, &PL_sv_undef);
3278 if (coro_nready >= incede)
3279 {
3280 PUSHMARK (SP);
3281 PUTBACK;
3282 call_pv ("Coro::AnyEvent::_activity", G_KEEPERR | G_EVAL | G_VOID | G_DISCARD);
3283 }
3284
3285 --incede;
3286}
3287
3288
3289MODULE = Coro::State PACKAGE = Coro::AIO
3290
3291void
3292_register (char *target, char *proto, SV *req)
3293 CODE:
3294{
3295 CV *req_cv = coro_sv_2cv (aTHX_ req);
3296 /* newXSproto doesn't return the CV on 5.8 */
3297 CV *slf_cv = newXS (target, coro_aio_req_xs, __FILE__);
3298 sv_setpv ((SV *)slf_cv, proto);
3299 sv_magicext ((SV *)slf_cv, (SV *)req_cv, CORO_MAGIC_type_aio, 0, 0, 0);
3300}
3301

Diff Legend

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