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.4 by root, Tue Jul 17 02:21:56 2001 UTC vs.
Revision 1.272 by root, Fri Nov 14 20:35:49 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
188static GV *irsgv; /* $/ */
189static GV *stdoutgv; /* *STDOUT */
190static SV *rv_diehook;
191static SV *rv_warnhook;
192static HV *hv_sig; /* %SIG */
193
194/* async_pool helper stuff */
195static SV *sv_pool_rss;
196static SV *sv_pool_size;
197static AV *av_async_pool;
198
199/* Coro::AnyEvent */
200static SV *sv_activity;
201
202static struct coro_cctx *cctx_first;
203static int cctx_count, cctx_idle;
204
205enum {
206 CC_MAPPED = 0x01,
207 CC_NOREUSE = 0x02, /* throw this away after tracing */
208 CC_TRACE = 0x04,
209 CC_TRACE_SUB = 0x08, /* trace sub calls */
210 CC_TRACE_LINE = 0x10, /* trace each statement */
211 CC_TRACE_ALL = CC_TRACE_SUB | CC_TRACE_LINE,
212};
213
214/* this is a structure representing a c-level coroutine */
215typedef struct coro_cctx
216{
217 struct coro_cctx *next;
218
219 /* the stack */
220 void *sptr;
221 size_t ssize;
222
223 /* cpu state */
224 void *idle_sp; /* sp of top-level transfer/schedule/cede call */
225 JMPENV *idle_te; /* same as idle_sp, but for top_env, TODO: remove once stable */
226 JMPENV *top_env;
227 coro_context cctx;
228
229 U32 gen;
230#if CORO_USE_VALGRIND
231 int valgrind_id;
232#endif
233 unsigned char flags;
234} coro_cctx;
235
236enum {
237 CF_RUNNING = 0x0001, /* coroutine is running */
238 CF_READY = 0x0002, /* coroutine is ready */
239 CF_NEW = 0x0004, /* has never been switched to */
240 CF_DESTROYED = 0x0008, /* coroutine data has been freed */
241};
242
243/* the structure where most of the perl state is stored, overlaid on the cxstack */
244typedef struct
245{
246 SV *defsv;
247 AV *defav;
248 SV *errsv;
249 SV *irsgv;
250#define VAR(name,type) type name;
251# include "state.h"
252#undef VAR
253} perl_slots;
254
255#define SLOT_COUNT ((sizeof (perl_slots) + sizeof (PERL_CONTEXT) - 1) / sizeof (PERL_CONTEXT))
256
257/* this is the per-perl-coro slf frame info */
258/* it is treated like other "global" interpreter data */
259/* and unfortunately is copied around, so kepe it small */
260struct slf_frame
261{
262 void (*prepare) (struct coro_transfer_args *ta); /* 0 means not yet initialised */
263 int (*check) (pTHX);
264};
265
266/* this is a structure representing a perl-level coroutine */
11struct coro { 267struct coro {
12 U8 dowarn; 268 /* the C coroutine allocated to this perl coroutine, if any */
13 AV *defav; 269 coro_cctx *cctx;
14 270
15 PERL_SI *curstackinfo; 271 /* process data */
16 AV *curstack; 272 struct slf_frame slf_frame; /* saved slf frame */
273 void *slf_data;
17 AV *mainstack; 274 AV *mainstack;
18 SV **stack_sp; 275 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 276
41 AV *args; 277 AV *args; /* data associated with this coroutine (initial args) */
278 int refcnt; /* coroutines are refcounted, yes */
279 int flags; /* CF_ flags */
280 HV *hv; /* the perl hash associated with this coro, if any */
281
282 /* statistics */
283 int usecount; /* number of transfers to this coro */
284
285 /* coro process data */
286 int prio;
287 SV *throw; /* exception to be thrown */
288
289 /* async_pool */
290 SV *saved_deffh;
291
292 /* linked list */
293 struct coro *next, *prev;
42}; 294};
43 295
44typedef struct coro *Coro__State; 296typedef struct coro *Coro__State;
45typedef struct coro *Coro__State_or_hashref; 297typedef struct coro *Coro__State_or_hashref;
46 298
47static HV *padlist_cache; 299static struct slf_frame slf_frame; /* the current slf frame */
48 300
49/* mostly copied from op.c:cv_clone2 */ 301/** Coro ********************************************************************/
50STATIC AV * 302
51clone_padlist (AV *protopadlist) 303#define PRIO_MAX 3
304#define PRIO_HIGH 1
305#define PRIO_NORMAL 0
306#define PRIO_LOW -1
307#define PRIO_IDLE -3
308#define PRIO_MIN -4
309
310/* for Coro.pm */
311static SV *coro_current;
312static SV *coro_readyhook;
313static AV *coro_ready [PRIO_MAX - PRIO_MIN + 1];
314static struct coro *coro_first;
315#define coro_nready coroapi.nready
316
317/** lowlevel stuff **********************************************************/
318
319static SV *
320coro_get_sv (pTHX_ const char *name, int create)
52{ 321{
53 AV *av; 322#if PERL_VERSION_ATLEAST (5,10,0)
54 I32 ix; 323 /* silence stupid and wrong 5.10 warning that I am unable to switch off */
55 AV *protopad_name = (AV *) * av_fetch (protopadlist, 0, FALSE); 324 get_sv (name, create);
56 AV *protopad = (AV *) * av_fetch (protopadlist, 1, FALSE); 325#endif
57 SV **pname = AvARRAY (protopad_name); 326 return get_sv (name, create);
58 SV **ppad = AvARRAY (protopad); 327}
59 I32 fname = AvFILLp (protopad_name); 328
60 I32 fpad = AvFILLp (protopad); 329static AV *
330coro_get_av (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_av (name, create);
335#endif
336 return get_av (name, create);
337}
338
339static HV *
340coro_get_hv (pTHX_ const char *name, int create)
341{
342#if PERL_VERSION_ATLEAST (5,10,0)
343 /* silence stupid and wrong 5.10 warning that I am unable to switch off */
344 get_hv (name, create);
345#endif
346 return get_hv (name, create);
347}
348
349static AV *
350coro_clone_padlist (pTHX_ CV *cv)
351{
352 AV *padlist = CvPADLIST (cv);
61 AV *newpadlist, *newpad_name, *newpad; 353 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 354
72 newpadlist = newAV (); 355 newpadlist = newAV ();
73 AvREAL_off (newpadlist); 356 AvREAL_off (newpadlist);
74 av_store (newpadlist, 0, (SV *) newpad_name); 357#if PERL_VERSION_ATLEAST (5,10,0)
358 Perl_pad_push (aTHX_ padlist, AvFILLp (padlist) + 1);
359#else
360 Perl_pad_push (aTHX_ padlist, AvFILLp (padlist) + 1, 1);
361#endif
362 newpad = (AV *)AvARRAY (padlist)[AvFILLp (padlist)];
363 --AvFILLp (padlist);
364
365 av_store (newpadlist, 0, SvREFCNT_inc_NN (*av_fetch (padlist, 0, FALSE)));
75 av_store (newpadlist, 1, (SV *) newpad); 366 av_store (newpadlist, 1, (SV *)newpad);
76 367
77 av = newAV (); /* will be @_ */ 368 return newpadlist;
78 av_extend (av, 0); 369}
79 av_store (newpad, 0, (SV *) av);
80 AvFLAGS (av) = AVf_REIFY;
81 370
82 for (ix = fpad; ix > 0; ix--) 371static void
372free_padlist (pTHX_ AV *padlist)
373{
374 /* may be during global destruction */
375 if (SvREFCNT (padlist))
83 { 376 {
84 SV *namesv = (ix <= fname) ? pname[ix] : Nullsv; 377 I32 i = AvFILLp (padlist);
85 if (namesv && namesv != &PL_sv_undef) 378 while (i >= 0)
86 { 379 {
87 char *name = SvPVX (namesv); /* XXX */ 380 SV **svp = av_fetch (padlist, i--, FALSE);
88 if (SvFLAGS (namesv) & SVf_FAKE || *name == '&') 381 if (svp)
89 { /* lexical from outside? */
90 npad[ix] = SvREFCNT_inc (ppad[ix]);
91 } 382 {
92 else
93 { /* our own lexical */
94 SV *sv; 383 SV *sv;
95 if (*name == '&') 384 while (&PL_sv_undef != (sv = av_pop ((AV *)*svp)))
96 sv = SvREFCNT_inc (ppad[ix]); 385 SvREFCNT_dec (sv);
97 else if (*name == '@') 386
98 sv = (SV *) newAV (); 387 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 } 388 }
107 } 389 }
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 390
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); 391 SvREFCNT_dec ((SV*)padlist);
392 }
393}
394
395static int
396coro_cv_free (pTHX_ SV *sv, MAGIC *mg)
397{
398 AV *padlist;
399 AV *av = (AV *)mg->mg_obj;
400
401 /* casting is fun. */
402 while (&PL_sv_undef != (SV *)(padlist = (AV *)av_pop (av)))
403 free_padlist (aTHX_ padlist);
404
405 SvREFCNT_dec (av); /* sv_magicext increased the refcount */
406
407 return 0;
408}
409
410#define CORO_MAGIC_type_cv PERL_MAGIC_ext
411#define CORO_MAGIC_type_state PERL_MAGIC_ext
412
413static MGVTBL coro_cv_vtbl = {
414 0, 0, 0, 0,
415 coro_cv_free
416};
417
418#define CORO_MAGIC(sv, type) \
419 SvMAGIC (sv) \
420 ? SvMAGIC (sv)->mg_type == type \
421 ? SvMAGIC (sv) \
422 : mg_find (sv, type) \
423 : 0
424
425#define CORO_MAGIC_cv(cv) CORO_MAGIC (((SV *)(cv)), CORO_MAGIC_type_cv)
426#define CORO_MAGIC_state(sv) CORO_MAGIC (((SV *)(sv)), CORO_MAGIC_type_state)
427
428INLINE struct coro *
429SvSTATE_ (pTHX_ SV *coro)
430{
431 HV *stash;
432 MAGIC *mg;
433
434 if (SvROK (coro))
435 coro = SvRV (coro);
436
437 if (expect_false (SvTYPE (coro) != SVt_PVHV))
438 croak ("Coro::State object required");
439
440 stash = SvSTASH (coro);
441 if (expect_false (stash != coro_stash && stash != coro_state_stash))
442 {
443 /* very slow, but rare, check */
444 if (!sv_derived_from (sv_2mortal (newRV_inc (coro)), "Coro::State"))
445 croak ("Coro::State object required");
446 }
447
448 mg = CORO_MAGIC_state (coro);
449 return (struct coro *)mg->mg_ptr;
450}
451
452#define SvSTATE(sv) SvSTATE_ (aTHX_ (sv))
453
454/* the next two functions merely cache the padlists */
455static void
456get_padlist (pTHX_ CV *cv)
457{
458 MAGIC *mg = CORO_MAGIC_cv (cv);
459 AV *av;
460
461 if (expect_true (mg && AvFILLp ((av = (AV *)mg->mg_obj)) >= 0))
462 CvPADLIST (cv) = (AV *)AvARRAY (av)[AvFILLp (av)--];
463 else
464 {
465#if CORO_PREFER_PERL_FUNCTIONS
466 /* this is probably cleaner? but also slower! */
467 /* in practise, it seems to be less stable */
468 CV *cp = Perl_cv_clone (cv);
469 CvPADLIST (cv) = CvPADLIST (cp);
470 CvPADLIST (cp) = 0;
471 SvREFCNT_dec (cp);
472#else
473 CvPADLIST (cv) = coro_clone_padlist (aTHX_ cv);
474#endif
475 }
476}
477
478static void
479put_padlist (pTHX_ CV *cv)
480{
481 MAGIC *mg = CORO_MAGIC_cv (cv);
482 AV *av;
483
484 if (expect_false (!mg))
485 mg = sv_magicext ((SV *)cv, (SV *)newAV (), CORO_MAGIC_type_cv, &coro_cv_vtbl, 0, 0);
486
487 av = (AV *)mg->mg_obj;
488
489 if (expect_false (AvFILLp (av) >= AvMAX (av)))
490 av_extend (av, AvMAX (av) + 1);
491
492 AvARRAY (av)[++AvFILLp (av)] = (SV *)CvPADLIST (cv);
493}
494
495/** load & save, init *******************************************************/
496
497static void
498load_perl (pTHX_ Coro__State c)
499{
500 perl_slots *slot = c->slot;
501 c->slot = 0;
502
503 PL_mainstack = c->mainstack;
504
505 GvSV (PL_defgv) = slot->defsv;
506 GvAV (PL_defgv) = slot->defav;
507 GvSV (PL_errgv) = slot->errsv;
508 GvSV (irsgv) = slot->irsgv;
509
510 #define VAR(name,type) PL_ ## name = slot->name;
511 # include "state.h"
512 #undef VAR
513
514 {
515 dSP;
516
517 CV *cv;
518
519 /* now do the ugly restore mess */
520 while (expect_true (cv = (CV *)POPs))
521 {
522 put_padlist (aTHX_ cv); /* mark this padlist as available */
523 CvDEPTH (cv) = PTR2IV (POPs);
524 CvPADLIST (cv) = (AV *)POPs;
525 }
526
527 PUTBACK;
159 } 528 }
160}
161 529
162/* the next tow functions merely cache the padlists */ 530 slf_frame = c->slf_frame;
163STATIC void 531 coroapi.slf_data = c->slf_data;
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}
173
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} 532}
187 533
188static void 534static void
189SAVE(pTHX_ Coro__State c) 535save_perl (pTHX_ Coro__State c)
190{ 536{
537 c->slf_data = coroapi.slf_data;
538 c->slf_frame = slf_frame;
539
191 { 540 {
192 dSP; 541 dSP;
193 I32 cxix = cxstack_ix; 542 I32 cxix = cxstack_ix;
543 PERL_CONTEXT *ccstk = cxstack;
194 PERL_SI *top_si = PL_curstackinfo; 544 PERL_SI *top_si = PL_curstackinfo;
195 PERL_CONTEXT *ccstk = cxstack;
196 545
197 /* 546 /*
198 * the worst thing you can imagine happens first - we have to save 547 * the worst thing you can imagine happens first - we have to save
199 * (and reinitialize) all cv's in the whole callchain :( 548 * (and reinitialize) all cv's in the whole callchain :(
200 */ 549 */
201 550
202 PUSHs (Nullsv); 551 XPUSHs (Nullsv);
203 /* this loop was inspired by pp_caller */ 552 /* this loop was inspired by pp_caller */
204 for (;;) 553 for (;;)
205 { 554 {
206 while (cxix >= 0) 555 while (expect_true (cxix >= 0))
207 { 556 {
208 PERL_CONTEXT *cx = &ccstk[cxix--]; 557 PERL_CONTEXT *cx = &ccstk[cxix--];
209 558
210 if (CxTYPE(cx) == CXt_SUB) 559 if (expect_true (CxTYPE (cx) == CXt_SUB || CxTYPE (cx) == CXt_FORMAT))
211 { 560 {
212 CV *cv = cx->blk_sub.cv; 561 CV *cv = cx->blk_sub.cv;
562
213 if (CvDEPTH(cv)) 563 if (expect_true (CvDEPTH (cv)))
214 { 564 {
215#ifdef USE_THREADS
216 XPUSHs ((SV *)CvOWNER(cv));
217#endif
218 EXTEND (SP, 3); 565 EXTEND (SP, 3);
219 PUSHs ((SV *)CvDEPTH(cv));
220 PUSHs ((SV *)CvPADLIST(cv)); 566 PUSHs ((SV *)CvPADLIST (cv));
567 PUSHs (INT2PTR (SV *, (IV)CvDEPTH (cv)));
221 PUSHs ((SV *)cv); 568 PUSHs ((SV *)cv);
222 569
223 get_padlist (cv);
224
225 CvDEPTH(cv) = 0; 570 CvDEPTH (cv) = 0;
226#ifdef USE_THREADS 571 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 } 572 }
233 } 573 }
234 else if (CxTYPE(cx) == CXt_FORMAT) 574 }
575
576 if (expect_true (top_si->si_type == PERLSI_MAIN))
577 break;
578
579 top_si = top_si->si_prev;
580 ccstk = top_si->si_cxstack;
581 cxix = top_si->si_cxix;
582 }
583
584 PUTBACK;
585 }
586
587 /* allocate some space on the context stack for our purposes */
588 /* we manually unroll here, as usually 2 slots is enough */
589 if (SLOT_COUNT >= 1) CXINC;
590 if (SLOT_COUNT >= 2) CXINC;
591 if (SLOT_COUNT >= 3) CXINC;
592 {
593 int i;
594 for (i = 3; i < SLOT_COUNT; ++i)
595 CXINC;
596 }
597 cxstack_ix -= SLOT_COUNT; /* undo allocation */
598
599 c->mainstack = PL_mainstack;
600
601 {
602 perl_slots *slot = c->slot = (perl_slots *)(cxstack + cxstack_ix + 1);
603
604 slot->defav = GvAV (PL_defgv);
605 slot->defsv = DEFSV;
606 slot->errsv = ERRSV;
607 slot->irsgv = GvSV (irsgv);
608
609 #define VAR(name,type) slot->name = PL_ ## name;
610 # include "state.h"
611 #undef VAR
612 }
613}
614
615/*
616 * allocate various perl stacks. This is almost an exact copy
617 * of perl.c:init_stacks, except that it uses less memory
618 * on the (sometimes correct) assumption that coroutines do
619 * not usually need a lot of stackspace.
620 */
621#if CORO_PREFER_PERL_FUNCTIONS
622# define coro_init_stacks init_stacks
623#else
624static void
625coro_init_stacks (pTHX)
626{
627 PL_curstackinfo = new_stackinfo(32, 8);
628 PL_curstackinfo->si_type = PERLSI_MAIN;
629 PL_curstack = PL_curstackinfo->si_stack;
630 PL_mainstack = PL_curstack; /* remember in case we switch stacks */
631
632 PL_stack_base = AvARRAY(PL_curstack);
633 PL_stack_sp = PL_stack_base;
634 PL_stack_max = PL_stack_base + AvMAX(PL_curstack);
635
636 New(50,PL_tmps_stack,32,SV*);
637 PL_tmps_floor = -1;
638 PL_tmps_ix = -1;
639 PL_tmps_max = 32;
640
641 New(54,PL_markstack,16,I32);
642 PL_markstack_ptr = PL_markstack;
643 PL_markstack_max = PL_markstack + 16;
644
645#ifdef SET_MARK_OFFSET
646 SET_MARK_OFFSET;
647#endif
648
649 New(54,PL_scopestack,8,I32);
650 PL_scopestack_ix = 0;
651 PL_scopestack_max = 8;
652
653 New(54,PL_savestack,24,ANY);
654 PL_savestack_ix = 0;
655 PL_savestack_max = 24;
656
657#if !PERL_VERSION_ATLEAST (5,10,0)
658 New(54,PL_retstack,4,OP*);
659 PL_retstack_ix = 0;
660 PL_retstack_max = 4;
661#endif
662}
663#endif
664
665/*
666 * destroy the stacks, the callchain etc...
667 */
668static void
669coro_destruct_stacks (pTHX)
670{
671 while (PL_curstackinfo->si_next)
672 PL_curstackinfo = PL_curstackinfo->si_next;
673
674 while (PL_curstackinfo)
675 {
676 PERL_SI *p = PL_curstackinfo->si_prev;
677
678 if (!IN_DESTRUCT)
679 SvREFCNT_dec (PL_curstackinfo->si_stack);
680
681 Safefree (PL_curstackinfo->si_cxstack);
682 Safefree (PL_curstackinfo);
683 PL_curstackinfo = p;
684 }
685
686 Safefree (PL_tmps_stack);
687 Safefree (PL_markstack);
688 Safefree (PL_scopestack);
689 Safefree (PL_savestack);
690#if !PERL_VERSION_ATLEAST (5,10,0)
691 Safefree (PL_retstack);
692#endif
693}
694
695static size_t
696coro_rss (pTHX_ struct coro *coro)
697{
698 size_t rss = sizeof (*coro);
699
700 if (coro->mainstack)
701 {
702 perl_slots tmp_slot;
703 perl_slots *slot;
704
705 if (coro->flags & CF_RUNNING)
706 {
707 slot = &tmp_slot;
708
709 #define VAR(name,type) slot->name = PL_ ## name;
710 # include "state.h"
711 #undef VAR
712 }
713 else
714 slot = coro->slot;
715
716 if (slot)
717 {
718 rss += sizeof (slot->curstackinfo);
719 rss += (slot->curstackinfo->si_cxmax + 1) * sizeof (PERL_CONTEXT);
720 rss += sizeof (SV) + sizeof (struct xpvav) + (1 + AvMAX (slot->curstack)) * sizeof (SV *);
721 rss += slot->tmps_max * sizeof (SV *);
722 rss += (slot->markstack_max - slot->markstack_ptr) * sizeof (I32);
723 rss += slot->scopestack_max * sizeof (I32);
724 rss += slot->savestack_max * sizeof (ANY);
725
726#if !PERL_VERSION_ATLEAST (5,10,0)
727 rss += slot->retstack_max * sizeof (OP *);
728#endif
729 }
730 }
731
732 return rss;
733}
734
735/** coroutine stack handling ************************************************/
736
737static int (*orig_sigelem_get) (pTHX_ SV *sv, MAGIC *mg);
738static int (*orig_sigelem_set) (pTHX_ SV *sv, MAGIC *mg);
739static int (*orig_sigelem_clr) (pTHX_ SV *sv, MAGIC *mg);
740
741/* apparently < 5.8.8 */
742#ifndef MgPV_nolen_const
743#define MgPV_nolen_const(mg) (((((int)(mg)->mg_len)) == HEf_SVKEY) ? \
744 SvPV_nolen((SV*)((mg)->mg_ptr)) : \
745 (const char*)(mg)->mg_ptr)
746#endif
747
748/*
749 * This overrides the default magic get method of %SIG elements.
750 * The original one doesn't provide for reading back of PL_diehook/PL_warnhook
751 * and instead of tryign to save and restore the hash elements, we just provide
752 * readback here.
753 * We only do this when the hook is != 0, as they are often set to 0 temporarily,
754 * not expecting this to actually change the hook. This is a potential problem
755 * when a schedule happens then, but we ignore this.
756 */
757static int
758coro_sigelem_get (pTHX_ SV *sv, MAGIC *mg)
759{
760 const char *s = MgPV_nolen_const (mg);
761
762 if (*s == '_')
763 {
764 SV **svp = 0;
765
766 if (strEQ (s, "__DIE__" )) svp = &PL_diehook;
767 if (strEQ (s, "__WARN__")) svp = &PL_warnhook;
768
769 if (svp)
770 {
771 sv_setsv (sv, *svp ? *svp : &PL_sv_undef);
772 return 0;
773 }
774 }
775
776 return orig_sigelem_get ? orig_sigelem_get (aTHX_ sv, mg) : 0;
777}
778
779static int
780coro_sigelem_clr (pTHX_ SV *sv, MAGIC *mg)
781{
782 const char *s = MgPV_nolen_const (mg);
783
784 if (*s == '_')
785 {
786 SV **svp = 0;
787
788 if (strEQ (s, "__DIE__" )) svp = &PL_diehook;
789 if (strEQ (s, "__WARN__")) svp = &PL_warnhook;
790
791 if (svp)
792 {
793 SV *old = *svp;
794 *svp = 0;
795 SvREFCNT_dec (old);
796 return 0;
797 }
798 }
799
800 return orig_sigelem_clr ? orig_sigelem_clr (aTHX_ sv, mg) : 0;
801}
802
803static int
804coro_sigelem_set (pTHX_ SV *sv, MAGIC *mg)
805{
806 const char *s = MgPV_nolen_const (mg);
807
808 if (*s == '_')
809 {
810 SV **svp = 0;
811
812 if (strEQ (s, "__DIE__" )) svp = &PL_diehook;
813 if (strEQ (s, "__WARN__")) svp = &PL_warnhook;
814
815 if (svp)
816 {
817 SV *old = *svp;
818 *svp = newSVsv (sv);
819 SvREFCNT_dec (old);
820 return 0;
821 }
822 }
823
824 return orig_sigelem_set ? orig_sigelem_set (aTHX_ sv, mg) : 0;
825}
826
827static void
828prepare_nop (aTHX_ struct coro_transfer_args *ta)
829{
830 /* kind of mega-hacky, but works */
831 ta->next = ta->prev = (struct coro *)ta;
832}
833
834static int
835slf_check_nop (aTHX)
836{
837 return 0;
838}
839
840static void
841coro_setup (pTHX_ struct coro *coro)
842{
843 /*
844 * emulate part of the perl startup here.
845 */
846 coro_init_stacks (aTHX);
847
848 PL_runops = RUNOPS_DEFAULT;
849 PL_curcop = &PL_compiling;
850 PL_in_eval = EVAL_NULL;
851 PL_comppad = 0;
852 PL_curpm = 0;
853 PL_curpad = 0;
854 PL_localizing = 0;
855 PL_dirty = 0;
856 PL_restartop = 0;
857#if PERL_VERSION_ATLEAST (5,10,0)
858 PL_parser = 0;
859#endif
860
861 /* recreate the die/warn hooks */
862 PL_diehook = 0; SvSetMagicSV (*hv_fetch (hv_sig, "__DIE__" , sizeof ("__DIE__" ) - 1, 1), rv_diehook );
863 PL_warnhook = 0; SvSetMagicSV (*hv_fetch (hv_sig, "__WARN__", sizeof ("__WARN__") - 1, 1), rv_warnhook);
864
865 GvSV (PL_defgv) = newSV (0);
866 GvAV (PL_defgv) = coro->args; coro->args = 0;
867 GvSV (PL_errgv) = newSV (0);
868 GvSV (irsgv) = newSVpvn ("\n", 1); sv_magic (GvSV (irsgv), (SV *)irsgv, PERL_MAGIC_sv, "/", 0);
869 PL_rs = newSVsv (GvSV (irsgv));
870 PL_defoutgv = (GV *)SvREFCNT_inc_NN (stdoutgv);
871
872 {
873 dSP;
874 UNOP myop;
875
876 Zero (&myop, 1, UNOP);
877 myop.op_next = Nullop;
878 myop.op_flags = OPf_WANT_VOID;
879
880 PUSHMARK (SP);
881 XPUSHs (sv_2mortal (av_shift (GvAV (PL_defgv))));
882 PUTBACK;
883 PL_op = (OP *)&myop;
884 PL_op = PL_ppaddr[OP_ENTERSUB](aTHX);
885 SPAGAIN;
886 }
887
888 /* this newly created coroutine might be run on an existing cctx which most
889 * likely was suspended in pp_slf, so we have to emulate entering pp_slf here.
890 */
891 slf_frame.prepare = prepare_nop; /* provide a nop function for an eventual pp_slf */
892 slf_frame.check = slf_check_nop; /* signal pp_slf to not repeat */
893}
894
895static void
896coro_destruct (pTHX_ struct coro *coro)
897{
898 if (!IN_DESTRUCT)
899 {
900 /* restore all saved variables and stuff */
901 LEAVE_SCOPE (0);
902 assert (PL_tmps_floor == -1);
903
904 /* free all temporaries */
905 FREETMPS;
906 assert (PL_tmps_ix == -1);
907
908 /* unwind all extra stacks */
909 POPSTACK_TO (PL_mainstack);
910
911 /* unwind main stack */
912 dounwind (-1);
913 }
914
915 SvREFCNT_dec (GvSV (PL_defgv));
916 SvREFCNT_dec (GvAV (PL_defgv));
917 SvREFCNT_dec (GvSV (PL_errgv));
918 SvREFCNT_dec (PL_defoutgv);
919 SvREFCNT_dec (PL_rs);
920 SvREFCNT_dec (GvSV (irsgv));
921
922 SvREFCNT_dec (PL_diehook);
923 SvREFCNT_dec (PL_warnhook);
924
925 SvREFCNT_dec (coro->saved_deffh);
926 SvREFCNT_dec (coro->throw);
927
928 coro_destruct_stacks (aTHX);
929}
930
931INLINE void
932free_coro_mortal (pTHX)
933{
934 if (expect_true (coro_mortal))
935 {
936 SvREFCNT_dec (coro_mortal);
937 coro_mortal = 0;
938 }
939}
940
941static int
942runops_trace (pTHX)
943{
944 COP *oldcop = 0;
945 int oldcxix = -2;
946 struct coro *coro = SvSTATE (coro_current); /* trace cctx is tied to specific coro */
947 coro_cctx *cctx = coro->cctx;
948
949 while ((PL_op = CALL_FPTR (PL_op->op_ppaddr) (aTHX)))
950 {
951 PERL_ASYNC_CHECK ();
952
953 if (cctx->flags & CC_TRACE_ALL)
954 {
955 if (PL_op->op_type == OP_LEAVESUB && cctx->flags & CC_TRACE_SUB)
956 {
957 PERL_CONTEXT *cx = &cxstack[cxstack_ix];
958 SV **bot, **top;
959 AV *av = newAV (); /* return values */
960 SV **cb;
961 dSP;
962
963 GV *gv = CvGV (cx->blk_sub.cv);
964 SV *fullname = sv_2mortal (newSV (0));
965 if (isGV (gv))
966 gv_efullname3 (fullname, gv, 0);
967
968 bot = PL_stack_base + cx->blk_oldsp + 1;
969 top = cx->blk_gimme == G_ARRAY ? SP + 1
970 : cx->blk_gimme == G_SCALAR ? bot + 1
971 : bot;
972
973 av_extend (av, top - bot);
974 while (bot < top)
975 av_push (av, SvREFCNT_inc_NN (*bot++));
976
977 PL_runops = RUNOPS_DEFAULT;
978 ENTER;
979 SAVETMPS;
980 EXTEND (SP, 3);
981 PUSHMARK (SP);
982 PUSHs (&PL_sv_no);
983 PUSHs (fullname);
984 PUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
985 PUTBACK;
986 cb = hv_fetch ((HV *)SvRV (coro_current), "_trace_sub_cb", sizeof ("_trace_sub_cb") - 1, 0);
987 if (cb) call_sv (*cb, G_KEEPERR | G_EVAL | G_VOID | G_DISCARD);
988 SPAGAIN;
989 FREETMPS;
990 LEAVE;
991 PL_runops = runops_trace;
992 }
993
994 if (oldcop != PL_curcop)
995 {
996 oldcop = PL_curcop;
997
998 if (PL_curcop != &PL_compiling)
999 {
1000 SV **cb;
1001
1002 if (oldcxix != cxstack_ix && cctx->flags & CC_TRACE_SUB)
1003 {
1004 PERL_CONTEXT *cx = &cxstack[cxstack_ix];
1005
1006 if (CxTYPE (cx) == CXt_SUB && oldcxix < cxstack_ix)
1007 {
1008 runops_proc_t old_runops = PL_runops;
1009 dSP;
1010 GV *gv = CvGV (cx->blk_sub.cv);
1011 SV *fullname = sv_2mortal (newSV (0));
1012
1013 if (isGV (gv))
1014 gv_efullname3 (fullname, gv, 0);
1015
1016 PL_runops = RUNOPS_DEFAULT;
1017 ENTER;
1018 SAVETMPS;
1019 EXTEND (SP, 3);
1020 PUSHMARK (SP);
1021 PUSHs (&PL_sv_yes);
1022 PUSHs (fullname);
1023 PUSHs (CxHASARGS (cx) ? sv_2mortal (newRV_inc ((SV *)cx->blk_sub.argarray)) : &PL_sv_undef);
1024 PUTBACK;
1025 cb = hv_fetch ((HV *)SvRV (coro_current), "_trace_sub_cb", sizeof ("_trace_sub_cb") - 1, 0);
1026 if (cb) call_sv (*cb, G_KEEPERR | G_EVAL | G_VOID | G_DISCARD);
1027 SPAGAIN;
1028 FREETMPS;
1029 LEAVE;
1030 PL_runops = runops_trace;
1031 }
1032
1033 oldcxix = cxstack_ix;
1034 }
1035
1036 if (cctx->flags & CC_TRACE_LINE)
1037 {
1038 dSP;
1039
1040 PL_runops = RUNOPS_DEFAULT;
1041 ENTER;
1042 SAVETMPS;
1043 EXTEND (SP, 3);
1044 PL_runops = RUNOPS_DEFAULT;
1045 PUSHMARK (SP);
1046 PUSHs (sv_2mortal (newSVpv (OutCopFILE (oldcop), 0)));
1047 PUSHs (sv_2mortal (newSViv (CopLINE (oldcop))));
1048 PUTBACK;
1049 cb = hv_fetch ((HV *)SvRV (coro_current), "_trace_line_cb", sizeof ("_trace_line_cb") - 1, 0);
1050 if (cb) call_sv (*cb, G_KEEPERR | G_EVAL | G_VOID | G_DISCARD);
1051 SPAGAIN;
1052 FREETMPS;
1053 LEAVE;
1054 PL_runops = runops_trace;
1055 }
1056 }
1057 }
1058 }
1059 }
1060
1061 TAINT_NOT;
1062 return 0;
1063}
1064
1065static void
1066prepare_set_stacklevel (struct coro_transfer_args *ta, struct coro_cctx *cctx)
1067{
1068 ta->prev = (struct coro *)cctx;
1069 ta->next = 0;
1070}
1071
1072/* inject a fake call to Coro::State::_cctx_init into the execution */
1073/* _cctx_init should be careful, as it could be called at almost any time */
1074/* during execution of a perl program */
1075/* also initialises PL_top_env */
1076static void NOINLINE
1077cctx_prepare (pTHX_ coro_cctx *cctx)
1078{
1079 dSP;
1080 UNOP myop;
1081
1082 PL_top_env = &PL_start_env;
1083
1084 if (cctx->flags & CC_TRACE)
1085 PL_runops = runops_trace;
1086
1087 Zero (&myop, 1, UNOP);
1088 myop.op_next = PL_op;
1089 myop.op_flags = OPf_WANT_VOID | OPf_STACKED;
1090
1091 PUSHMARK (SP);
1092 EXTEND (SP, 2);
1093 PUSHs (sv_2mortal (newSViv ((IV)cctx)));
1094 PUSHs ((SV *)get_cv ("Coro::State::_cctx_init", FALSE));
1095 PUTBACK;
1096 PL_op = (OP *)&myop;
1097 PL_op = PL_ppaddr[OP_ENTERSUB](aTHX);
1098 SPAGAIN;
1099}
1100
1101/* the tail of transfer: execute stuff we can only do after a transfer */
1102INLINE void
1103transfer_tail (pTHX)
1104{
1105 struct coro *next = (struct coro *)transfer_next;
1106 assert (!(transfer_next = 0)); /* just used for the side effect when asserts are enabled */
1107 assert (("FATAL: next coroutine was zero in transfer_tail (please report)", next));
1108
1109 free_coro_mortal (aTHX);
1110 UNLOCK;
1111
1112 if (expect_false (next->throw))
1113 {
1114 SV *exception = sv_2mortal (next->throw);
1115
1116 next->throw = 0;
1117 sv_setsv (ERRSV, exception);
1118 croak (0);
1119 }
1120}
1121
1122/*
1123 * this is a _very_ stripped down perl interpreter ;)
1124 */
1125static void
1126cctx_run (void *arg)
1127{
1128#ifdef USE_ITHREADS
1129# if CORO_PTHREAD
1130 PERL_SET_CONTEXT (coro_thx);
1131# endif
1132#endif
1133 {
1134 dTHX;
1135
1136 /* normally we would need to skip the entersub here */
1137 /* not doing so will re-execute it, which is exactly what we want */
1138 /* PL_nop = PL_nop->op_next */
1139
1140 /* inject a fake subroutine call to cctx_init */
1141 cctx_prepare (aTHX_ (coro_cctx *)arg);
1142
1143 /* cctx_run is the alternative tail of transfer() */
1144 /* TODO: throwing an exception here might be deadly, VERIFY */
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 coro_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 (pTHX_ SV *prev_sv, SV *next_sv)
1511{
1512 struct coro_transfer_args ta;
1513
1514 prepare_transfer (aTHX_ &ta, prev_sv, next_sv);
1515 TRANSFER (ta, 1);
1516}
1517
1518/** Coro ********************************************************************/
1519
1520static void
1521coro_enq (pTHX_ SV *coro_sv)
1522{
1523 av_push (coro_ready [SvSTATE (coro_sv)->prio - PRIO_MIN], coro_sv);
1524}
1525
1526static SV *
1527coro_deq (pTHX)
1528{
1529 int prio;
1530
1531 for (prio = PRIO_MAX - PRIO_MIN + 1; --prio >= 0; )
1532 if (AvFILLp (coro_ready [prio]) >= 0)
1533 return av_shift (coro_ready [prio]);
1534
1535 return 0;
1536}
1537
1538static int
1539api_ready (pTHX_ SV *coro_sv)
1540{
1541 struct coro *coro;
1542 SV *sv_hook;
1543 void (*xs_hook)(void);
1544
1545 if (SvROK (coro_sv))
1546 coro_sv = SvRV (coro_sv);
1547
1548 coro = SvSTATE (coro_sv);
1549
1550 if (coro->flags & CF_READY)
1551 return 0;
1552
1553 coro->flags |= CF_READY;
1554
1555 LOCK;
1556
1557 sv_hook = coro_nready ? 0 : coro_readyhook;
1558 xs_hook = coro_nready ? 0 : coroapi.readyhook;
1559
1560 coro_enq (aTHX_ SvREFCNT_inc_NN (coro_sv));
1561 ++coro_nready;
1562
1563 UNLOCK;
1564
1565 if (sv_hook)
1566 {
1567 dSP;
1568
1569 ENTER;
1570 SAVETMPS;
1571
1572 PUSHMARK (SP);
1573 PUTBACK;
1574 call_sv (sv_hook, G_DISCARD);
1575 SPAGAIN;
1576
1577 FREETMPS;
1578 LEAVE;
1579 }
1580
1581 if (xs_hook)
1582 xs_hook ();
1583
1584 return 1;
1585}
1586
1587static int
1588api_is_ready (pTHX_ SV *coro_sv)
1589{
1590 return !!(SvSTATE (coro_sv)->flags & CF_READY);
1591}
1592
1593INLINE void
1594prepare_schedule (pTHX_ struct coro_transfer_args *ta)
1595{
1596 SV *prev_sv, *next_sv;
1597
1598 for (;;)
1599 {
1600 LOCK;
1601 next_sv = coro_deq (aTHX);
1602
1603 /* nothing to schedule: call the idle handler */
1604 if (expect_false (!next_sv))
1605 {
1606 dSP;
1607 UNLOCK;
1608
1609 ENTER;
1610 SAVETMPS;
1611
1612 PUSHMARK (SP);
1613 PUTBACK;
1614 call_sv (get_sv ("Coro::idle", FALSE), G_DISCARD);
1615 SPAGAIN;
1616
1617 FREETMPS;
1618 LEAVE;
1619 continue;
1620 }
1621
1622 ta->next = SvSTATE (next_sv);
1623
1624 /* cannot transfer to destroyed coros, skip and look for next */
1625 if (expect_false (ta->next->flags & CF_DESTROYED))
1626 {
1627 UNLOCK;
1628 SvREFCNT_dec (next_sv);
1629 /* coro_nready has already been taken care of by destroy */
1630 continue;
1631 }
1632
1633 --coro_nready;
1634 UNLOCK;
1635 break;
1636 }
1637
1638 /* free this only after the transfer */
1639 prev_sv = SvRV (coro_current);
1640 ta->prev = SvSTATE (prev_sv);
1641 TRANSFER_CHECK (*ta);
1642 assert (("FATAL: next coroutine isn't marked as ready in Coro (please report)", ta->next->flags & CF_READY));
1643 ta->next->flags &= ~CF_READY;
1644 SvRV_set (coro_current, next_sv);
1645
1646 LOCK;
1647 free_coro_mortal (aTHX);
1648 coro_mortal = prev_sv;
1649 UNLOCK;
1650}
1651
1652INLINE void
1653prepare_cede (pTHX_ struct coro_transfer_args *ta)
1654{
1655 api_ready (aTHX_ coro_current);
1656 prepare_schedule (aTHX_ ta);
1657}
1658
1659INLINE void
1660prepare_cede_notself (pTHX_ struct coro_transfer_args *ta)
1661{
1662 SV *prev = SvRV (coro_current);
1663
1664 if (coro_nready)
1665 {
1666 prepare_schedule (aTHX_ ta);
1667 api_ready (aTHX_ prev);
1668 }
1669 else
1670 prepare_nop (aTHX_ ta);
1671}
1672
1673static void
1674api_schedule (pTHX)
1675{
1676 struct coro_transfer_args ta;
1677
1678 prepare_schedule (aTHX_ &ta);
1679 TRANSFER (ta, 1);
1680}
1681
1682static int
1683api_cede (pTHX)
1684{
1685 struct coro_transfer_args ta;
1686
1687 prepare_cede (aTHX_ &ta);
1688
1689 if (expect_true (ta.prev != ta.next))
1690 {
1691 TRANSFER (ta, 1);
1692 return 1;
1693 }
1694 else
1695 return 0;
1696}
1697
1698static int
1699api_cede_notself (pTHX)
1700{
1701 if (coro_nready)
1702 {
1703 struct coro_transfer_args ta;
1704
1705 prepare_cede_notself (aTHX_ &ta);
1706 TRANSFER (ta, 1);
1707 return 1;
1708 }
1709 else
1710 return 0;
1711}
1712
1713static void
1714api_trace (pTHX_ SV *coro_sv, int flags)
1715{
1716 struct coro *coro = SvSTATE (coro_sv);
1717
1718 if (flags & CC_TRACE)
1719 {
1720 if (!coro->cctx)
1721 coro->cctx = cctx_new_run ();
1722 else if (!(coro->cctx->flags & CC_TRACE))
1723 croak ("cannot enable tracing on coroutine with custom stack");
1724
1725 coro->cctx->flags |= CC_NOREUSE | (flags & (CC_TRACE | CC_TRACE_ALL));
1726 }
1727 else if (coro->cctx && coro->cctx->flags & CC_TRACE)
1728 {
1729 coro->cctx->flags &= ~(CC_TRACE | CC_TRACE_ALL);
1730
1731 if (coro->flags & CF_RUNNING)
1732 PL_runops = RUNOPS_DEFAULT;
1733 else
1734 coro->slot->runops = RUNOPS_DEFAULT;
1735 }
1736}
1737
1738#if 0
1739static int
1740coro_gensub_free (pTHX_ SV *sv, MAGIC *mg)
1741{
1742 AV *padlist;
1743 AV *av = (AV *)mg->mg_obj;
1744
1745 abort ();
1746
1747 return 0;
1748}
1749
1750static MGVTBL coro_gensub_vtbl = {
1751 0, 0, 0, 0,
1752 coro_gensub_free
1753};
1754#endif
1755
1756/*****************************************************************************/
1757/* PerlIO::cede */
1758
1759typedef struct
1760{
1761 PerlIOBuf base;
1762 NV next, every;
1763} PerlIOCede;
1764
1765static IV
1766PerlIOCede_pushed (pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
1767{
1768 PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
1769
1770 self->every = SvCUR (arg) ? SvNV (arg) : 0.01;
1771 self->next = nvtime () + self->every;
1772
1773 return PerlIOBuf_pushed (aTHX_ f, mode, Nullsv, tab);
1774}
1775
1776static SV *
1777PerlIOCede_getarg (pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)
1778{
1779 PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
1780
1781 return newSVnv (self->every);
1782}
1783
1784static IV
1785PerlIOCede_flush (pTHX_ PerlIO *f)
1786{
1787 PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
1788 double now = nvtime ();
1789
1790 if (now >= self->next)
1791 {
1792 api_cede (aTHX);
1793 self->next = now + self->every;
1794 }
1795
1796 return PerlIOBuf_flush (aTHX_ f);
1797}
1798
1799static PerlIO_funcs PerlIO_cede =
1800{
1801 sizeof(PerlIO_funcs),
1802 "cede",
1803 sizeof(PerlIOCede),
1804 PERLIO_K_DESTRUCT | PERLIO_K_RAW,
1805 PerlIOCede_pushed,
1806 PerlIOBuf_popped,
1807 PerlIOBuf_open,
1808 PerlIOBase_binmode,
1809 PerlIOCede_getarg,
1810 PerlIOBase_fileno,
1811 PerlIOBuf_dup,
1812 PerlIOBuf_read,
1813 PerlIOBuf_unread,
1814 PerlIOBuf_write,
1815 PerlIOBuf_seek,
1816 PerlIOBuf_tell,
1817 PerlIOBuf_close,
1818 PerlIOCede_flush,
1819 PerlIOBuf_fill,
1820 PerlIOBase_eof,
1821 PerlIOBase_error,
1822 PerlIOBase_clearerr,
1823 PerlIOBase_setlinebuf,
1824 PerlIOBuf_get_base,
1825 PerlIOBuf_bufsiz,
1826 PerlIOBuf_get_ptr,
1827 PerlIOBuf_get_cnt,
1828 PerlIOBuf_set_ptrcnt,
1829};
1830
1831/*****************************************************************************/
1832
1833static const CV *slf_cv; /* for quick consistency check */
1834
1835static UNOP slf_restore; /* restore stack as entersub did, for first-re-run */
1836static SV *slf_arg0;
1837static SV *slf_arg1;
1838
1839/* this restores the stack in the case we patched the entersub, to */
1840/* recreate the stack frame as perl will on following calls */
1841/* since entersub cleared the stack */
1842static OP *
1843pp_restore (pTHX)
1844{
1845 dSP;
1846
1847 PUSHMARK (SP);
1848
1849 EXTEND (SP, 3);
1850 if (slf_arg0) PUSHs (sv_2mortal (slf_arg0));
1851 if (slf_arg1) PUSHs (sv_2mortal (slf_arg1));
1852 PUSHs ((SV *)CvGV (slf_cv));
1853
1854 RETURNOP (slf_restore.op_first);
1855}
1856
1857static void
1858slf_init_set_stacklevel (pTHX_ SV **arg, int items)
1859{
1860 assert (("FATAL: set_stacklevel needs the coro cctx as sole argument", items == 1));
1861 CORO_SLF_DATA = (void *)SvIV (arg [0]);
1862}
1863
1864static void
1865slf_prepare_set_stacklevel (pTHX_ struct coro_transfer_args *ta)
1866{
1867 prepare_set_stacklevel (ta, (struct coro_cctx *)CORO_SLF_DATA);
1868}
1869
1870static void
1871slf_init_transfer (pTHX_ SV **arg, int items)
1872{
1873 if (items != 2)
1874 croak ("Coro::State::transfer (prev, next) expects two arguments, not %d.", items);
1875
1876 CORO_SLF_DATA = (void *)arg; /* let's hope it will stay valid */
1877}
1878
1879static void
1880slf_prepare_transfer (pTHX_ struct coro_transfer_args *ta)
1881{
1882 SV **arg = (SV **)CORO_SLF_DATA;
1883
1884 prepare_transfer (ta, arg [0], arg [1]);
1885}
1886
1887static void
1888slf_init_nop (pTHX_ SV **arg, int items)
1889{
1890}
1891
1892/* slf_prepare_schedule == prepare_schedule */
1893/* slf_prepare_cede == prepare_cede */
1894/* slf_prepare_notself == prepare_notself */
1895
1896/* we hijack an hopefully unused CV flag for our purposes */
1897#define CVf_SLF 0x4000
1898
1899/*
1900 * these not obviously related functions are all rolled into one
1901 * function to increase chances that they all will call transfer with the same
1902 * stack offset
1903 * SLF stands for "schedule-like-function".
1904 */
1905static OP *
1906pp_slf (pTHX)
1907{
1908 I32 checkmark; /* mark SP to see how many elements check has pushed */
1909
1910 if (expect_true (!slf_frame.prepare))
1911 {
1912 /* first iteration */
1913 dSP;
1914 SV **arg = PL_stack_base + TOPMARK + 1;
1915 int items = SP - arg; /* args without function object */
1916 SV *gv = *sp;
1917 struct CoroSLF *slf;
1918
1919 /* do a quick consistency check on the "function" object, and if it isn't */
1920 /* for us, divert to the real entersub */
1921 if (SvTYPE (gv) != SVt_PVGV || !(CvFLAGS (GvCV (gv)) & CVf_SLF))
1922 return PL_ppaddr[OP_ENTERSUB](aTHX);
1923
1924 /* pop args */
1925 SP = PL_stack_base + POPMARK;
1926
1927 if (!(PL_op->op_flags & OPf_STACKED))
1928 {
1929 /* ampersand-form of call, use @_ instead of stack */
1930 AV *av = GvAV (PL_defgv);
1931 arg = AvARRAY (av);
1932 items = AvFILLp (av) + 1;
1933 }
1934
1935 PUTBACK;
1936
1937 slf = (struct CoroSLF *)CvXSUBANY (GvCV (gv)).any_ptr;
1938 slf_frame.prepare = slf->prepare;
1939 slf_frame.check = slf->check;
1940 slf->init (aTHX_ arg, items);
1941 }
1942
1943 /* now interpret the slf_frame */
1944 /* we use a callback system not to make the code needlessly */
1945 /* complicated, but so we can run multiple perl coros from one cctx */
1946
1947 do
1948 {
1949 struct coro_transfer_args ta;
1950
1951 slf_frame.prepare (aTHX_ &ta);
1952 TRANSFER (ta, 0);
1953
1954 checkmark = PL_stack_sp - PL_stack_base;
1955 }
1956 while (slf_frame.check (aTHX));
1957
1958 {
1959 dSP;
1960 SV **bot = PL_stack_base + checkmark;
1961 int gimme = GIMME_V;
1962
1963 slf_frame.prepare = 0; /* signal pp_slf that we need a new frame */
1964
1965 /* make sure we put something on the stack in scalar context */
1966 if (gimme == G_SCALAR)
1967 {
1968 if (sp == bot)
1969 XPUSHs (&PL_sv_undef);
1970
1971 SP = bot + 1;
1972 }
1973
1974 PUTBACK;
1975 }
1976
1977 return NORMAL;
1978}
1979
1980static void
1981api_execute_slf (pTHX_ CV *cv, const struct CoroSLF *slf, SV **arg, int items)
1982{
1983 assert (("FATAL: SLF call recursion in Coro module (please report)", PL_op->op_ppaddr != pp_slf));
1984 assert (("FATAL: SLF call with illegal CV value", !CvANON (cv)));
1985
1986 if (items > 2)
1987 croak ("Coro only supports a max of two arguments to SLF functions.");
1988
1989 CvFLAGS (cv) |= CVf_SLF;
1990 CvXSUBANY (cv).any_ptr = (void *)slf;
1991 slf_cv = cv;
1992
1993 /* we patch the op, and then re-run the whole call */
1994 /* we have to put the same argument on the stack for this to work */
1995 /* and this will be done by pp_restore */
1996 slf_restore.op_next = (OP *)&slf_restore;
1997 slf_restore.op_type = OP_NULL;
1998 slf_restore.op_ppaddr = pp_restore;
1999 slf_restore.op_first = PL_op;
2000
2001 slf_arg0 = items > 0 ? SvREFCNT_inc (arg [0]) : 0;
2002 slf_arg1 = items > 1 ? SvREFCNT_inc (arg [1]) : 0;
2003
2004 PL_op->op_ppaddr = pp_slf;
2005
2006 PL_op = (OP *)&slf_restore;
2007}
2008
2009MODULE = Coro::State PACKAGE = Coro::State PREFIX = api_
2010
2011PROTOTYPES: DISABLE
2012
2013BOOT:
2014{
2015#ifdef USE_ITHREADS
2016 MUTEX_INIT (&coro_lock);
2017# if CORO_PTHREAD
2018 coro_thx = PERL_GET_CONTEXT;
2019# endif
2020#endif
2021 BOOT_PAGESIZE;
2022
2023 irsgv = gv_fetchpv ("/" , GV_ADD|GV_NOTQUAL, SVt_PV);
2024 stdoutgv = gv_fetchpv ("STDOUT", GV_ADD|GV_NOTQUAL, SVt_PVIO);
2025
2026 orig_sigelem_get = PL_vtbl_sigelem.svt_get; PL_vtbl_sigelem.svt_get = coro_sigelem_get;
2027 orig_sigelem_set = PL_vtbl_sigelem.svt_set; PL_vtbl_sigelem.svt_set = coro_sigelem_set;
2028 orig_sigelem_clr = PL_vtbl_sigelem.svt_clear; PL_vtbl_sigelem.svt_clear = coro_sigelem_clr;
2029
2030 hv_sig = coro_get_hv (aTHX_ "SIG", TRUE);
2031 rv_diehook = newRV_inc ((SV *)gv_fetchpv ("Coro::State::diehook" , 0, SVt_PVCV));
2032 rv_warnhook = newRV_inc ((SV *)gv_fetchpv ("Coro::State::warnhook", 0, SVt_PVCV));
2033
2034 coro_state_stash = gv_stashpv ("Coro::State", TRUE);
2035
2036 newCONSTSUB (coro_state_stash, "CC_TRACE" , newSViv (CC_TRACE));
2037 newCONSTSUB (coro_state_stash, "CC_TRACE_SUB" , newSViv (CC_TRACE_SUB));
2038 newCONSTSUB (coro_state_stash, "CC_TRACE_LINE", newSViv (CC_TRACE_LINE));
2039 newCONSTSUB (coro_state_stash, "CC_TRACE_ALL" , newSViv (CC_TRACE_ALL));
2040
2041 main_mainstack = PL_mainstack;
2042 main_top_env = PL_top_env;
2043
2044 while (main_top_env->je_prev)
2045 main_top_env = main_top_env->je_prev;
2046
2047 coroapi.ver = CORO_API_VERSION;
2048 coroapi.rev = CORO_API_REVISION;
2049 coroapi.transfer = api_transfer;
2050 coroapi.execute_slf = api_execute_slf;
2051 coroapi.sv_state = SvSTATE_;
2052
2053 {
2054 SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
2055
2056 if (!svp) croak ("Time::HiRes is required");
2057 if (!SvIOK (*svp)) croak ("Time::NVtime isn't a function pointer");
2058
2059 nvtime = INT2PTR (double (*)(), SvIV (*svp));
2060 }
2061
2062 assert (("PRIO_NORMAL must be 0", !PRIO_NORMAL));
2063}
2064
2065SV *
2066new (char *klass, ...)
2067 CODE:
2068{
2069 struct coro *coro;
2070 MAGIC *mg;
2071 HV *hv;
2072 int i;
2073
2074 Newz (0, coro, 1, struct coro);
2075 coro->args = newAV ();
2076 coro->flags = CF_NEW;
2077
2078 if (coro_first) coro_first->prev = coro;
2079 coro->next = coro_first;
2080 coro_first = coro;
2081
2082 coro->hv = hv = newHV ();
2083 mg = sv_magicext ((SV *)hv, 0, CORO_MAGIC_type_state, &coro_state_vtbl, (char *)coro, 0);
2084 mg->mg_flags |= MGf_DUP;
2085 RETVAL = sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));
2086
2087 av_extend (coro->args, items - 1);
2088 for (i = 1; i < items; i++)
2089 av_push (coro->args, newSVsv (ST (i)));
2090}
2091 OUTPUT:
2092 RETVAL
2093
2094void
2095_set_stacklevel (...)
2096 CODE:
2097{
2098 static struct CoroSLF slf = { slf_init_set_stacklevel, slf_prepare_set_stacklevel, slf_check_nop };
2099 api_execute_slf (aTHX_ cv, &slf, &ST (0), items);
2100}
2101
2102void
2103transfer (...)
2104 CODE:
2105{
2106 static struct CoroSLF slf = { slf_init_transfer, slf_prepare_transfer, slf_check_nop };
2107 api_execute_slf (aTHX_ cv, &slf, &ST (0), items);
2108}
2109
2110bool
2111_destroy (SV *coro_sv)
2112 CODE:
2113 RETVAL = coro_state_destroy (aTHX_ SvSTATE (coro_sv));
2114 OUTPUT:
2115 RETVAL
2116
2117void
2118_exit (int code)
2119 PROTOTYPE: $
2120 CODE:
2121 _exit (code);
2122
2123int
2124cctx_stacksize (int new_stacksize = 0)
2125 CODE:
2126 RETVAL = cctx_stacksize;
2127 if (new_stacksize)
2128 {
2129 cctx_stacksize = new_stacksize;
2130 ++cctx_gen;
2131 }
2132 OUTPUT:
2133 RETVAL
2134
2135int
2136cctx_max_idle (int max_idle = 0)
2137 CODE:
2138 RETVAL = cctx_max_idle;
2139 if (max_idle > 1)
2140 cctx_max_idle = max_idle;
2141 OUTPUT:
2142 RETVAL
2143
2144int
2145cctx_count ()
2146 CODE:
2147 RETVAL = cctx_count;
2148 OUTPUT:
2149 RETVAL
2150
2151int
2152cctx_idle ()
2153 CODE:
2154 RETVAL = cctx_idle;
2155 OUTPUT:
2156 RETVAL
2157
2158void
2159list ()
2160 PPCODE:
2161{
2162 struct coro *coro;
2163 for (coro = coro_first; coro; coro = coro->next)
2164 if (coro->hv)
2165 XPUSHs (sv_2mortal (newRV_inc ((SV *)coro->hv)));
2166}
2167
2168void
2169call (Coro::State coro, SV *coderef)
2170 ALIAS:
2171 eval = 1
2172 CODE:
2173{
2174 if (coro->mainstack && ((coro->flags & CF_RUNNING) || coro->slot))
2175 {
2176 struct coro temp;
2177
2178 if (!(coro->flags & CF_RUNNING))
235 { 2179 {
236 /* I never used formats, so how should I know how these are implemented? */ 2180 PUTBACK;
237 /* my bold guess is as a simple, plain sub... */ 2181 save_perl (aTHX_ &temp);
238 croak ("CXt_FORMAT not yet handled. Don't switch coroutines from within formats"); 2182 load_perl (aTHX_ coro);
2183 }
2184
2185 {
2186 dSP;
2187 ENTER;
2188 SAVETMPS;
2189 PUTBACK;
2190 PUSHSTACK;
2191 PUSHMARK (SP);
2192
2193 if (ix)
2194 eval_sv (coderef, 0);
2195 else
2196 call_sv (coderef, G_KEEPERR | G_EVAL | G_VOID | G_DISCARD);
2197
2198 POPSTACK;
2199 SPAGAIN;
2200 FREETMPS;
2201 LEAVE;
2202 PUTBACK;
2203 }
2204
2205 if (!(coro->flags & CF_RUNNING))
2206 {
2207 save_perl (aTHX_ coro);
2208 load_perl (aTHX_ &temp);
2209 SPAGAIN;
239 } 2210 }
240 } 2211 }
241
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} 2212}
281 2213
282static void 2214SV *
283LOAD(pTHX_ Coro__State c) 2215is_ready (Coro::State coro)
284{ 2216 PROTOTYPE: $
285 PL_dowarn = c->dowarn; 2217 ALIAS:
286 GvAV (PL_defgv) = c->defav; 2218 is_ready = CF_READY
287 PL_curstackinfo = c->curstackinfo; 2219 is_running = CF_RUNNING
288 PL_curstack = c->curstack; 2220 is_new = CF_NEW
289 PL_mainstack = c->mainstack; 2221 is_destroyed = CF_DESTROYED
290 PL_stack_sp = c->stack_sp; 2222 CODE:
291 PL_op = c->op; 2223 RETVAL = boolSV (coro->flags & ix);
292 PL_curpad = c->curpad; 2224 OUTPUT:
293 PL_stack_base = c->stack_base; 2225 RETVAL
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 2226
2227void
2228throw (Coro::State self, SV *throw = &PL_sv_undef)
2229 PROTOTYPE: $;$
2230 CODE:
2231 SvREFCNT_dec (self->throw);
2232 self->throw = SvOK (throw) ? newSVsv (throw) : 0;
2233
2234void
2235api_trace (SV *coro, int flags = CC_TRACE | CC_TRACE_SUB)
2236 C_ARGS: aTHX_ coro, flags
2237
2238SV *
2239has_cctx (Coro::State coro)
2240 PROTOTYPE: $
2241 CODE:
2242 RETVAL = boolSV (!!coro->cctx);
2243 OUTPUT:
2244 RETVAL
2245
2246int
2247is_traced (Coro::State coro)
2248 PROTOTYPE: $
2249 CODE:
2250 RETVAL = (coro->cctx ? coro->cctx->flags : 0) & CC_TRACE_ALL;
2251 OUTPUT:
2252 RETVAL
2253
2254UV
2255rss (Coro::State coro)
2256 PROTOTYPE: $
2257 ALIAS:
2258 usecount = 1
2259 CODE:
2260 switch (ix)
313 { 2261 {
314 dSP; 2262 case 0: RETVAL = coro_rss (aTHX_ coro); break;
315 CV *cv; 2263 case 1: RETVAL = coro->usecount; break;
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 } 2264 }
2265 OUTPUT:
2266 RETVAL
331 2267
332 PUTBACK; 2268void
333 } 2269force_cctx ()
334} 2270 CODE:
2271 struct coro *coro = SvSTATE (coro_current);
2272 coro->cctx->idle_sp = 0;
335 2273
336/* this is an EXACT copy of S_nuke_stacks in perl.c, which is unfortunately static */ 2274void
337STATIC void 2275swap_defsv (Coro::State self)
338destroy_stacks(pTHX) 2276 PROTOTYPE: $
339{ 2277 ALIAS:
340 dSP; 2278 swap_defav = 1
2279 CODE:
2280 if (!self->slot)
2281 croak ("cannot swap state with coroutine that has no saved state");
2282 else
2283 {
2284 SV **src = ix ? (SV **)&GvAV (PL_defgv) : &GvSV (PL_defgv);
2285 SV **dst = ix ? (SV **)&self->slot->defav : (SV **)&self->slot->defsv;
341 2286
342 /* die does this while calling POPSTACK, but I just don't see why. */ 2287 SV *tmp = *src; *src = *dst; *dst = tmp;
343 dounwind(-1); 2288 }
344 2289
345 /* is this ugly, I ask? */
346 while (PL_scopestack_ix)
347 LEAVE;
348
349 while (PL_curstackinfo->si_next)
350 PL_curstackinfo = PL_curstackinfo->si_next;
351
352 while (PL_curstackinfo)
353 {
354 PERL_SI *p = PL_curstackinfo->si_prev;
355
356 SvREFCNT_dec(PL_curstackinfo->si_stack);
357 Safefree(PL_curstackinfo->si_cxstack);
358 Safefree(PL_curstackinfo);
359 PL_curstackinfo = p;
360 }
361
362 if (PL_scopestack_ix != 0)
363 Perl_warner(aTHX_ WARN_INTERNAL,
364 "Unbalanced scopes: %ld more ENTERs than LEAVEs\n",
365 (long)PL_scopestack_ix);
366 if (PL_savestack_ix != 0)
367 Perl_warner(aTHX_ WARN_INTERNAL,
368 "Unbalanced saves: %ld more saves than restores\n",
369 (long)PL_savestack_ix);
370 if (PL_tmps_floor != -1)
371 Perl_warner(aTHX_ WARN_INTERNAL,"Unbalanced tmps: %ld more allocs than frees\n",
372 (long)PL_tmps_floor + 1);
373 /*
374 */
375 Safefree(PL_tmps_stack);
376 Safefree(PL_markstack);
377 Safefree(PL_scopestack);
378 Safefree(PL_savestack);
379 Safefree(PL_retstack);
380}
381
382#define SUB_INIT "Coro::State::_newcoro"
383
384MODULE = Coro::State PACKAGE = Coro::State 2290MODULE = Coro::State PACKAGE = Coro
385
386PROTOTYPES: ENABLE
387 2291
388BOOT: 2292BOOT:
389 if (!padlist_cache) 2293{
390 padlist_cache = newHV (); 2294 int i;
391 2295
392Coro::State 2296 av_async_pool = coro_get_av (aTHX_ "Coro::async_pool", TRUE);
393_newprocess(args) 2297 sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE);
394 SV * args 2298 sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE);
2299
2300 coro_current = coro_get_sv (aTHX_ "Coro::current", FALSE);
2301 SvREADONLY_on (coro_current);
2302
2303 coro_stash = gv_stashpv ("Coro", TRUE);
2304
2305 newCONSTSUB (coro_stash, "PRIO_MAX", newSViv (PRIO_MAX));
2306 newCONSTSUB (coro_stash, "PRIO_HIGH", newSViv (PRIO_HIGH));
2307 newCONSTSUB (coro_stash, "PRIO_NORMAL", newSViv (PRIO_NORMAL));
2308 newCONSTSUB (coro_stash, "PRIO_LOW", newSViv (PRIO_LOW));
2309 newCONSTSUB (coro_stash, "PRIO_IDLE", newSViv (PRIO_IDLE));
2310 newCONSTSUB (coro_stash, "PRIO_MIN", newSViv (PRIO_MIN));
2311
2312 for (i = PRIO_MAX - PRIO_MIN + 1; i--; )
2313 coro_ready[i] = newAV ();
2314
2315 {
2316 SV *sv = coro_get_sv (aTHX_ "Coro::API", TRUE);
2317
2318 coroapi.schedule = api_schedule;
2319 coroapi.cede = api_cede;
2320 coroapi.cede_notself = api_cede_notself;
2321 coroapi.ready = api_ready;
2322 coroapi.is_ready = api_is_ready;
2323 coroapi.nready = coro_nready;
2324 coroapi.current = coro_current;
2325
2326 GCoroAPI = &coroapi;
2327 sv_setiv (sv, (IV)&coroapi);
2328 SvREADONLY_on (sv);
2329 }
2330}
2331
2332void
2333schedule (...)
2334 CODE:
2335{
2336 static struct CoroSLF slf = { slf_init_nop, prepare_schedule, slf_check_nop };
2337 api_execute_slf (aTHX_ cv, &slf, &ST (0), items);
2338}
2339
2340void
2341cede (...)
2342 CODE:
2343{
2344 static struct CoroSLF slf = { slf_init_nop, prepare_cede, slf_check_nop };
2345 api_execute_slf (aTHX_ cv, &slf, &ST (0), items);
2346}
2347
2348void
2349cede_notself (...)
2350 CODE:
2351{
2352 static struct CoroSLF slf = { slf_init_nop, prepare_cede_notself, slf_check_nop };
2353 api_execute_slf (aTHX_ cv, &slf, &ST (0), items);
2354}
2355
2356void
2357_set_current (SV *current)
395 PROTOTYPE: $ 2358 PROTOTYPE: $
2359 CODE:
2360 SvREFCNT_dec (SvRV (coro_current));
2361 SvRV_set (coro_current, SvREFCNT_inc_NN (SvRV (current)));
2362
2363void
2364_set_readyhook (SV *hook)
2365 PROTOTYPE: $
396 CODE: 2366 CODE:
397 Coro__State coro;
398
399 if (!SvROK (args) || SvTYPE (SvRV (args)) != SVt_PVAV)
400 croak ("Coro::State::newprocess expects an arrayref");
401 2367 LOCK;
402 New (0, coro, 1, struct coro); 2368 SvREFCNT_dec (coro_readyhook);
2369 coro_readyhook = SvOK (hook) ? newSVsv (hook) : 0;
2370 UNLOCK;
403 2371
404 coro->mainstack = 0; /* actual work is done inside transfer */ 2372int
405 coro->args = (AV *)SvREFCNT_inc (SvRV (args)); 2373prio (Coro::State coro, int newprio = 0)
406 2374 ALIAS:
2375 nice = 1
2376 CODE:
2377{
407 RETVAL = coro; 2378 RETVAL = coro->prio;
408 OUTPUT: 2379
2380 if (items > 1)
2381 {
2382 if (ix)
2383 newprio = coro->prio - newprio;
2384
2385 if (newprio < PRIO_MIN) newprio = PRIO_MIN;
2386 if (newprio > PRIO_MAX) newprio = PRIO_MAX;
2387
2388 coro->prio = newprio;
2389 }
2390}
2391 OUTPUT:
409 RETVAL 2392 RETVAL
410 2393
2394SV *
2395ready (SV *self)
2396 PROTOTYPE: $
2397 CODE:
2398 RETVAL = boolSV (api_ready (aTHX_ self));
2399 OUTPUT:
2400 RETVAL
2401
2402int
2403nready (...)
2404 PROTOTYPE:
2405 CODE:
2406 RETVAL = coro_nready;
2407 OUTPUT:
2408 RETVAL
2409
2410# for async_pool speedup
411void 2411void
412transfer(prev,next) 2412_pool_1 (SV *cb)
413 Coro::State_or_hashref prev 2413 CODE:
414 Coro::State_or_hashref next 2414{
2415 struct coro *coro = SvSTATE (coro_current);
2416 HV *hv = (HV *)SvRV (coro_current);
2417 AV *defav = GvAV (PL_defgv);
2418 SV *invoke = hv_delete (hv, "_invoke", sizeof ("_invoke") - 1, 0);
2419 AV *invoke_av;
2420 int i, len;
2421
2422 if (!invoke)
2423 {
2424 SV *old = PL_diehook;
2425 PL_diehook = 0;
2426 SvREFCNT_dec (old);
2427 croak ("\3async_pool terminate\2\n");
2428 }
2429
2430 SvREFCNT_dec (coro->saved_deffh);
2431 coro->saved_deffh = SvREFCNT_inc_NN ((SV *)PL_defoutgv);
2432
2433 hv_store (hv, "desc", sizeof ("desc") - 1,
2434 newSVpvn ("[async_pool]", sizeof ("[async_pool]") - 1), 0);
2435
2436 invoke_av = (AV *)SvRV (invoke);
2437 len = av_len (invoke_av);
2438
2439 sv_setsv (cb, AvARRAY (invoke_av)[0]);
2440
2441 if (len > 0)
2442 {
2443 av_fill (defav, len - 1);
2444 for (i = 0; i < len; ++i)
2445 av_store (defav, i, SvREFCNT_inc_NN (AvARRAY (invoke_av)[i + 1]));
2446 }
2447
2448 SvREFCNT_dec (invoke);
2449}
2450
2451void
2452_pool_2 (SV *cb)
2453 CODE:
2454{
2455 struct coro *coro = SvSTATE (coro_current);
2456
2457 sv_setsv (cb, &PL_sv_undef);
2458
2459 SvREFCNT_dec ((SV *)PL_defoutgv); PL_defoutgv = (GV *)coro->saved_deffh;
2460 coro->saved_deffh = 0;
2461
2462 if (coro_rss (aTHX_ coro) > SvUV (sv_pool_rss)
2463 || av_len (av_async_pool) + 1 >= SvIV (sv_pool_size))
2464 {
2465 SV *old = PL_diehook;
2466 PL_diehook = 0;
2467 SvREFCNT_dec (old);
2468 croak ("\3async_pool terminate\2\n");
2469 }
2470
2471 av_clear (GvAV (PL_defgv));
2472 hv_store ((HV *)SvRV (coro_current), "desc", sizeof ("desc") - 1,
2473 newSVpvn ("[async_pool idle]", sizeof ("[async_pool idle]") - 1), 0);
2474
2475 coro->prio = 0;
2476
2477 if (coro->cctx && (coro->cctx->flags & CC_TRACE))
2478 api_trace (aTHX_ coro_current, 0);
2479
2480 av_push (av_async_pool, newSVsv (coro_current));
2481}
2482
2483#if 0
2484
2485void
2486_generator_call (...)
2487 PROTOTYPE: @
2488 PPCODE:
2489 fprintf (stderr, "call %p\n", CvXSUBANY(cv).any_ptr);
2490 xxxx
2491 abort ();
2492
2493SV *
2494gensub (SV *sub, ...)
2495 PROTOTYPE: &;@
415 CODE: 2496 CODE:
2497{
2498 struct coro *coro;
2499 MAGIC *mg;
2500 CV *xcv;
2501 CV *ncv = (CV *)newSV_type (SVt_PVCV);
2502 int i;
416 2503
417 if (prev != next) 2504 CvGV (ncv) = CvGV (cv);
2505 CvFILE (ncv) = CvFILE (cv);
2506
2507 Newz (0, coro, 1, struct coro);
2508 coro->args = newAV ();
2509 coro->flags = CF_NEW;
2510
2511 av_extend (coro->args, items - 1);
2512 for (i = 1; i < items; i++)
2513 av_push (coro->args, newSVsv (ST (i)));
2514
2515 CvISXSUB_on (ncv);
2516 CvXSUBANY (ncv).any_ptr = (void *)coro;
2517
2518 xcv = GvCV (gv_fetchpv ("Coro::_generator_call", 0, SVt_PVCV));
2519
2520 CvXSUB (ncv) = CvXSUB (xcv);
2521 CvANON_on (ncv);
2522
2523 mg = sv_magicext ((SV *)ncv, 0, CORO_MAGIC_type_state, &coro_gensub_vtbl, (char *)coro, 0);
2524 RETVAL = newRV_noinc ((SV *)ncv);
2525}
2526 OUTPUT:
2527 RETVAL
2528
2529#endif
2530
2531
2532MODULE = Coro::State PACKAGE = Coro::AIO
2533
2534void
2535_get_state (SV *self)
2536 PPCODE:
2537{
2538 AV *defav = GvAV (PL_defgv);
2539 AV *av = newAV ();
2540 int i;
2541 SV *data_sv = newSV (sizeof (struct io_state));
2542 struct io_state *data = (struct io_state *)SvPVX (data_sv);
2543 SvCUR_set (data_sv, sizeof (struct io_state));
2544 SvPOK_only (data_sv);
2545
2546 data->errorno = errno;
2547 data->laststype = PL_laststype;
2548 data->laststatval = PL_laststatval;
2549 data->statcache = PL_statcache;
2550
2551 av_extend (av, AvFILLp (defav) + 1 + 1);
2552
2553 for (i = 0; i <= AvFILLp (defav); ++i)
2554 av_push (av, SvREFCNT_inc_NN (AvARRAY (defav)[i]));
2555
2556 av_push (av, data_sv);
2557
2558 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
2559
2560 api_ready (aTHX_ self);
2561}
2562
2563void
2564_set_state (SV *state)
2565 PROTOTYPE: $
2566 PPCODE:
2567{
2568 AV *av = (AV *)SvRV (state);
2569 struct io_state *data = (struct io_state *)SvPVX (AvARRAY (av)[AvFILLp (av)]);
2570 int i;
2571
2572 errno = data->errorno;
2573 PL_laststype = data->laststype;
2574 PL_laststatval = data->laststatval;
2575 PL_statcache = data->statcache;
2576
2577 EXTEND (SP, AvFILLp (av));
2578 for (i = 0; i < AvFILLp (av); ++i)
2579 PUSHs (sv_2mortal (SvREFCNT_inc_NN (AvARRAY (av)[i])));
2580}
2581
2582
2583MODULE = Coro::State PACKAGE = Coro::AnyEvent
2584
2585BOOT:
2586 sv_activity = coro_get_sv (aTHX_ "Coro::AnyEvent::ACTIVITY", TRUE);
2587
2588SV *
2589_schedule (...)
2590 PROTOTYPE: @
2591 CODE:
2592{
2593 static int incede;
2594
2595 api_cede_notself (aTHX);
2596
2597 ++incede;
2598 while (coro_nready >= incede && api_cede (aTHX))
2599 ;
2600
2601 sv_setsv (sv_activity, &PL_sv_undef);
2602 if (coro_nready >= incede)
418 { 2603 {
2604 PUSHMARK (SP);
419 PUTBACK; 2605 PUTBACK;
420 SAVE (aTHX_ prev); 2606 call_pv ("Coro::AnyEvent::_activity", G_DISCARD | G_EVAL);
421
422 /*
423 * this could be done in newprocess which would lead to
424 * extremely elegant and fast (just PUTBACK/SAVE/LOAD/SPAGAIN)
425 * code here, but lazy allocation of stacks has also
426 * some virtues and the overhead of the if() is nil.
427 */
428 if (next->mainstack)
429 {
430 LOAD (aTHX_ next);
431 next->mainstack = 0; /* unnecessary but much cleaner */
432 SPAGAIN;
433 }
434 else
435 {
436 /*
437 * emulate part of the perl startup here.
438 */
439 UNOP myop;
440
441 init_stacks (); /* from perl.c */
442 PL_op = (OP *)&myop;
443 /*PL_curcop = 0;*/
444 GvAV (PL_defgv) = (SV *)SvREFCNT_inc (next->args);
445
446 SPAGAIN;
447 Zero(&myop, 1, UNOP);
448 myop.op_next = Nullop;
449 myop.op_flags = OPf_WANT_VOID;
450
451 PUSHMARK(SP);
452 XPUSHs ((SV*)get_cv(SUB_INIT, TRUE));
453 PUTBACK;
454 /*
455 * the next line is slightly wrong, as PL_op->op_next
456 * is actually being executed so we skip the first op.
457 * that doesn't matter, though, since it is only
458 * pp_nextstate and we never return...
459 */
460 PL_op = Perl_pp_entersub(aTHX);
461 SPAGAIN;
462
463 ENTER;
464 }
465 }
466
467void
468DESTROY(coro)
469 Coro::State coro
470 CODE:
471
472 if (coro->mainstack)
473 {
474 struct coro temp;
475
476 PUTBACK;
477 SAVE(aTHX_ (&temp));
478 LOAD(aTHX_ coro);
479
480 destroy_stacks ();
481 SvREFCNT_dec ((SV *)GvAV (PL_defgv));
482
483 LOAD((&temp));
484 SPAGAIN; 2607 SPAGAIN;
485 } 2608 }
486 2609
487 SvREFCNT_dec (coro->args); 2610 --incede;
488 Safefree (coro); 2611}
489 2612
490 2613
2614MODULE = Coro::State PACKAGE = PerlIO::cede
2615
2616BOOT:
2617 PerlIO_define_layer (aTHX_ &PerlIO_cede);
2618

Diff Legend

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