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

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

Diff Legend

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