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

Comparing Coro/Coro/State.xs (file contents):
Revision 1.5 by root, Tue Jul 17 02:55:29 2001 UTC vs.
Revision 1.438 by root, Mon Nov 18 10:27:53 2013 UTC

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

Diff Legend

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