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

Diff Legend

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