ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/Coro/Coro/State.xs
(Generate patch)

Comparing Coro/Coro/State.xs (file contents):
Revision 1.3 by root, Tue Jul 17 00:24:15 2001 UTC vs.
Revision 1.269 by root, Fri Nov 14 06:50:11 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, don't ask
7#else 22#else
8# define CHK(x) if (!(x)) croak("FATAL, CHK: " #x) 23# include <inttypes.h> /* most portable stdint.h */
24#endif
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
9#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
10 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) && PERLSUBVERSION >= (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
101/* 5.8.7 */
102#ifndef SvRV_set
103# define SvRV_set(s,v) SvRV(s) = (v)
104#endif
105
106#if !__i386 && !__x86_64 && !__powerpc && !__m68k && !__alpha && !__mips && !__sparc64
107# undef CORO_STACKGUARD
108#endif
109
110#ifndef CORO_STACKGUARD
111# define CORO_STACKGUARD 0
112#endif
113
114/* prefer perl internal functions over our own? */
115#ifndef CORO_PREFER_PERL_FUNCTIONS
116# define CORO_PREFER_PERL_FUNCTIONS 0
117#endif
118
119/* The next macros try to return the current stack pointer, in an as
120 * portable way as possible. */
121#if __GNUC__ >= 4
122# define dSTACKLEVEL void *stacklevel = __builtin_frame_address (0)
123#else
124# define dSTACKLEVEL volatile void *stacklevel = (volatile void *)&stacklevel
125#endif
126
127#define IN_DESTRUCT (PL_main_cv == Nullcv)
128
129#if __GNUC__ >= 3
130# define attribute(x) __attribute__(x)
131# define expect(expr,value) __builtin_expect ((expr),(value))
132# define INLINE static inline
133#else
134# define attribute(x)
135# define expect(expr,value) (expr)
136# define INLINE static
137#endif
138
139#define expect_false(expr) expect ((expr) != 0, 0)
140#define expect_true(expr) expect ((expr) != 0, 1)
141
142#define NOINLINE attribute ((noinline))
143
144#include "CoroAPI.h"
145
146#ifdef USE_ITHREADS
147
148static perl_mutex coro_lock;
149# define LOCK do { MUTEX_LOCK (&coro_lock); } while (0)
150# define UNLOCK do { MUTEX_UNLOCK (&coro_lock); } while (0)
151# if CORO_PTHREAD
152static void *coro_thx;
153# endif
154
155#else
156
157# define LOCK (void)0
158# define UNLOCK (void)0
159
160#endif
161
162# undef LOCK
163# define LOCK (void)0
164# undef UNLOCK
165# define UNLOCK (void)0
166
167/* helper storage struct for Coro::AIO */
168struct io_state
169{
170 AV *res;
171 int errorno;
172 I32 laststype; /* U16 in 5.10.0 */
173 int laststatval;
174 Stat_t statcache;
175};
176
177static double (*nvtime)(); /* so why doesn't it take void? */
178
179static U32 cctx_gen;
180static size_t cctx_stacksize = CORO_STACKSIZE;
181static struct CoroAPI coroapi;
182static AV *main_mainstack; /* used to differentiate between $main and others */
183static JMPENV *main_top_env;
184static HV *coro_state_stash, *coro_stash;
185static volatile SV *coro_mortal; /* will be freed/thrown after next transfer */
186static volatile struct coro *transfer_next;
187
188struct transfer_args
189{
190 struct coro *prev, *next;
191};
192
193static GV *irsgv; /* $/ */
194static GV *stdoutgv; /* *STDOUT */
195static SV *rv_diehook;
196static SV *rv_warnhook;
197static HV *hv_sig; /* %SIG */
198
199/* async_pool helper stuff */
200static SV *sv_pool_rss;
201static SV *sv_pool_size;
202static AV *av_async_pool;
203
204/* Coro::AnyEvent */
205static SV *sv_activity;
206
207static struct coro_cctx *cctx_first;
208static int cctx_count, cctx_idle;
209
210enum {
211 CC_MAPPED = 0x01,
212 CC_NOREUSE = 0x02, /* throw this away after tracing */
213 CC_TRACE = 0x04,
214 CC_TRACE_SUB = 0x08, /* trace sub calls */
215 CC_TRACE_LINE = 0x10, /* trace each statement */
216 CC_TRACE_ALL = CC_TRACE_SUB | CC_TRACE_LINE,
217};
218
219/* this is a structure representing a c-level coroutine */
220typedef struct coro_cctx {
221 struct coro_cctx *next;
222
223 /* the stack */
224 void *sptr;
225 size_t ssize;
226
227 /* cpu state */
228 void *idle_sp; /* sp of top-level transfer/schedule/cede call */
229 JMPENV *idle_te; /* same as idle_sp, but for top_env, TODO: remove once stable */
230 JMPENV *top_env;
231 coro_context cctx;
232
233 U32 gen;
234#if CORO_USE_VALGRIND
235 int valgrind_id;
236#endif
237 unsigned char flags;
238} coro_cctx;
239
240enum {
241 CF_RUNNING = 0x0001, /* coroutine is running */
242 CF_READY = 0x0002, /* coroutine is ready */
243 CF_NEW = 0x0004, /* has never been switched to */
244 CF_DESTROYED = 0x0008, /* coroutine data has been freed */
245};
246
247/* the structure where most of the perl state is stored, overlaid on the cxstack */
248typedef struct {
249 SV *defsv;
250 AV *defav;
251 SV *errsv;
252 SV *irsgv;
253#define VAR(name,type) type name;
254# include "state.h"
255#undef VAR
256} perl_slots;
257
258#define SLOT_COUNT ((sizeof (perl_slots) + sizeof (PERL_CONTEXT) - 1) / sizeof (PERL_CONTEXT))
259
260/* this is a structure representing a perl-level coroutine */
11struct coro { 261struct coro {
12 U8 dowarn; 262 /* the c coroutine allocated to this perl coroutine, if any */
13 AV *defav; 263 coro_cctx *cctx;
14 264
15 PERL_SI *curstackinfo; 265 /* process data */
16 AV *curstack;
17 AV *mainstack; 266 AV *mainstack;
18 SV **stack_sp; 267 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 268
41 AV *args; 269 AV *args; /* data associated with this coroutine (initial args) */
270 int refcnt; /* coroutines are refcounted, yes */
271 int flags; /* CF_ flags */
272 HV *hv; /* the perl hash associated with this coro, if any */
273
274 /* statistics */
275 int usecount; /* number of transfers to this coro */
276
277 /* coro process data */
278 int prio;
279 SV *throw; /* exception to be thrown */
280
281 /* async_pool */
282 SV *saved_deffh;
283
284 /* linked list */
285 struct coro *next, *prev;
42}; 286};
43 287
44typedef struct coro *Coro__State; 288typedef struct coro *Coro__State;
45typedef struct coro *Coro__State_or_hashref; 289typedef struct coro *Coro__State_or_hashref;
46 290
47static HV *padlist_cache; 291/** Coro ********************************************************************/
48 292
49/* mostly copied from op.c:cv_clone2 */ 293#define PRIO_MAX 3
50STATIC AV * 294#define PRIO_HIGH 1
51clone_padlist (AV *protopadlist) 295#define PRIO_NORMAL 0
296#define PRIO_LOW -1
297#define PRIO_IDLE -3
298#define PRIO_MIN -4
299
300/* for Coro.pm */
301static SV *coro_current;
302static SV *coro_readyhook;
303static AV *coro_ready [PRIO_MAX - PRIO_MIN + 1];
304static int coro_nready;
305static struct coro *coro_first;
306
307/** lowlevel stuff **********************************************************/
308
309static SV *
310coro_get_sv (pTHX_ const char *name, int create)
52{ 311{
53 AV *av; 312#if PERL_VERSION_ATLEAST (5,10,0)
54 I32 ix; 313 /* silence stupid and wrong 5.10 warning that I am unable to switch off */
55 AV *protopad_name = (AV *) * av_fetch (protopadlist, 0, FALSE); 314 get_sv (name, create);
56 AV *protopad = (AV *) * av_fetch (protopadlist, 1, FALSE); 315#endif
57 SV **pname = AvARRAY (protopad_name); 316 return get_sv (name, create);
58 SV **ppad = AvARRAY (protopad); 317}
59 I32 fname = AvFILLp (protopad_name); 318
60 I32 fpad = AvFILLp (protopad); 319static AV *
320coro_get_av (pTHX_ const char *name, int create)
321{
322#if PERL_VERSION_ATLEAST (5,10,0)
323 /* silence stupid and wrong 5.10 warning that I am unable to switch off */
324 get_av (name, create);
325#endif
326 return get_av (name, create);
327}
328
329static HV *
330coro_get_hv (pTHX_ const char *name, int create)
331{
332#if PERL_VERSION_ATLEAST (5,10,0)
333 /* silence stupid and wrong 5.10 warning that I am unable to switch off */
334 get_hv (name, create);
335#endif
336 return get_hv (name, create);
337}
338
339static AV *
340coro_clone_padlist (pTHX_ CV *cv)
341{
342 AV *padlist = CvPADLIST (cv);
61 AV *newpadlist, *newpad_name, *newpad; 343 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 344
72 newpadlist = newAV (); 345 newpadlist = newAV ();
73 AvREAL_off (newpadlist); 346 AvREAL_off (newpadlist);
74 av_store (newpadlist, 0, (SV *) newpad_name); 347#if PERL_VERSION_ATLEAST (5,10,0)
348 Perl_pad_push (aTHX_ padlist, AvFILLp (padlist) + 1);
349#else
350 Perl_pad_push (aTHX_ padlist, AvFILLp (padlist) + 1, 1);
351#endif
352 newpad = (AV *)AvARRAY (padlist)[AvFILLp (padlist)];
353 --AvFILLp (padlist);
354
355 av_store (newpadlist, 0, SvREFCNT_inc_NN (*av_fetch (padlist, 0, FALSE)));
75 av_store (newpadlist, 1, (SV *) newpad); 356 av_store (newpadlist, 1, (SV *)newpad);
76 357
77 av = newAV (); /* will be @_ */ 358 return newpadlist;
78 av_extend (av, 0); 359}
79 av_store (newpad, 0, (SV *) av);
80 AvFLAGS (av) = AVf_REIFY;
81 360
82 for (ix = fpad; ix > 0; ix--) 361static void
362free_padlist (pTHX_ AV *padlist)
363{
364 /* may be during global destruction */
365 if (SvREFCNT (padlist))
83 { 366 {
84 SV *namesv = (ix <= fname) ? pname[ix] : Nullsv; 367 I32 i = AvFILLp (padlist);
85 if (namesv && namesv != &PL_sv_undef) 368 while (i >= 0)
86 { 369 {
87 char *name = SvPVX (namesv); /* XXX */ 370 SV **svp = av_fetch (padlist, i--, FALSE);
88 if (SvFLAGS (namesv) & SVf_FAKE || *name == '&') 371 if (svp)
89 { /* lexical from outside? */
90 npad[ix] = SvREFCNT_inc (ppad[ix]);
91 } 372 {
92 else
93 { /* our own lexical */
94 SV *sv; 373 SV *sv;
95 if (*name == '&') 374 while (&PL_sv_undef != (sv = av_pop ((AV *)*svp)))
96 sv = SvREFCNT_inc (ppad[ix]); 375 SvREFCNT_dec (sv);
97 else if (*name == '@') 376
98 sv = (SV *) newAV (); 377 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 } 378 }
107 } 379 }
108 else if (IS_PADGV (ppad[ix]) || IS_PADCONST (ppad[ix]))
109 {
110 npad[ix] = SvREFCNT_inc (ppad[ix]);
111 }
112 else
113 {
114 SV *sv = NEWSV (0, 0);
115 SvPADTMP_on (sv);
116 npad[ix] = sv;
117 }
118 }
119 380
120#if 0 /* NONOTUNDERSTOOD */
121 /* Now that vars are all in place, clone nested closures. */
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 }
138#endif
139
140 return newpadlist;
141}
142
143STATIC AV *
144free_padlist (AV *padlist)
145{
146 /* may be during global destruction */
147 if (SvREFCNT(padlist))
148 {
149 I32 i = AvFILLp(padlist);
150 while (i >= 0)
151 {
152 SV **svp = av_fetch(padlist, i--, FALSE);
153 SV *sv = svp ? *svp : Nullsv;
154 if (sv)
155 SvREFCNT_dec(sv);
156 }
157
158 SvREFCNT_dec((SV*)padlist); 381 SvREFCNT_dec ((SV*)padlist);
382 }
383}
384
385static int
386coro_cv_free (pTHX_ SV *sv, MAGIC *mg)
387{
388 AV *padlist;
389 AV *av = (AV *)mg->mg_obj;
390
391 /* casting is fun. */
392 while (&PL_sv_undef != (SV *)(padlist = (AV *)av_pop (av)))
393 free_padlist (aTHX_ padlist);
394
395 SvREFCNT_dec (av); /* sv_magicext increased the refcount */
396
397 return 0;
398}
399
400#define CORO_MAGIC_type_cv PERL_MAGIC_ext
401#define CORO_MAGIC_type_state PERL_MAGIC_ext
402
403static MGVTBL coro_cv_vtbl = {
404 0, 0, 0, 0,
405 coro_cv_free
406};
407
408#define CORO_MAGIC(sv, type) \
409 SvMAGIC (sv) \
410 ? SvMAGIC (sv)->mg_type == type \
411 ? SvMAGIC (sv) \
412 : mg_find (sv, type) \
413 : 0
414
415#define CORO_MAGIC_cv(cv) CORO_MAGIC (((SV *)(cv)), CORO_MAGIC_type_cv)
416#define CORO_MAGIC_state(sv) CORO_MAGIC (((SV *)(sv)), CORO_MAGIC_type_state)
417
418INLINE struct coro *
419SvSTATE_ (pTHX_ SV *coro)
420{
421 HV *stash;
422 MAGIC *mg;
423
424 if (SvROK (coro))
425 coro = SvRV (coro);
426
427 if (expect_false (SvTYPE (coro) != SVt_PVHV))
428 croak ("Coro::State object required");
429
430 stash = SvSTASH (coro);
431 if (expect_false (stash != coro_stash && stash != coro_state_stash))
432 {
433 /* very slow, but rare, check */
434 if (!sv_derived_from (sv_2mortal (newRV_inc (coro)), "Coro::State"))
435 croak ("Coro::State object required");
436 }
437
438 mg = CORO_MAGIC_state (coro);
439 return (struct coro *)mg->mg_ptr;
440}
441
442#define SvSTATE(sv) SvSTATE_ (aTHX_ (sv))
443
444/* the next two functions merely cache the padlists */
445static void
446get_padlist (pTHX_ CV *cv)
447{
448 MAGIC *mg = CORO_MAGIC_cv (cv);
449 AV *av;
450
451 if (expect_true (mg && AvFILLp ((av = (AV *)mg->mg_obj)) >= 0))
452 CvPADLIST (cv) = (AV *)AvARRAY (av)[AvFILLp (av)--];
453 else
454 {
455#if CORO_PREFER_PERL_FUNCTIONS
456 /* this is probably cleaner? but also slower! */
457 /* in practise, it seems to be less stable */
458 CV *cp = Perl_cv_clone (cv);
459 CvPADLIST (cv) = CvPADLIST (cp);
460 CvPADLIST (cp) = 0;
461 SvREFCNT_dec (cp);
462#else
463 CvPADLIST (cv) = coro_clone_padlist (aTHX_ cv);
464#endif
465 }
466}
467
468static void
469put_padlist (pTHX_ CV *cv)
470{
471 MAGIC *mg = CORO_MAGIC_cv (cv);
472 AV *av;
473
474 if (expect_false (!mg))
475 mg = sv_magicext ((SV *)cv, (SV *)newAV (), CORO_MAGIC_type_cv, &coro_cv_vtbl, 0, 0);
476
477 av = (AV *)mg->mg_obj;
478
479 if (expect_false (AvFILLp (av) >= AvMAX (av)))
480 av_extend (av, AvMAX (av) + 1);
481
482 AvARRAY (av)[++AvFILLp (av)] = (SV *)CvPADLIST (cv);
483}
484
485/** load & save, init *******************************************************/
486
487static void
488load_perl (pTHX_ Coro__State c)
489{
490 perl_slots *slot = c->slot;
491 c->slot = 0;
492
493 PL_mainstack = c->mainstack;
494
495 GvSV (PL_defgv) = slot->defsv;
496 GvAV (PL_defgv) = slot->defav;
497 GvSV (PL_errgv) = slot->errsv;
498 GvSV (irsgv) = slot->irsgv;
499
500 #define VAR(name,type) PL_ ## name = slot->name;
501 # include "state.h"
502 #undef VAR
503
504 {
505 dSP;
506
507 CV *cv;
508
509 /* now do the ugly restore mess */
510 while (expect_true (cv = (CV *)POPs))
511 {
512 put_padlist (aTHX_ cv); /* mark this padlist as available */
513 CvDEPTH (cv) = PTR2IV (POPs);
514 CvPADLIST (cv) = (AV *)POPs;
515 }
516
517 PUTBACK;
159 } 518 }
160} 519}
161 520
162STATIC AV *
163unuse_padlist (AV *padlist)
164{
165 free_padlist (padlist);
166}
167
168static void 521static void
169SAVE(pTHX_ Coro__State c) 522save_perl (pTHX_ Coro__State c)
170{ 523{
171 { 524 {
172 dSP; 525 dSP;
173 I32 cxix = cxstack_ix; 526 I32 cxix = cxstack_ix;
527 PERL_CONTEXT *ccstk = cxstack;
174 PERL_SI *top_si = PL_curstackinfo; 528 PERL_SI *top_si = PL_curstackinfo;
175 PERL_CONTEXT *ccstk = cxstack;
176 529
177 /* 530 /*
178 * the worst thing you can imagine happens first - we have to save 531 * the worst thing you can imagine happens first - we have to save
179 * (and reinitialize) all cv's in the whole callchain :( 532 * (and reinitialize) all cv's in the whole callchain :(
180 */ 533 */
181 534
182 PUSHs (Nullsv); 535 XPUSHs (Nullsv);
183 /* this loop was inspired by pp_caller */ 536 /* this loop was inspired by pp_caller */
184 for (;;) 537 for (;;)
185 { 538 {
186 while (cxix >= 0) 539 while (expect_true (cxix >= 0))
187 { 540 {
188 PERL_CONTEXT *cx = &ccstk[--cxix]; 541 PERL_CONTEXT *cx = &ccstk[cxix--];
189 542
190 if (CxTYPE(cx) == CXt_SUB) 543 if (expect_true (CxTYPE (cx) == CXt_SUB || CxTYPE (cx) == CXt_FORMAT))
191 { 544 {
192 CV *cv = cx->blk_sub.cv; 545 CV *cv = cx->blk_sub.cv;
546
193 if (CvDEPTH(cv)) 547 if (expect_true (CvDEPTH (cv)))
194 { 548 {
195#ifdef USE_THREADS
196 XPUSHs ((SV *)CvOWNER(cv));
197#endif
198 EXTEND (SP, 3); 549 EXTEND (SP, 3);
199 PUSHs ((SV *)CvDEPTH(cv));
200 PUSHs ((SV *)CvPADLIST(cv)); 550 PUSHs ((SV *)CvPADLIST (cv));
551 PUSHs (INT2PTR (SV *, (IV)CvDEPTH (cv)));
201 PUSHs ((SV *)cv); 552 PUSHs ((SV *)cv);
202 553
203 CvPADLIST(cv) = clone_padlist (CvPADLIST(cv));
204
205 CvDEPTH(cv) = 0; 554 CvDEPTH (cv) = 0;
206#ifdef USE_THREADS 555 get_padlist (aTHX_ cv);
207 CvOWNER(cv) = 0;
208 error must unlock this cv etc.. etc...
209 if you are here wondering about this error message then
210 the reason is that it will not work as advertised yet
211#endif
212 } 556 }
213 } 557 }
214 else if (CxTYPE(cx) == CXt_FORMAT) 558 }
559
560 if (expect_true (top_si->si_type == PERLSI_MAIN))
561 break;
562
563 top_si = top_si->si_prev;
564 ccstk = top_si->si_cxstack;
565 cxix = top_si->si_cxix;
566 }
567
568 PUTBACK;
569 }
570
571 /* allocate some space on the context stack for our purposes */
572 /* we manually unroll here, as usually 2 slots is enough */
573 if (SLOT_COUNT >= 1) CXINC;
574 if (SLOT_COUNT >= 2) CXINC;
575 if (SLOT_COUNT >= 3) CXINC;
576 {
577 int i;
578 for (i = 3; i < SLOT_COUNT; ++i)
579 CXINC;
580 }
581 cxstack_ix -= SLOT_COUNT; /* undo allocation */
582
583 c->mainstack = PL_mainstack;
584
585 {
586 perl_slots *slot = c->slot = (perl_slots *)(cxstack + cxstack_ix + 1);
587
588 slot->defav = GvAV (PL_defgv);
589 slot->defsv = DEFSV;
590 slot->errsv = ERRSV;
591 slot->irsgv = GvSV (irsgv);
592
593 #define VAR(name,type) slot->name = PL_ ## name;
594 # include "state.h"
595 #undef VAR
596 }
597}
598
599/*
600 * allocate various perl stacks. This is an exact copy
601 * of perl.c:init_stacks, except that it uses less memory
602 * on the (sometimes correct) assumption that coroutines do
603 * not usually need a lot of stackspace.
604 */
605#if CORO_PREFER_PERL_FUNCTIONS
606# define coro_init_stacks init_stacks
607#else
608static void
609coro_init_stacks (pTHX)
610{
611 PL_curstackinfo = new_stackinfo(32, 8);
612 PL_curstackinfo->si_type = PERLSI_MAIN;
613 PL_curstack = PL_curstackinfo->si_stack;
614 PL_mainstack = PL_curstack; /* remember in case we switch stacks */
615
616 PL_stack_base = AvARRAY(PL_curstack);
617 PL_stack_sp = PL_stack_base;
618 PL_stack_max = PL_stack_base + AvMAX(PL_curstack);
619
620 New(50,PL_tmps_stack,32,SV*);
621 PL_tmps_floor = -1;
622 PL_tmps_ix = -1;
623 PL_tmps_max = 32;
624
625 New(54,PL_markstack,16,I32);
626 PL_markstack_ptr = PL_markstack;
627 PL_markstack_max = PL_markstack + 16;
628
629#ifdef SET_MARK_OFFSET
630 SET_MARK_OFFSET;
631#endif
632
633 New(54,PL_scopestack,8,I32);
634 PL_scopestack_ix = 0;
635 PL_scopestack_max = 8;
636
637 New(54,PL_savestack,24,ANY);
638 PL_savestack_ix = 0;
639 PL_savestack_max = 24;
640
641#if !PERL_VERSION_ATLEAST (5,10,0)
642 New(54,PL_retstack,4,OP*);
643 PL_retstack_ix = 0;
644 PL_retstack_max = 4;
645#endif
646}
647#endif
648
649/*
650 * destroy the stacks, the callchain etc...
651 */
652static void
653coro_destruct_stacks (pTHX)
654{
655 while (PL_curstackinfo->si_next)
656 PL_curstackinfo = PL_curstackinfo->si_next;
657
658 while (PL_curstackinfo)
659 {
660 PERL_SI *p = PL_curstackinfo->si_prev;
661
662 if (!IN_DESTRUCT)
663 SvREFCNT_dec (PL_curstackinfo->si_stack);
664
665 Safefree (PL_curstackinfo->si_cxstack);
666 Safefree (PL_curstackinfo);
667 PL_curstackinfo = p;
668 }
669
670 Safefree (PL_tmps_stack);
671 Safefree (PL_markstack);
672 Safefree (PL_scopestack);
673 Safefree (PL_savestack);
674#if !PERL_VERSION_ATLEAST (5,10,0)
675 Safefree (PL_retstack);
676#endif
677}
678
679static size_t
680coro_rss (pTHX_ struct coro *coro)
681{
682 size_t rss = sizeof (*coro);
683
684 if (coro->mainstack)
685 {
686 perl_slots tmp_slot;
687 perl_slots *slot;
688
689 if (coro->flags & CF_RUNNING)
690 {
691 slot = &tmp_slot;
692
693 #define VAR(name,type) slot->name = PL_ ## name;
694 # include "state.h"
695 #undef VAR
696 }
697 else
698 slot = coro->slot;
699
700 if (slot)
701 {
702 rss += sizeof (slot->curstackinfo);
703 rss += (slot->curstackinfo->si_cxmax + 1) * sizeof (PERL_CONTEXT);
704 rss += sizeof (SV) + sizeof (struct xpvav) + (1 + AvMAX (slot->curstack)) * sizeof (SV *);
705 rss += slot->tmps_max * sizeof (SV *);
706 rss += (slot->markstack_max - slot->markstack_ptr) * sizeof (I32);
707 rss += slot->scopestack_max * sizeof (I32);
708 rss += slot->savestack_max * sizeof (ANY);
709
710#if !PERL_VERSION_ATLEAST (5,10,0)
711 rss += slot->retstack_max * sizeof (OP *);
712#endif
713 }
714 }
715
716 return rss;
717}
718
719/** set stacklevel support **************************************************/
720
721/* we sometimes need to create the effect of pp_slf calling us */
722#define SLF_HEAD (void)0
723/* we sometimes need to create the effect of leaving via pp_slf */
724#define SLF_TAIL slf_tail (aTHX)
725
726INLINE void
727slf_tail (pTHX)
728{
729 dSP;
730 SV **bot = SP;
731
732 int gimme = GIMME_V;
733
734 /* make sure we put something on the stack in scalar context */
735 if (gimme == G_SCALAR)
736 {
737 if (sp == bot)
738 XPUSHs (&PL_sv_undef);
739
740 SP = bot + 1;
741 }
742
743 PUTBACK;
744}
745
746/** coroutine stack handling ************************************************/
747
748static int (*orig_sigelem_get) (pTHX_ SV *sv, MAGIC *mg);
749static int (*orig_sigelem_set) (pTHX_ SV *sv, MAGIC *mg);
750static int (*orig_sigelem_clr) (pTHX_ SV *sv, MAGIC *mg);
751
752/* apparently < 5.8.8 */
753#ifndef MgPV_nolen_const
754#define MgPV_nolen_const(mg) (((((int)(mg)->mg_len)) == HEf_SVKEY) ? \
755 SvPV_nolen((SV*)((mg)->mg_ptr)) : \
756 (const char*)(mg)->mg_ptr)
757#endif
758
759/*
760 * This overrides the default magic get method of %SIG elements.
761 * The original one doesn't provide for reading back of PL_diehook/PL_warnhook
762 * and instead of tryign to save and restore the hash elements, we just provide
763 * readback here.
764 * We only do this when the hook is != 0, as they are often set to 0 temporarily,
765 * not expecting this to actually change the hook. This is a potential problem
766 * when a schedule happens then, but we ignore this.
767 */
768static int
769coro_sigelem_get (pTHX_ SV *sv, MAGIC *mg)
770{
771 const char *s = MgPV_nolen_const (mg);
772
773 if (*s == '_')
774 {
775 SV **svp = 0;
776
777 if (strEQ (s, "__DIE__" )) svp = &PL_diehook;
778 if (strEQ (s, "__WARN__")) svp = &PL_warnhook;
779
780 if (svp)
781 {
782 sv_setsv (sv, *svp ? *svp : &PL_sv_undef);
783 return 0;
784 }
785 }
786
787 return orig_sigelem_get ? orig_sigelem_get (aTHX_ sv, mg) : 0;
788}
789
790static int
791coro_sigelem_clr (pTHX_ SV *sv, MAGIC *mg)
792{
793 const char *s = MgPV_nolen_const (mg);
794
795 if (*s == '_')
796 {
797 SV **svp = 0;
798
799 if (strEQ (s, "__DIE__" )) svp = &PL_diehook;
800 if (strEQ (s, "__WARN__")) svp = &PL_warnhook;
801
802 if (svp)
803 {
804 SV *old = *svp;
805 *svp = 0;
806 SvREFCNT_dec (old);
807 return 0;
808 }
809 }
810
811 return orig_sigelem_clr ? orig_sigelem_clr (aTHX_ sv, mg) : 0;
812}
813
814static int
815coro_sigelem_set (pTHX_ SV *sv, MAGIC *mg)
816{
817 const char *s = MgPV_nolen_const (mg);
818
819 if (*s == '_')
820 {
821 SV **svp = 0;
822
823 if (strEQ (s, "__DIE__" )) svp = &PL_diehook;
824 if (strEQ (s, "__WARN__")) svp = &PL_warnhook;
825
826 if (svp)
827 {
828 SV *old = *svp;
829 *svp = newSVsv (sv);
830 SvREFCNT_dec (old);
831 return 0;
832 }
833 }
834
835 return orig_sigelem_set ? orig_sigelem_set (aTHX_ sv, mg) : 0;
836}
837
838static void
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_flags = OPf_WANT_VOID;
877
878 PUSHMARK (SP);
879 XPUSHs (sv_2mortal (av_shift (GvAV (PL_defgv))));
880 PUTBACK;
881 PL_op = (OP *)&myop;
882 PL_op = PL_ppaddr[OP_ENTERSUB](aTHX);
883 SPAGAIN;
884 }
885
886 /* this newly created coroutine might be run on an existing cctx which most
887 * likely was suspended in set_stacklevel, called from pp_set_stacklevel,
888 * so we have to emulate entering pp_set_stacklevel here.
889 */
890 SLF_HEAD;
891}
892
893static void
894coro_destruct (pTHX_ struct coro *coro)
895{
896 if (!IN_DESTRUCT)
897 {
898 /* restore all saved variables and stuff */
899 LEAVE_SCOPE (0);
900 assert (PL_tmps_floor == -1);
901
902 /* free all temporaries */
903 FREETMPS;
904 assert (PL_tmps_ix == -1);
905
906 /* unwind all extra stacks */
907 POPSTACK_TO (PL_mainstack);
908
909 /* unwind main stack */
910 dounwind (-1);
911 }
912
913 SvREFCNT_dec (GvSV (PL_defgv));
914 SvREFCNT_dec (GvAV (PL_defgv));
915 SvREFCNT_dec (GvSV (PL_errgv));
916 SvREFCNT_dec (PL_defoutgv);
917 SvREFCNT_dec (PL_rs);
918 SvREFCNT_dec (GvSV (irsgv));
919
920 SvREFCNT_dec (PL_diehook);
921 SvREFCNT_dec (PL_warnhook);
922
923 SvREFCNT_dec (coro->saved_deffh);
924 SvREFCNT_dec (coro->throw);
925
926 coro_destruct_stacks (aTHX);
927}
928
929INLINE void
930free_coro_mortal (pTHX)
931{
932 if (expect_true (coro_mortal))
933 {
934 SvREFCNT_dec (coro_mortal);
935 coro_mortal = 0;
936 }
937}
938
939static int
940runops_trace (pTHX)
941{
942 COP *oldcop = 0;
943 int oldcxix = -2;
944 struct coro *coro = SvSTATE (coro_current); /* trace cctx is tied to specific coro */
945 coro_cctx *cctx = coro->cctx;
946
947 while ((PL_op = CALL_FPTR (PL_op->op_ppaddr) (aTHX)))
948 {
949 PERL_ASYNC_CHECK ();
950
951 if (cctx->flags & CC_TRACE_ALL)
952 {
953 if (PL_op->op_type == OP_LEAVESUB && cctx->flags & CC_TRACE_SUB)
954 {
955 PERL_CONTEXT *cx = &cxstack[cxstack_ix];
956 SV **bot, **top;
957 AV *av = newAV (); /* return values */
958 SV **cb;
959 dSP;
960
961 GV *gv = CvGV (cx->blk_sub.cv);
962 SV *fullname = sv_2mortal (newSV (0));
963 if (isGV (gv))
964 gv_efullname3 (fullname, gv, 0);
965
966 bot = PL_stack_base + cx->blk_oldsp + 1;
967 top = cx->blk_gimme == G_ARRAY ? SP + 1
968 : cx->blk_gimme == G_SCALAR ? bot + 1
969 : bot;
970
971 av_extend (av, top - bot);
972 while (bot < top)
973 av_push (av, SvREFCNT_inc_NN (*bot++));
974
975 PL_runops = RUNOPS_DEFAULT;
976 ENTER;
977 SAVETMPS;
978 EXTEND (SP, 3);
979 PUSHMARK (SP);
980 PUSHs (&PL_sv_no);
981 PUSHs (fullname);
982 PUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
983 PUTBACK;
984 cb = hv_fetch ((HV *)SvRV (coro_current), "_trace_sub_cb", sizeof ("_trace_sub_cb") - 1, 0);
985 if (cb) call_sv (*cb, G_KEEPERR | G_EVAL | G_VOID | G_DISCARD);
986 SPAGAIN;
987 FREETMPS;
988 LEAVE;
989 PL_runops = runops_trace;
990 }
991
992 if (oldcop != PL_curcop)
993 {
994 oldcop = PL_curcop;
995
996 if (PL_curcop != &PL_compiling)
997 {
998 SV **cb;
999
1000 if (oldcxix != cxstack_ix && cctx->flags & CC_TRACE_SUB)
1001 {
1002 PERL_CONTEXT *cx = &cxstack[cxstack_ix];
1003
1004 if (CxTYPE (cx) == CXt_SUB && oldcxix < cxstack_ix)
1005 {
1006 runops_proc_t old_runops = PL_runops;
1007 dSP;
1008 GV *gv = CvGV (cx->blk_sub.cv);
1009 SV *fullname = sv_2mortal (newSV (0));
1010
1011 if (isGV (gv))
1012 gv_efullname3 (fullname, gv, 0);
1013
1014 PL_runops = RUNOPS_DEFAULT;
1015 ENTER;
1016 SAVETMPS;
1017 EXTEND (SP, 3);
1018 PUSHMARK (SP);
1019 PUSHs (&PL_sv_yes);
1020 PUSHs (fullname);
1021 PUSHs (CxHASARGS (cx) ? sv_2mortal (newRV_inc ((SV *)cx->blk_sub.argarray)) : &PL_sv_undef);
1022 PUTBACK;
1023 cb = hv_fetch ((HV *)SvRV (coro_current), "_trace_sub_cb", sizeof ("_trace_sub_cb") - 1, 0);
1024 if (cb) call_sv (*cb, G_KEEPERR | G_EVAL | G_VOID | G_DISCARD);
1025 SPAGAIN;
1026 FREETMPS;
1027 LEAVE;
1028 PL_runops = runops_trace;
1029 }
1030
1031 oldcxix = cxstack_ix;
1032 }
1033
1034 if (cctx->flags & CC_TRACE_LINE)
1035 {
1036 dSP;
1037
1038 PL_runops = RUNOPS_DEFAULT;
1039 ENTER;
1040 SAVETMPS;
1041 EXTEND (SP, 3);
1042 PL_runops = RUNOPS_DEFAULT;
1043 PUSHMARK (SP);
1044 PUSHs (sv_2mortal (newSVpv (OutCopFILE (oldcop), 0)));
1045 PUSHs (sv_2mortal (newSViv (CopLINE (oldcop))));
1046 PUTBACK;
1047 cb = hv_fetch ((HV *)SvRV (coro_current), "_trace_line_cb", sizeof ("_trace_line_cb") - 1, 0);
1048 if (cb) call_sv (*cb, G_KEEPERR | G_EVAL | G_VOID | G_DISCARD);
1049 SPAGAIN;
1050 FREETMPS;
1051 LEAVE;
1052 PL_runops = runops_trace;
1053 }
1054 }
1055 }
1056 }
1057 }
1058
1059 TAINT_NOT;
1060 return 0;
1061}
1062
1063static void
1064prepare_set_stacklevel (struct transfer_args *ta, struct coro_cctx *cctx)
1065{
1066 ta->prev = (struct coro *)cctx;
1067 ta->next = 0;
1068}
1069
1070/* inject a fake call to Coro::State::_cctx_init into the execution */
1071/* _cctx_init should be careful, as it could be called at almost any time */
1072/* during execution of a perl program */
1073/* also initialises PL_top_env */
1074static void NOINLINE
1075cctx_prepare (pTHX_ coro_cctx *cctx)
1076{
1077 dSP;
1078 UNOP myop;
1079
1080 PL_top_env = &PL_start_env;
1081
1082 if (cctx->flags & CC_TRACE)
1083 PL_runops = runops_trace;
1084
1085 Zero (&myop, 1, UNOP);
1086 myop.op_next = PL_op;
1087 myop.op_flags = OPf_WANT_VOID | OPf_STACKED;
1088
1089 PUSHMARK (SP);
1090 EXTEND (SP, 2);
1091 PUSHs (sv_2mortal (newSViv ((IV)cctx)));
1092 PUSHs ((SV *)get_cv ("Coro::State::_cctx_init", FALSE));
1093 PUTBACK;
1094 PL_op = (OP *)&myop;
1095 PL_op = PL_ppaddr[OP_ENTERSUB](aTHX);
1096 SPAGAIN;
1097}
1098
1099/* the tail of transfer: execute stuff we can only do after a transfer */
1100INLINE void
1101transfer_tail (pTHX)
1102{
1103 struct coro *next = (struct coro *)transfer_next;
1104 assert (!(transfer_next = 0)); /* just used for the side effect when asserts are enabled */
1105 assert (("FATAL: next coroutine was zero in transfer_tail (please report)", next));
1106
1107 free_coro_mortal (aTHX);
1108 UNLOCK;
1109
1110 if (expect_false (next->throw))
1111 {
1112 SV *exception = sv_2mortal (next->throw);
1113
1114 next->throw = 0;
1115 sv_setsv (ERRSV, exception);
1116 croak (0);
1117 }
1118}
1119
1120/*
1121 * this is a _very_ stripped down perl interpreter ;)
1122 */
1123static void
1124cctx_run (void *arg)
1125{
1126#ifdef USE_ITHREADS
1127# if CORO_PTHREAD
1128 PERL_SET_CONTEXT (coro_thx);
1129# endif
1130#endif
1131 {
1132 dTHX;
1133
1134 /* we are the alternative tail to pp_set_stacklevel */
1135 /* so do the same things here */
1136 SLF_TAIL;
1137
1138 /* we now skip the op that did lead to transfer() */
1139 PL_op = PL_op->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 /*
1152 * If perl-run returns we assume exit() was being called or the coro
1153 * fell off the end, which seems to be the only valid (non-bug)
1154 * reason for perl_run to return. We try to exit by jumping to the
1155 * bootstrap-time "top" top_env, as we cannot restore the "main"
1156 * coroutine as Coro has no such concept
1157 */
1158 PL_top_env = main_top_env;
1159 JMPENV_JUMP (2); /* I do not feel well about the hardcoded 2 at all */
1160 }
1161}
1162
1163static coro_cctx *
1164cctx_new ()
1165{
1166 coro_cctx *cctx;
1167
1168 ++cctx_count;
1169 New (0, cctx, 1, coro_cctx);
1170
1171 cctx->gen = cctx_gen;
1172 cctx->flags = 0;
1173 cctx->idle_sp = 0; /* can be accessed by transfer between cctx_run and set_stacklevel, on throw */
1174
1175 return cctx;
1176}
1177
1178/* create a new cctx only suitable as source */
1179static coro_cctx *
1180cctx_new_empty ()
1181{
1182 coro_cctx *cctx = cctx_new ();
1183
1184 cctx->sptr = 0;
1185 coro_create (&cctx->cctx, 0, 0, 0, 0);
1186
1187 return cctx;
1188}
1189
1190/* create a new cctx suitable as destination/running a perl interpreter */
1191static coro_cctx *
1192cctx_new_run ()
1193{
1194 coro_cctx *cctx = cctx_new ();
1195 void *stack_start;
1196 size_t stack_size;
1197
1198#if HAVE_MMAP
1199 cctx->ssize = ((cctx_stacksize * sizeof (long) + PAGESIZE - 1) / PAGESIZE + CORO_STACKGUARD) * PAGESIZE;
1200 /* mmap supposedly does allocate-on-write for us */
1201 cctx->sptr = mmap (0, cctx->ssize, PROT_EXEC|PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);
1202
1203 if (cctx->sptr != (void *)-1)
1204 {
1205 #if CORO_STACKGUARD
1206 mprotect (cctx->sptr, CORO_STACKGUARD * PAGESIZE, PROT_NONE);
1207 #endif
1208 stack_start = (char *)cctx->sptr + CORO_STACKGUARD * PAGESIZE;
1209 stack_size = cctx->ssize - CORO_STACKGUARD * PAGESIZE;
1210 cctx->flags |= CC_MAPPED;
1211 }
1212 else
1213#endif
1214 {
1215 cctx->ssize = cctx_stacksize * (long)sizeof (long);
1216 New (0, cctx->sptr, cctx_stacksize, long);
1217
1218 if (!cctx->sptr)
1219 {
1220 perror ("FATAL: unable to allocate stack for coroutine, exiting.");
1221 _exit (EXIT_FAILURE);
1222 }
1223
1224 stack_start = cctx->sptr;
1225 stack_size = cctx->ssize;
1226 }
1227
1228 #if CORO_USE_VALGRIND
1229 cctx->valgrind_id = VALGRIND_STACK_REGISTER ((char *)stack_start, (char *)stack_start + stack_size);
1230 #endif
1231
1232 coro_create (&cctx->cctx, cctx_run, (void *)cctx, stack_start, stack_size);
1233
1234 return cctx;
1235}
1236
1237static void
1238cctx_destroy (coro_cctx *cctx)
1239{
1240 if (!cctx)
1241 return;
1242
1243 --cctx_count;
1244 coro_destroy (&cctx->cctx);
1245
1246 /* coro_transfer creates new, empty cctx's */
1247 if (cctx->sptr)
1248 {
1249 #if CORO_USE_VALGRIND
1250 VALGRIND_STACK_DEREGISTER (cctx->valgrind_id);
1251 #endif
1252
1253#if HAVE_MMAP
1254 if (cctx->flags & CC_MAPPED)
1255 munmap (cctx->sptr, cctx->ssize);
1256 else
1257#endif
1258 Safefree (cctx->sptr);
1259 }
1260
1261 Safefree (cctx);
1262}
1263
1264/* wether this cctx should be destructed */
1265#define CCTX_EXPIRED(cctx) ((cctx)->gen != cctx_gen || ((cctx)->flags & CC_NOREUSE))
1266
1267static coro_cctx *
1268cctx_get (pTHX)
1269{
1270 while (expect_true (cctx_first))
1271 {
1272 coro_cctx *cctx = cctx_first;
1273 cctx_first = cctx->next;
1274 --cctx_idle;
1275
1276 if (expect_true (!CCTX_EXPIRED (cctx)))
1277 return cctx;
1278
1279 cctx_destroy (cctx);
1280 }
1281
1282 return cctx_new_run ();
1283}
1284
1285static void
1286cctx_put (coro_cctx *cctx)
1287{
1288 assert (("FATAL: cctx_put called on non-initialised cctx in Coro (please report)", cctx->sptr));
1289
1290 /* free another cctx if overlimit */
1291 if (expect_false (cctx_idle >= cctx_max_idle))
1292 {
1293 coro_cctx *first = cctx_first;
1294 cctx_first = first->next;
1295 --cctx_idle;
1296
1297 cctx_destroy (first);
1298 }
1299
1300 ++cctx_idle;
1301 cctx->next = cctx_first;
1302 cctx_first = cctx;
1303}
1304
1305/** coroutine switching *****************************************************/
1306
1307static void
1308transfer_check (pTHX_ struct coro *prev, struct coro *next)
1309{
1310 if (expect_true (prev != next))
1311 {
1312 if (expect_false (!(prev->flags & (CF_RUNNING | CF_NEW))))
1313 croak ("Coro::State::transfer called with non-running/new prev Coro::State, but can only transfer from running or new states");
1314
1315 if (expect_false (next->flags & CF_RUNNING))
1316 croak ("Coro::State::transfer called with running next Coro::State, but can only transfer to inactive states");
1317
1318 if (expect_false (next->flags & CF_DESTROYED))
1319 croak ("Coro::State::transfer called with destroyed next Coro::State, but can only transfer to inactive states");
1320
1321#if !PERL_VERSION_ATLEAST (5,10,0)
1322 if (expect_false (PL_lex_state != LEX_NOTPARSING))
1323 croak ("Coro::State::transfer called while parsing, but this is not supported in your perl version");
1324#endif
1325 }
1326}
1327
1328/* always use the TRANSFER macro */
1329static void NOINLINE
1330transfer (pTHX_ struct coro *prev, struct coro *next, int force_cctx)
1331{
1332 dSTACKLEVEL;
1333
1334 /* sometimes transfer is only called to set idle_sp */
1335 if (expect_false (!next))
1336 {
1337 ((coro_cctx *)prev)->idle_sp = stacklevel;
1338 assert (((coro_cctx *)prev)->idle_te = PL_top_env); /* just for the side-effect when asserts are enabled */
1339 }
1340 else if (expect_true (prev != next))
1341 {
1342 coro_cctx *prev__cctx;
1343
1344 if (expect_false (prev->flags & CF_NEW))
1345 {
1346 /* create a new empty/source context */
1347 prev->cctx = cctx_new_empty ();
1348 prev->flags &= ~CF_NEW;
1349 prev->flags |= CF_RUNNING;
1350 }
1351
1352 prev->flags &= ~CF_RUNNING;
1353 next->flags |= CF_RUNNING;
1354
1355 LOCK;
1356
1357 /* first get rid of the old state */
1358 save_perl (aTHX_ prev);
1359
1360 if (expect_false (next->flags & CF_NEW))
1361 {
1362 /* need to start coroutine */
1363 next->flags &= ~CF_NEW;
1364 /* setup coroutine call */
1365 coro_setup (aTHX_ next);
1366 }
1367 else
1368 load_perl (aTHX_ next);
1369
1370 prev__cctx = prev->cctx;
1371
1372 /* possibly untie and reuse the cctx */
1373 if (expect_true (
1374 prev__cctx->idle_sp == stacklevel
1375 && !(prev__cctx->flags & CC_TRACE)
1376 && !force_cctx
1377 ))
1378 {
1379 /* I assume that stacklevel is a stronger indicator than PL_top_env changes */
1380 assert (("FATAL: current top_env must equal previous top_env in Coro (please report)", PL_top_env == prev__cctx->idle_te));
1381
1382 prev->cctx = 0;
1383
1384 /* if the cctx is about to be destroyed we need to make sure we won't see it in cctx_get */
1385 /* without this the next cctx_get might destroy the prev__cctx while still in use */
1386 if (expect_false (CCTX_EXPIRED (prev__cctx)))
1387 if (!next->cctx)
1388 next->cctx = cctx_get (aTHX);
1389
1390 cctx_put (prev__cctx);
1391 }
1392
1393 ++next->usecount;
1394
1395 if (expect_true (!next->cctx))
1396 next->cctx = cctx_get (aTHX);
1397
1398 assert (("FATAL: transfer_next already nonzero in Coro (please report)", !transfer_next));
1399 transfer_next = next;
1400
1401 if (expect_false (prev__cctx != next->cctx))
1402 {
1403 prev__cctx->top_env = PL_top_env;
1404 PL_top_env = next->cctx->top_env;
1405 coro_transfer (&prev__cctx->cctx, &next->cctx->cctx);
1406 }
1407
1408 transfer_tail (aTHX);
1409 }
1410}
1411
1412#define TRANSFER(ta, force_cctx) transfer (aTHX_ (ta).prev, (ta).next, (force_cctx))
1413#define TRANSFER_CHECK(ta) transfer_check (aTHX_ (ta).prev, (ta).next)
1414
1415/** high level stuff ********************************************************/
1416
1417static int
1418coro_state_destroy (pTHX_ struct coro *coro)
1419{
1420 if (coro->flags & CF_DESTROYED)
1421 return 0;
1422
1423 coro->flags |= CF_DESTROYED;
1424
1425 if (coro->flags & CF_READY)
1426 {
1427 /* reduce nready, as destroying a ready coro effectively unreadies it */
1428 /* alternative: look through all ready queues and remove the coro */
1429 LOCK;
1430 --coro_nready;
1431 UNLOCK;
1432 }
1433 else
1434 coro->flags |= CF_READY; /* make sure it is NOT put into the readyqueue */
1435
1436 if (coro->mainstack && coro->mainstack != main_mainstack)
1437 {
1438 struct coro temp;
1439
1440 if (coro->flags & CF_RUNNING)
1441 croak ("FATAL: tried to destroy currently running coroutine");
1442
1443 save_perl (aTHX_ &temp);
1444 load_perl (aTHX_ coro);
1445
1446 coro_destruct (aTHX_ coro);
1447
1448 load_perl (aTHX_ &temp);
1449
1450 coro->slot = 0;
1451 }
1452
1453 cctx_destroy (coro->cctx);
1454 SvREFCNT_dec (coro->args);
1455
1456 if (coro->next) coro->next->prev = coro->prev;
1457 if (coro->prev) coro->prev->next = coro->next;
1458 if (coro == coro_first) coro_first = coro->next;
1459
1460 return 1;
1461}
1462
1463static int
1464coro_state_free (pTHX_ SV *sv, MAGIC *mg)
1465{
1466 struct coro *coro = (struct coro *)mg->mg_ptr;
1467 mg->mg_ptr = 0;
1468
1469 coro->hv = 0;
1470
1471 if (--coro->refcnt < 0)
1472 {
1473 coro_state_destroy (aTHX_ coro);
1474 Safefree (coro);
1475 }
1476
1477 return 0;
1478}
1479
1480static int
1481coro_state_dup (pTHX_ MAGIC *mg, CLONE_PARAMS *params)
1482{
1483 struct coro *coro = (struct coro *)mg->mg_ptr;
1484
1485 ++coro->refcnt;
1486
1487 return 0;
1488}
1489
1490static MGVTBL coro_state_vtbl = {
1491 0, 0, 0, 0,
1492 coro_state_free,
1493 0,
1494#ifdef MGf_DUP
1495 coro_state_dup,
1496#else
1497# define MGf_DUP 0
1498#endif
1499};
1500
1501static void
1502prepare_transfer (pTHX_ struct transfer_args *ta, SV *prev_sv, SV *next_sv)
1503{
1504 ta->prev = SvSTATE (prev_sv);
1505 ta->next = SvSTATE (next_sv);
1506 TRANSFER_CHECK (*ta);
1507}
1508
1509static void
1510api_transfer (SV *prev_sv, SV *next_sv)
1511{
1512 dTHX;
1513 struct transfer_args ta;
1514
1515 prepare_transfer (aTHX_ &ta, prev_sv, next_sv);
1516 TRANSFER (ta, 1);
1517}
1518
1519/** Coro ********************************************************************/
1520
1521static void
1522coro_enq (pTHX_ SV *coro_sv)
1523{
1524 av_push (coro_ready [SvSTATE (coro_sv)->prio - PRIO_MIN], coro_sv);
1525}
1526
1527static SV *
1528coro_deq (pTHX)
1529{
1530 int prio;
1531
1532 for (prio = PRIO_MAX - PRIO_MIN + 1; --prio >= 0; )
1533 if (AvFILLp (coro_ready [prio]) >= 0)
1534 return av_shift (coro_ready [prio]);
1535
1536 return 0;
1537}
1538
1539static int
1540api_ready (SV *coro_sv)
1541{
1542 dTHX;
1543 struct coro *coro;
1544 SV *sv_hook;
1545 void (*xs_hook)(void);
1546
1547 if (SvROK (coro_sv))
1548 coro_sv = SvRV (coro_sv);
1549
1550 coro = SvSTATE (coro_sv);
1551
1552 if (coro->flags & CF_READY)
1553 return 0;
1554
1555 coro->flags |= CF_READY;
1556
1557 LOCK;
1558
1559 sv_hook = coro_nready ? 0 : coro_readyhook;
1560 xs_hook = coro_nready ? 0 : coroapi.readyhook;
1561
1562 coro_enq (aTHX_ SvREFCNT_inc_NN (coro_sv));
1563 ++coro_nready;
1564
1565 UNLOCK;
1566
1567 if (sv_hook)
1568 {
1569 dSP;
1570
1571 ENTER;
1572 SAVETMPS;
1573
1574 PUSHMARK (SP);
1575 PUTBACK;
1576 call_sv (sv_hook, G_DISCARD);
1577 SPAGAIN;
1578
1579 FREETMPS;
1580 LEAVE;
1581 }
1582
1583 if (xs_hook)
1584 xs_hook ();
1585
1586 return 1;
1587}
1588
1589static int
1590api_is_ready (SV *coro_sv)
1591{
1592 dTHX;
1593
1594 return !!(SvSTATE (coro_sv)->flags & CF_READY);
1595}
1596
1597INLINE void
1598prepare_schedule (pTHX_ struct transfer_args *ta)
1599{
1600 SV *prev_sv, *next_sv;
1601
1602 for (;;)
1603 {
1604 LOCK;
1605 next_sv = coro_deq (aTHX);
1606
1607 /* nothing to schedule: call the idle handler */
1608 if (expect_false (!next_sv))
1609 {
1610 dSP;
1611 UNLOCK;
1612
1613 ENTER;
1614 SAVETMPS;
1615
1616 PUSHMARK (SP);
1617 PUTBACK;
1618 call_sv (get_sv ("Coro::idle", FALSE), G_DISCARD);
1619 SPAGAIN;
1620
1621 FREETMPS;
1622 LEAVE;
1623 continue;
1624 }
1625
1626 ta->next = SvSTATE (next_sv);
1627
1628 /* cannot transfer to destroyed coros, skip and look for next */
1629 if (expect_false (ta->next->flags & CF_DESTROYED))
1630 {
1631 UNLOCK;
1632 SvREFCNT_dec (next_sv);
1633 /* coro_nready has already been taken care of by destroy */
1634 continue;
1635 }
1636
1637 --coro_nready;
1638 UNLOCK;
1639 break;
1640 }
1641
1642 /* free this only after the transfer */
1643 prev_sv = SvRV (coro_current);
1644 ta->prev = SvSTATE (prev_sv);
1645 TRANSFER_CHECK (*ta);
1646 assert (("FATAL: next coroutine isn't marked as ready in Coro (please report)", ta->next->flags & CF_READY));
1647 ta->next->flags &= ~CF_READY;
1648 SvRV_set (coro_current, next_sv);
1649
1650 LOCK;
1651 free_coro_mortal (aTHX);
1652 coro_mortal = prev_sv;
1653 UNLOCK;
1654}
1655
1656INLINE void
1657prepare_cede (pTHX_ struct transfer_args *ta)
1658{
1659 api_ready (coro_current);
1660 prepare_schedule (aTHX_ ta);
1661}
1662
1663static void
1664prepare_cede_notself (pTHX_ struct transfer_args *ta)
1665{
1666 SV *prev = SvRV (coro_current);
1667
1668 if (coro_nready)
1669 {
1670 prepare_schedule (aTHX_ ta);
1671 api_ready (prev);
1672 }
1673 else
1674 ta->prev = ta->next = SvSTATE (prev);
1675}
1676
1677static void
1678api_schedule (void)
1679{
1680 dTHX;
1681 struct transfer_args ta;
1682
1683 prepare_schedule (aTHX_ &ta);
1684 TRANSFER (ta, 1);
1685}
1686
1687static int
1688api_cede (void)
1689{
1690 dTHX;
1691 struct transfer_args ta;
1692
1693 prepare_cede (aTHX_ &ta);
1694
1695 if (expect_true (ta.prev != ta.next))
1696 {
1697 TRANSFER (ta, 1);
1698 return 1;
1699 }
1700 else
1701 return 0;
1702}
1703
1704static int
1705api_cede_notself (void)
1706{
1707 if (coro_nready)
1708 {
1709 dTHX;
1710 struct transfer_args ta;
1711
1712 prepare_cede_notself (aTHX_ &ta);
1713 TRANSFER (ta, 1);
1714 return 1;
1715 }
1716 else
1717 return 0;
1718}
1719
1720static void
1721api_trace (SV *coro_sv, int flags)
1722{
1723 dTHX;
1724 struct coro *coro = SvSTATE (coro_sv);
1725
1726 if (flags & CC_TRACE)
1727 {
1728 if (!coro->cctx)
1729 coro->cctx = cctx_new_run ();
1730 else if (!(coro->cctx->flags & CC_TRACE))
1731 croak ("cannot enable tracing on coroutine with custom stack");
1732
1733 coro->cctx->flags |= CC_NOREUSE | (flags & (CC_TRACE | CC_TRACE_ALL));
1734 }
1735 else if (coro->cctx && coro->cctx->flags & CC_TRACE)
1736 {
1737 coro->cctx->flags &= ~(CC_TRACE | CC_TRACE_ALL);
1738
1739 if (coro->flags & CF_RUNNING)
1740 PL_runops = RUNOPS_DEFAULT;
1741 else
1742 coro->slot->runops = RUNOPS_DEFAULT;
1743 }
1744}
1745
1746#if 0
1747static int
1748coro_gensub_free (pTHX_ SV *sv, MAGIC *mg)
1749{
1750 AV *padlist;
1751 AV *av = (AV *)mg->mg_obj;
1752
1753 abort ();
1754
1755 return 0;
1756}
1757
1758static MGVTBL coro_gensub_vtbl = {
1759 0, 0, 0, 0,
1760 coro_gensub_free
1761};
1762#endif
1763
1764/*****************************************************************************/
1765/* PerlIO::cede */
1766
1767typedef struct
1768{
1769 PerlIOBuf base;
1770 NV next, every;
1771} PerlIOCede;
1772
1773static IV
1774PerlIOCede_pushed (pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
1775{
1776 PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
1777
1778 self->every = SvCUR (arg) ? SvNV (arg) : 0.01;
1779 self->next = nvtime () + self->every;
1780
1781 return PerlIOBuf_pushed (aTHX_ f, mode, Nullsv, tab);
1782}
1783
1784static SV *
1785PerlIOCede_getarg (pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)
1786{
1787 PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
1788
1789 return newSVnv (self->every);
1790}
1791
1792static IV
1793PerlIOCede_flush (pTHX_ PerlIO *f)
1794{
1795 PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
1796 double now = nvtime ();
1797
1798 if (now >= self->next)
1799 {
1800 api_cede ();
1801 self->next = now + self->every;
1802 }
1803
1804 return PerlIOBuf_flush (aTHX_ f);
1805}
1806
1807static PerlIO_funcs PerlIO_cede =
1808{
1809 sizeof(PerlIO_funcs),
1810 "cede",
1811 sizeof(PerlIOCede),
1812 PERLIO_K_DESTRUCT | PERLIO_K_RAW,
1813 PerlIOCede_pushed,
1814 PerlIOBuf_popped,
1815 PerlIOBuf_open,
1816 PerlIOBase_binmode,
1817 PerlIOCede_getarg,
1818 PerlIOBase_fileno,
1819 PerlIOBuf_dup,
1820 PerlIOBuf_read,
1821 PerlIOBuf_unread,
1822 PerlIOBuf_write,
1823 PerlIOBuf_seek,
1824 PerlIOBuf_tell,
1825 PerlIOBuf_close,
1826 PerlIOCede_flush,
1827 PerlIOBuf_fill,
1828 PerlIOBase_eof,
1829 PerlIOBase_error,
1830 PerlIOBase_clearerr,
1831 PerlIOBase_setlinebuf,
1832 PerlIOBuf_get_base,
1833 PerlIOBuf_bufsiz,
1834 PerlIOBuf_get_ptr,
1835 PerlIOBuf_get_cnt,
1836 PerlIOBuf_set_ptrcnt,
1837};
1838
1839/*****************************************************************************/
1840
1841static const CV *slf_cv; /* for quick consistency check */
1842
1843static UNOP slf_restore; /* restore stack as entersub did, for first-re-run */
1844static SV *slf_arg0;
1845static SV *slf_arg1;
1846
1847/* this restores the stack in the case we patched the entersub, to */
1848/* recreate the stack frame as perl will on following calls */
1849/* since entersub cleared the stack */
1850static OP *
1851pp_restore (pTHX)
1852{
1853 dSP;
1854
1855 PUSHMARK (SP);
1856
1857 EXTEND (SP, 3);
1858 if (slf_arg0) PUSHs (sv_2mortal (slf_arg0));
1859 if (slf_arg1) PUSHs (sv_2mortal (slf_arg1));
1860 PUSHs ((SV *)CvGV (slf_cv));
1861
1862 RETURNOP (slf_restore.op_first);
1863}
1864
1865#define OPpENTERSUB_SLF 15 /* the part of op_private entersub hopefully doesn't use */
1866
1867/* declare prototype */
1868XS(XS_Coro__State__set_stacklevel);
1869
1870/*
1871 * these not obviously related functions are all rolled into one
1872 * function to increase chances that they all will call transfer with the same
1873 * stack offset
1874 * SLF stands for "schedule-like-function".
1875 */
1876static OP *
1877pp_slf (pTHX)
1878{
1879 dSP;
1880 struct transfer_args ta;
1881 SV **arg = PL_stack_base + TOPMARK + 1;
1882 int items = SP - arg; /* args without function object */
1883
1884 /* do a quick consistency check on the "function" object, and if it isn't */
1885 /* for us, divert to the real entersub */
1886 if (SvTYPE (*sp) != SVt_PVGV || CvXSUB (GvCV (*sp)) != XS_Coro__State__set_stacklevel)
1887 return PL_ppaddr[OP_ENTERSUB](aTHX);
1888
1889 /* pop args */
1890 SP = PL_stack_base + POPMARK;
1891
1892 if (!(PL_op->op_flags & OPf_STACKED))
1893 {
1894 /* ampersand-form of call, use @_ instead of stack */
1895 AV *av = GvAV (PL_defgv);
1896 arg = AvARRAY (av);
1897 items = AvFILLp (av) + 1;
1898 }
1899
1900 PUTBACK;
1901 switch (PL_op->op_private & OPpENTERSUB_SLF)
1902 {
1903 case 0:
1904 prepare_set_stacklevel (&ta, (struct coro_cctx *)SvIV (arg [0]));
1905 break;
1906
1907 case 1:
1908 if (items != 2)
1909 croak ("Coro::State::transfer (prev, next) expects two arguments, not %d.", items);
1910
1911 prepare_transfer (aTHX_ &ta, arg [0], arg [1]);
1912 break;
1913
1914 case 2:
1915 prepare_schedule (aTHX_ &ta);
1916 break;
1917
1918 case 3:
1919 prepare_cede (aTHX_ &ta);
1920 break;
1921
1922 case 4:
1923 prepare_cede_notself (aTHX_ &ta);
1924 break;
1925
1926 case 5:
1927 abort ();
1928
1929 default:
1930 abort ();
1931 }
1932
1933 TRANSFER (ta, 0);
1934 SPAGAIN;
1935
1936 PUTBACK;
1937 SLF_TAIL;
1938 SPAGAIN;
1939 RETURN;
1940}
1941
1942static void
1943coro_slf_patch (pTHX_ CV *cv, int ix, SV **args, int items)
1944{
1945 assert (("FATAL: SLF call recursion in Coro module (please report)", PL_op->op_ppaddr != pp_slf));
1946
1947 assert (("FATAL: SLF call with illegal CV value", CvGV (cv)));
1948 slf_cv = cv;
1949
1950 /* we patch the op, and then re-run the whole call */
1951 /* we have to put the same argument on the stack for this to work */
1952 /* and this will be done by pp_restore */
1953 slf_restore.op_next = (OP *)&slf_restore;
1954 slf_restore.op_type = OP_NULL;
1955 slf_restore.op_ppaddr = pp_restore;
1956 slf_restore.op_first = PL_op;
1957
1958 slf_arg0 = items > 0 ? SvREFCNT_inc (args [0]) : 0;
1959 slf_arg1 = items > 1 ? SvREFCNT_inc (args [1]) : 0;
1960
1961 PL_op->op_ppaddr = pp_slf;
1962 PL_op->op_private = PL_op->op_private & ~OPpENTERSUB_SLF | ix; /* we potentially share our private flags with entersub */
1963
1964 PL_op = (OP *)&slf_restore;
1965}
1966
1967MODULE = Coro::State PACKAGE = Coro::State PREFIX = api_
1968
1969PROTOTYPES: DISABLE
1970
1971BOOT:
1972{
1973#ifdef USE_ITHREADS
1974 MUTEX_INIT (&coro_lock);
1975# if CORO_PTHREAD
1976 coro_thx = PERL_GET_CONTEXT;
1977# endif
1978#endif
1979 BOOT_PAGESIZE;
1980
1981 irsgv = gv_fetchpv ("/" , GV_ADD|GV_NOTQUAL, SVt_PV);
1982 stdoutgv = gv_fetchpv ("STDOUT", GV_ADD|GV_NOTQUAL, SVt_PVIO);
1983
1984 orig_sigelem_get = PL_vtbl_sigelem.svt_get; PL_vtbl_sigelem.svt_get = coro_sigelem_get;
1985 orig_sigelem_set = PL_vtbl_sigelem.svt_set; PL_vtbl_sigelem.svt_set = coro_sigelem_set;
1986 orig_sigelem_clr = PL_vtbl_sigelem.svt_clear; PL_vtbl_sigelem.svt_clear = coro_sigelem_clr;
1987
1988 hv_sig = coro_get_hv (aTHX_ "SIG", TRUE);
1989 rv_diehook = newRV_inc ((SV *)gv_fetchpv ("Coro::State::diehook" , 0, SVt_PVCV));
1990 rv_warnhook = newRV_inc ((SV *)gv_fetchpv ("Coro::State::warnhook", 0, SVt_PVCV));
1991
1992 coro_state_stash = gv_stashpv ("Coro::State", TRUE);
1993
1994 newCONSTSUB (coro_state_stash, "CC_TRACE" , newSViv (CC_TRACE));
1995 newCONSTSUB (coro_state_stash, "CC_TRACE_SUB" , newSViv (CC_TRACE_SUB));
1996 newCONSTSUB (coro_state_stash, "CC_TRACE_LINE", newSViv (CC_TRACE_LINE));
1997 newCONSTSUB (coro_state_stash, "CC_TRACE_ALL" , newSViv (CC_TRACE_ALL));
1998
1999 main_mainstack = PL_mainstack;
2000 main_top_env = PL_top_env;
2001
2002 while (main_top_env->je_prev)
2003 main_top_env = main_top_env->je_prev;
2004
2005 coroapi.ver = CORO_API_VERSION;
2006 coroapi.rev = CORO_API_REVISION;
2007 coroapi.transfer = api_transfer;
2008
2009 {
2010 SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
2011
2012 if (!svp) croak ("Time::HiRes is required");
2013 if (!SvIOK (*svp)) croak ("Time::NVtime isn't a function pointer");
2014
2015 nvtime = INT2PTR (double (*)(), SvIV (*svp));
2016 }
2017
2018 assert (("PRIO_NORMAL must be 0", !PRIO_NORMAL));
2019}
2020
2021SV *
2022new (char *klass, ...)
2023 CODE:
2024{
2025 struct coro *coro;
2026 MAGIC *mg;
2027 HV *hv;
2028 int i;
2029
2030 Newz (0, coro, 1, struct coro);
2031 coro->args = newAV ();
2032 coro->flags = CF_NEW;
2033
2034 if (coro_first) coro_first->prev = coro;
2035 coro->next = coro_first;
2036 coro_first = coro;
2037
2038 coro->hv = hv = newHV ();
2039 mg = sv_magicext ((SV *)hv, 0, CORO_MAGIC_type_state, &coro_state_vtbl, (char *)coro, 0);
2040 mg->mg_flags |= MGf_DUP;
2041 RETVAL = sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));
2042
2043 av_extend (coro->args, items - 1);
2044 for (i = 1; i < items; i++)
2045 av_push (coro->args, newSVsv (ST (i)));
2046}
2047 OUTPUT:
2048 RETVAL
2049
2050void
2051_set_stacklevel (...)
2052 ALIAS:
2053 Coro::State::transfer = 1
2054 Coro::schedule = 2
2055 Coro::cede = 3
2056 Coro::cede_notself = 4
2057 CODE:
2058 coro_slf_patch (aTHX_ cv, ix, &ST (0), items);
2059
2060bool
2061_destroy (SV *coro_sv)
2062 CODE:
2063 RETVAL = coro_state_destroy (aTHX_ SvSTATE (coro_sv));
2064 OUTPUT:
2065 RETVAL
2066
2067void
2068_exit (int code)
2069 PROTOTYPE: $
2070 CODE:
2071 _exit (code);
2072
2073int
2074cctx_stacksize (int new_stacksize = 0)
2075 CODE:
2076 RETVAL = cctx_stacksize;
2077 if (new_stacksize)
2078 {
2079 cctx_stacksize = new_stacksize;
2080 ++cctx_gen;
2081 }
2082 OUTPUT:
2083 RETVAL
2084
2085int
2086cctx_max_idle (int max_idle = 0)
2087 CODE:
2088 RETVAL = cctx_max_idle;
2089 if (max_idle > 1)
2090 cctx_max_idle = max_idle;
2091 OUTPUT:
2092 RETVAL
2093
2094int
2095cctx_count ()
2096 CODE:
2097 RETVAL = cctx_count;
2098 OUTPUT:
2099 RETVAL
2100
2101int
2102cctx_idle ()
2103 CODE:
2104 RETVAL = cctx_idle;
2105 OUTPUT:
2106 RETVAL
2107
2108void
2109list ()
2110 PPCODE:
2111{
2112 struct coro *coro;
2113 for (coro = coro_first; coro; coro = coro->next)
2114 if (coro->hv)
2115 XPUSHs (sv_2mortal (newRV_inc ((SV *)coro->hv)));
2116}
2117
2118void
2119call (Coro::State coro, SV *coderef)
2120 ALIAS:
2121 eval = 1
2122 CODE:
2123{
2124 if (coro->mainstack && ((coro->flags & CF_RUNNING) || coro->slot))
2125 {
2126 struct coro temp;
2127
2128 if (!(coro->flags & CF_RUNNING))
215 { 2129 {
216 /* I never used formats, so how should I know how these are implemented? */ 2130 PUTBACK;
217 /* my bold guess is as a simple, plain sub... */ 2131 save_perl (aTHX_ &temp);
218 croak ("CXt_FORMAT not yet handled. Don't switch coroutines from within formats"); 2132 load_perl (aTHX_ coro);
2133 }
2134
2135 {
2136 dSP;
2137 ENTER;
2138 SAVETMPS;
2139 PUTBACK;
2140 PUSHSTACK;
2141 PUSHMARK (SP);
2142
2143 if (ix)
2144 eval_sv (coderef, 0);
2145 else
2146 call_sv (coderef, G_KEEPERR | G_EVAL | G_VOID | G_DISCARD);
2147
2148 POPSTACK;
2149 SPAGAIN;
2150 FREETMPS;
2151 LEAVE;
2152 PUTBACK;
2153 }
2154
2155 if (!(coro->flags & CF_RUNNING))
2156 {
2157 save_perl (aTHX_ coro);
2158 load_perl (aTHX_ &temp);
2159 SPAGAIN;
219 } 2160 }
220 } 2161 }
221
222 if (top_si->si_type == PERLSI_MAIN)
223 break;
224
225 top_si = top_si->si_prev;
226 ccstk = top_si->si_cxstack;
227 cxix = top_si->si_cxix;
228 }
229
230 PUTBACK;
231 }
232
233 c->dowarn = PL_dowarn;
234 c->defav = GvAV (PL_defgv);
235 c->curstackinfo = PL_curstackinfo;
236 c->curstack = PL_curstack;
237 c->mainstack = PL_mainstack;
238 c->stack_sp = PL_stack_sp;
239 c->op = PL_op;
240 c->curpad = PL_curpad;
241 c->stack_base = PL_stack_base;
242 c->stack_max = PL_stack_max;
243 c->tmps_stack = PL_tmps_stack;
244 c->tmps_floor = PL_tmps_floor;
245 c->tmps_ix = PL_tmps_ix;
246 c->tmps_max = PL_tmps_max;
247 c->markstack = PL_markstack;
248 c->markstack_ptr = PL_markstack_ptr;
249 c->markstack_max = PL_markstack_max;
250 c->scopestack = PL_scopestack;
251 c->scopestack_ix = PL_scopestack_ix;
252 c->scopestack_max = PL_scopestack_max;
253 c->savestack = PL_savestack;
254 c->savestack_ix = PL_savestack_ix;
255 c->savestack_max = PL_savestack_max;
256 c->retstack = PL_retstack;
257 c->retstack_ix = PL_retstack_ix;
258 c->retstack_max = PL_retstack_max;
259 c->curcop = PL_curcop;
260} 2162}
261 2163
262static void 2164SV *
263LOAD(pTHX_ Coro__State c) 2165is_ready (Coro::State coro)
264{ 2166 PROTOTYPE: $
265 PL_dowarn = c->dowarn; 2167 ALIAS:
266 GvAV (PL_defgv) = c->defav; 2168 is_ready = CF_READY
267 PL_curstackinfo = c->curstackinfo; 2169 is_running = CF_RUNNING
268 PL_curstack = c->curstack; 2170 is_new = CF_NEW
269 PL_mainstack = c->mainstack; 2171 is_destroyed = CF_DESTROYED
270 PL_stack_sp = c->stack_sp; 2172 CODE:
271 PL_op = c->op; 2173 RETVAL = boolSV (coro->flags & ix);
272 PL_curpad = c->curpad; 2174 OUTPUT:
273 PL_stack_base = c->stack_base; 2175 RETVAL
274 PL_stack_max = c->stack_max;
275 PL_tmps_stack = c->tmps_stack;
276 PL_tmps_floor = c->tmps_floor;
277 PL_tmps_ix = c->tmps_ix;
278 PL_tmps_max = c->tmps_max;
279 PL_markstack = c->markstack;
280 PL_markstack_ptr = c->markstack_ptr;
281 PL_markstack_max = c->markstack_max;
282 PL_scopestack = c->scopestack;
283 PL_scopestack_ix = c->scopestack_ix;
284 PL_scopestack_max = c->scopestack_max;
285 PL_savestack = c->savestack;
286 PL_savestack_ix = c->savestack_ix;
287 PL_savestack_max = c->savestack_max;
288 PL_retstack = c->retstack;
289 PL_retstack_ix = c->retstack_ix;
290 PL_retstack_max = c->retstack_max;
291 PL_curcop = c->curcop;
292 2176
2177void
2178throw (Coro::State self, SV *throw = &PL_sv_undef)
2179 PROTOTYPE: $;$
2180 CODE:
2181 SvREFCNT_dec (self->throw);
2182 self->throw = SvOK (throw) ? newSVsv (throw) : 0;
2183
2184void
2185api_trace (SV *coro, int flags = CC_TRACE | CC_TRACE_SUB)
2186
2187SV *
2188has_cctx (Coro::State coro)
2189 PROTOTYPE: $
2190 CODE:
2191 RETVAL = boolSV (!!coro->cctx);
2192 OUTPUT:
2193 RETVAL
2194
2195int
2196is_traced (Coro::State coro)
2197 PROTOTYPE: $
2198 CODE:
2199 RETVAL = (coro->cctx ? coro->cctx->flags : 0) & CC_TRACE_ALL;
2200 OUTPUT:
2201 RETVAL
2202
2203UV
2204rss (Coro::State coro)
2205 PROTOTYPE: $
2206 ALIAS:
2207 usecount = 1
2208 CODE:
2209 switch (ix)
293 { 2210 {
294 dSP; 2211 case 0: RETVAL = coro_rss (aTHX_ coro); break;
295 CV *cv; 2212 case 1: RETVAL = coro->usecount; break;
296
297 /* now do the ugly restore mess */
298 while ((cv = (CV *)POPs))
299 {
300 AV *padlist = (AV *)POPs;
301
302 unuse_padlist (CvPADLIST(cv));
303 CvPADLIST(cv) = padlist;
304 CvDEPTH(cv) = (I32)POPs;
305
306#ifdef USE_THREADS
307 CvOWNER(cv) = (struct perl_thread *)POPs;
308 error does not work either
309#endif
310 } 2213 }
2214 OUTPUT:
2215 RETVAL
311 2216
312 PUTBACK; 2217void
313 } 2218force_cctx ()
314} 2219 CODE:
2220 struct coro *coro = SvSTATE (coro_current);
2221 coro->cctx->idle_sp = 0;
315 2222
316/* this is an EXACT copy of S_nuke_stacks in perl.c, which is unfortunately static */ 2223void
317STATIC void 2224swap_defsv (Coro::State self)
318S_nuke_stacks(pTHX) 2225 PROTOTYPE: $
319{ 2226 ALIAS:
320 while (PL_curstackinfo->si_next) 2227 swap_defav = 1
321 PL_curstackinfo = PL_curstackinfo->si_next; 2228 CODE:
322 while (PL_curstackinfo) { 2229 if (!self->slot)
323 PERL_SI *p = PL_curstackinfo->si_prev; 2230 croak ("cannot swap state with coroutine that has no saved state");
324 /* curstackinfo->si_stack got nuked by sv_free_arenas() */ 2231 else
325 Safefree(PL_curstackinfo->si_cxstack); 2232 {
326 Safefree(PL_curstackinfo); 2233 SV **src = ix ? (SV **)&GvAV (PL_defgv) : &GvSV (PL_defgv);
327 PL_curstackinfo = p; 2234 SV **dst = ix ? (SV **)&self->slot->defav : (SV **)&self->slot->defsv;
328 }
329 Safefree(PL_tmps_stack);
330 Safefree(PL_markstack);
331 Safefree(PL_scopestack);
332 Safefree(PL_savestack);
333 Safefree(PL_retstack);
334}
335 2235
336#define SUB_INIT "Coro::State::_newcoro" 2236 SV *tmp = *src; *src = *dst; *dst = tmp;
2237 }
337 2238
338MODULE = Coro::State PACKAGE = Coro::State 2239MODULE = Coro::State PACKAGE = Coro
339
340PROTOTYPES: ENABLE
341 2240
342BOOT: 2241BOOT:
343 if (!padlist_cache) 2242{
344 padlist_cache = newHV (); 2243 int i;
345 2244
346Coro::State 2245 av_async_pool = coro_get_av (aTHX_ "Coro::async_pool", TRUE);
347_newprocess(args) 2246 sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE);
348 SV * args 2247 sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE);
2248
2249 coro_current = coro_get_sv (aTHX_ "Coro::current", FALSE);
2250 SvREADONLY_on (coro_current);
2251
2252 coro_stash = gv_stashpv ("Coro", TRUE);
2253
2254 newCONSTSUB (coro_stash, "PRIO_MAX", newSViv (PRIO_MAX));
2255 newCONSTSUB (coro_stash, "PRIO_HIGH", newSViv (PRIO_HIGH));
2256 newCONSTSUB (coro_stash, "PRIO_NORMAL", newSViv (PRIO_NORMAL));
2257 newCONSTSUB (coro_stash, "PRIO_LOW", newSViv (PRIO_LOW));
2258 newCONSTSUB (coro_stash, "PRIO_IDLE", newSViv (PRIO_IDLE));
2259 newCONSTSUB (coro_stash, "PRIO_MIN", newSViv (PRIO_MIN));
2260
2261 for (i = PRIO_MAX - PRIO_MIN + 1; i--; )
2262 coro_ready[i] = newAV ();
2263
2264 {
2265 SV *sv = coro_get_sv (aTHX_ "Coro::API", TRUE);
2266
2267 coroapi.schedule = api_schedule;
2268 coroapi.cede = api_cede;
2269 coroapi.cede_notself = api_cede_notself;
2270 coroapi.ready = api_ready;
2271 coroapi.is_ready = api_is_ready;
2272 coroapi.nready = &coro_nready;
2273 coroapi.current = coro_current;
2274
2275 GCoroAPI = &coroapi;
2276 sv_setiv (sv, (IV)&coroapi);
2277 SvREADONLY_on (sv);
2278 }
2279}
2280
2281void
2282_set_current (SV *current)
349 PROTOTYPE: $ 2283 PROTOTYPE: $
2284 CODE:
2285 SvREFCNT_dec (SvRV (coro_current));
2286 SvRV_set (coro_current, SvREFCNT_inc_NN (SvRV (current)));
2287
2288void
2289_set_readyhook (SV *hook)
2290 PROTOTYPE: $
350 CODE: 2291 CODE:
351 Coro__State coro;
352
353 if (!SvROK (args) || SvTYPE (SvRV (args)) != SVt_PVAV)
354 croak ("Coro::State::newprocess expects an arrayref");
355 2292 LOCK;
356 New (0, coro, 1, struct coro); 2293 SvREFCNT_dec (coro_readyhook);
2294 coro_readyhook = SvOK (hook) ? newSVsv (hook) : 0;
2295 UNLOCK;
357 2296
358 coro->mainstack = 0; /* actual work is done inside transfer */ 2297int
359 coro->args = (AV *)SvREFCNT_inc (SvRV (args)); 2298prio (Coro::State coro, int newprio = 0)
360 2299 ALIAS:
2300 nice = 1
2301 CODE:
2302{
361 RETVAL = coro; 2303 RETVAL = coro->prio;
362 OUTPUT: 2304
2305 if (items > 1)
2306 {
2307 if (ix)
2308 newprio = coro->prio - newprio;
2309
2310 if (newprio < PRIO_MIN) newprio = PRIO_MIN;
2311 if (newprio > PRIO_MAX) newprio = PRIO_MAX;
2312
2313 coro->prio = newprio;
2314 }
2315}
2316 OUTPUT:
363 RETVAL 2317 RETVAL
364 2318
2319SV *
2320ready (SV *self)
2321 PROTOTYPE: $
2322 CODE:
2323 RETVAL = boolSV (api_ready (self));
2324 OUTPUT:
2325 RETVAL
2326
2327int
2328nready (...)
2329 PROTOTYPE:
2330 CODE:
2331 RETVAL = coro_nready;
2332 OUTPUT:
2333 RETVAL
2334
2335# for async_pool speedup
365void 2336void
366transfer(prev,next) 2337_pool_1 (SV *cb)
367 Coro::State_or_hashref prev 2338 CODE:
368 Coro::State_or_hashref next 2339{
2340 struct coro *coro = SvSTATE (coro_current);
2341 HV *hv = (HV *)SvRV (coro_current);
2342 AV *defav = GvAV (PL_defgv);
2343 SV *invoke = hv_delete (hv, "_invoke", sizeof ("_invoke") - 1, 0);
2344 AV *invoke_av;
2345 int i, len;
2346
2347 if (!invoke)
2348 {
2349 SV *old = PL_diehook;
2350 PL_diehook = 0;
2351 SvREFCNT_dec (old);
2352 croak ("\3async_pool terminate\2\n");
2353 }
2354
2355 SvREFCNT_dec (coro->saved_deffh);
2356 coro->saved_deffh = SvREFCNT_inc_NN ((SV *)PL_defoutgv);
2357
2358 hv_store (hv, "desc", sizeof ("desc") - 1,
2359 newSVpvn ("[async_pool]", sizeof ("[async_pool]") - 1), 0);
2360
2361 invoke_av = (AV *)SvRV (invoke);
2362 len = av_len (invoke_av);
2363
2364 sv_setsv (cb, AvARRAY (invoke_av)[0]);
2365
2366 if (len > 0)
2367 {
2368 av_fill (defav, len - 1);
2369 for (i = 0; i < len; ++i)
2370 av_store (defav, i, SvREFCNT_inc_NN (AvARRAY (invoke_av)[i + 1]));
2371 }
2372
2373 SvREFCNT_dec (invoke);
2374}
2375
2376void
2377_pool_2 (SV *cb)
2378 CODE:
2379{
2380 struct coro *coro = SvSTATE (coro_current);
2381
2382 sv_setsv (cb, &PL_sv_undef);
2383
2384 SvREFCNT_dec ((SV *)PL_defoutgv); PL_defoutgv = (GV *)coro->saved_deffh;
2385 coro->saved_deffh = 0;
2386
2387 if (coro_rss (aTHX_ coro) > SvUV (sv_pool_rss)
2388 || av_len (av_async_pool) + 1 >= SvIV (sv_pool_size))
2389 {
2390 SV *old = PL_diehook;
2391 PL_diehook = 0;
2392 SvREFCNT_dec (old);
2393 croak ("\3async_pool terminate\2\n");
2394 }
2395
2396 av_clear (GvAV (PL_defgv));
2397 hv_store ((HV *)SvRV (coro_current), "desc", sizeof ("desc") - 1,
2398 newSVpvn ("[async_pool idle]", sizeof ("[async_pool idle]") - 1), 0);
2399
2400 coro->prio = 0;
2401
2402 if (coro->cctx && (coro->cctx->flags & CC_TRACE))
2403 api_trace (coro_current, 0);
2404
2405 av_push (av_async_pool, newSVsv (coro_current));
2406}
2407
2408#if 0
2409
2410void
2411_generator_call (...)
2412 PROTOTYPE: @
2413 PPCODE:
2414 fprintf (stderr, "call %p\n", CvXSUBANY(cv).any_ptr);
2415 xxxx
2416 abort ();
2417
2418SV *
2419gensub (SV *sub, ...)
2420 PROTOTYPE: &;@
369 CODE: 2421 CODE:
2422{
2423 struct coro *coro;
2424 MAGIC *mg;
2425 CV *xcv;
2426 CV *ncv = (CV *)newSV_type (SVt_PVCV);
2427 int i;
370 2428
371 if (prev != next) 2429 CvGV (ncv) = CvGV (cv);
2430 CvFILE (ncv) = CvFILE (cv);
2431
2432 Newz (0, coro, 1, struct coro);
2433 coro->args = newAV ();
2434 coro->flags = CF_NEW;
2435
2436 av_extend (coro->args, items - 1);
2437 for (i = 1; i < items; i++)
2438 av_push (coro->args, newSVsv (ST (i)));
2439
2440 CvISXSUB_on (ncv);
2441 CvXSUBANY (ncv).any_ptr = (void *)coro;
2442
2443 xcv = GvCV (gv_fetchpv ("Coro::_generator_call", 0, SVt_PVCV));
2444
2445 CvXSUB (ncv) = CvXSUB (xcv);
2446 CvANON_on (ncv);
2447
2448 mg = sv_magicext ((SV *)ncv, 0, CORO_MAGIC_type_state, &coro_gensub_vtbl, (char *)coro, 0);
2449 RETVAL = newRV_noinc ((SV *)ncv);
2450}
2451 OUTPUT:
2452 RETVAL
2453
2454#endif
2455
2456
2457MODULE = Coro::State PACKAGE = Coro::AIO
2458
2459void
2460_get_state (SV *self)
2461 PPCODE:
2462{
2463 AV *defav = GvAV (PL_defgv);
2464 AV *av = newAV ();
2465 int i;
2466 SV *data_sv = newSV (sizeof (struct io_state));
2467 struct io_state *data = (struct io_state *)SvPVX (data_sv);
2468 SvCUR_set (data_sv, sizeof (struct io_state));
2469 SvPOK_only (data_sv);
2470
2471 data->errorno = errno;
2472 data->laststype = PL_laststype;
2473 data->laststatval = PL_laststatval;
2474 data->statcache = PL_statcache;
2475
2476 av_extend (av, AvFILLp (defav) + 1 + 1);
2477
2478 for (i = 0; i <= AvFILLp (defav); ++i)
2479 av_push (av, SvREFCNT_inc_NN (AvARRAY (defav)[i]));
2480
2481 av_push (av, data_sv);
2482
2483 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
2484
2485 api_ready (self);
2486}
2487
2488void
2489_set_state (SV *state)
2490 PROTOTYPE: $
2491 PPCODE:
2492{
2493 AV *av = (AV *)SvRV (state);
2494 struct io_state *data = (struct io_state *)SvPVX (AvARRAY (av)[AvFILLp (av)]);
2495 int i;
2496
2497 errno = data->errorno;
2498 PL_laststype = data->laststype;
2499 PL_laststatval = data->laststatval;
2500 PL_statcache = data->statcache;
2501
2502 EXTEND (SP, AvFILLp (av));
2503 for (i = 0; i < AvFILLp (av); ++i)
2504 PUSHs (sv_2mortal (SvREFCNT_inc_NN (AvARRAY (av)[i])));
2505}
2506
2507
2508MODULE = Coro::State PACKAGE = Coro::AnyEvent
2509
2510BOOT:
2511 sv_activity = coro_get_sv (aTHX_ "Coro::AnyEvent::ACTIVITY", TRUE);
2512
2513SV *
2514_schedule (...)
2515 PROTOTYPE: @
2516 CODE:
2517{
2518 static int incede;
2519
2520 api_cede_notself ();
2521
2522 ++incede;
2523 while (coro_nready >= incede && api_cede ())
2524 ;
2525
2526 sv_setsv (sv_activity, &PL_sv_undef);
2527 if (coro_nready >= incede)
372 { 2528 {
2529 PUSHMARK (SP);
373 PUTBACK; 2530 PUTBACK;
374 SAVE (aTHX_ prev); 2531 call_pv ("Coro::AnyEvent::_activity", G_DISCARD | G_EVAL);
375
376 /*
377 * this could be done in newprocess which would lead to
378 * extremely elegant and fast (just PUTBACK/SAVE/LOAD/SPAGAIN)
379 * code here, but lazy allocation of stacks has also
380 * some virtues and the overhead of the if() is nil.
381 */
382 if (next->mainstack)
383 {
384 LOAD (aTHX_ next);
385 next->mainstack = 0; /* unnecessary but much cleaner */
386 SPAGAIN;
387 }
388 else
389 {
390 /*
391 * emulate part of the perl startup here.
392 */
393 UNOP myop;
394
395 init_stacks ();
396 PL_op = (OP *)&myop;
397 /*PL_curcop = 0;*/
398 GvAV (PL_defgv) = (SV *)SvREFCNT_inc (next->args);
399
400 SPAGAIN;
401 Zero(&myop, 1, UNOP);
402 myop.op_next = Nullop;
403 myop.op_flags = OPf_WANT_VOID;
404
405 PUSHMARK(SP);
406 XPUSHs ((SV*)get_cv(SUB_INIT, TRUE));
407 PUTBACK;
408 /*
409 * the next line is slightly wrong, as PL_op->op_next
410 * is actually being executed so we skip the first op.
411 * that doesn't matter, though, since it is only
412 * pp_nextstate and we never return...
413 */
414 PL_op = Perl_pp_entersub(aTHX);
415 SPAGAIN;
416
417 ENTER;
418 }
419 }
420
421void
422DESTROY(coro)
423 Coro::State coro
424 CODE:
425
426 if (coro->mainstack)
427 {
428 struct coro temp;
429
430 PUTBACK;
431 SAVE(aTHX_ (&temp));
432 LOAD(aTHX_ coro);
433
434 S_nuke_stacks ();
435 SvREFCNT_dec ((SV *)GvAV (PL_defgv));
436
437 LOAD((&temp));
438 SPAGAIN; 2532 SPAGAIN;
439 } 2533 }
440 2534
441 SvREFCNT_dec (coro->args); 2535 --incede;
442 Safefree (coro); 2536}
443 2537
444 2538
2539MODULE = Coro::State PACKAGE = PerlIO::cede
2540
2541BOOT:
2542 PerlIO_define_layer (aTHX_ &PerlIO_cede);
2543

Diff Legend

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