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

Diff Legend

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