ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/Coro/Coro/State.xs

Comparing Coro/Coro/State.xs (file contents):
Revision 1.386 by root, Sat Feb 19 06:51:23 2011 UTC vs.
Revision 1.404 by root, Fri Jun 10 12:27:02 2011 UTC

…		…
12	#include "perl.h"	12	#include "perl.h"
13	#include "XSUB.h"	13	#include "XSUB.h"
14	#include "perliol.h"	14	#include "perliol.h"
15		15
16	#include "schmorp.h"	16	#include "schmorp.h"
		17	#include "ecb.h"
17		18
		19	#include <stddef.h>
18	#include <stdio.h>	20	#include <stdio.h>
19	#include <errno.h>	21	#include <errno.h>
20	#include <assert.h>	22	#include <assert.h>
21		23
22	#ifndef SVs_PADSTALE	24	#ifndef SVs_PADSTALE
23	# define SVs_PADSTALE 0	25	# define SVs_PADSTALE 0
24	#endif	26	#endif
25		27
26	#ifdef WIN32	28	#if defined(_WIN32)
		29	# undef HAS_GETTIMEOFDAY
27	# undef setjmp	30	# undef setjmp
28	# undef longjmp	31	# undef longjmp
29	# undef _exit	32	# undef _exit
30	# define setjmp _setjmp /* deep magic */	33	# define setjmp _setjmp /* deep magic */
31	#else	34	#else
…		…
85	# define STACKLEVEL ((void *)&stacklevel)	88	# define STACKLEVEL ((void *)&stacklevel)
86	#endif	89	#endif
87		90
88	#define IN_DESTRUCT PL_dirty	91	#define IN_DESTRUCT PL_dirty
89		92
90	#if __GNUC__ >= 3
91	# define attribute(x) __attribute__(x)
92	# define expect(expr,value) __builtin_expect ((expr), (value))
93	# define INLINE static inline
94	#else
95	# define attribute(x)
96	# define expect(expr,value) (expr)
97	# define INLINE static
98	#endif
99
100	#define expect_false(expr) expect ((expr) != 0, 0)
101	#define expect_true(expr) expect ((expr) != 0, 1)
102
103	#define NOINLINE attribute ((noinline))
104
105	#include "CoroAPI.h"	93	#include "CoroAPI.h"
106	#define GCoroAPI (&coroapi) /* very sneaky */	94	#define GCoroAPI (&coroapi) /* very sneaky */
107		95
108	#ifdef USE_ITHREADS	96	#ifdef USE_ITHREADS
109	# if CORO_PTHREAD	97	# if CORO_PTHREAD
…		…
125	static void (*u2time)(pTHX_ UV ret[2]);	113	static void (*u2time)(pTHX_ UV ret[2]);
126		114
127	/* we hijack an hopefully unused CV flag for our purposes */	115	/* we hijack an hopefully unused CV flag for our purposes */
128	#define CVf_SLF 0x4000	116	#define CVf_SLF 0x4000
129	static OP *pp_slf (pTHX);	117	static OP *pp_slf (pTHX);
		118	static void slf_destroy (pTHX_ struct coro *coro);
130		119
131	static U32 cctx_gen;	120	static U32 cctx_gen;
132	static size_t cctx_stacksize = CORO_STACKSIZE;	121	static size_t cctx_stacksize = CORO_STACKSIZE;
133	static struct CoroAPI coroapi;	122	static struct CoroAPI coroapi;
134	static AV *main_mainstack; /* used to differentiate between $main and others */	123	static AV *main_mainstack; /* used to differentiate between $main and others */
…		…
164	static char times_valid;	153	static char times_valid;
165		154
166	static struct coro_cctx *cctx_first;	155	static struct coro_cctx *cctx_first;
167	static int cctx_count, cctx_idle;	156	static int cctx_count, cctx_idle;
168		157
169	enum {	158	enum
		159	{
170	CC_MAPPED = 0x01,	160	CC_MAPPED = 0x01,
171	CC_NOREUSE = 0x02, /* throw this away after tracing */	161	CC_NOREUSE = 0x02, /* throw this away after tracing */
172	CC_TRACE = 0x04,	162	CC_TRACE = 0x04,
173	CC_TRACE_SUB = 0x08, /* trace sub calls */	163	CC_TRACE_SUB = 0x08, /* trace sub calls */
174	CC_TRACE_LINE = 0x10, /* trace each statement */	164	CC_TRACE_LINE = 0x10, /* trace each statement */
…		…
195	int valgrind_id;	185	int valgrind_id;
196	#endif	186	#endif
197	unsigned char flags;	187	unsigned char flags;
198	} coro_cctx;	188	} coro_cctx;
199		189
200	coro_cctx *cctx_current; /* the currently running cctx */	190	static coro_cctx *cctx_current; /* the currently running cctx */
201		191
202	/*****************************************************************************/	192	/*****************************************************************************/
203		193
		194	static MGVTBL coro_state_vtbl;
		195
204	enum {	196	enum
		197	{
205	CF_RUNNING = 0x0001, /* coroutine is running */	198	CF_RUNNING = 0x0001, /* coroutine is running */
206	CF_READY = 0x0002, /* coroutine is ready */	199	CF_READY = 0x0002, /* coroutine is ready */
207	CF_NEW = 0x0004, /* has never been switched to */	200	CF_NEW = 0x0004, /* has never been switched to */
208	CF_DESTROYED = 0x0008, /* coroutine data has been freed */	201	CF_ZOMBIE = 0x0008, /* coroutine data has been freed */
209	CF_SUSPENDED = 0x0010, /* coroutine can't be scheduled */	202	CF_SUSPENDED = 0x0010, /* coroutine can't be scheduled */
		203	CF_NOCANCEL = 0x0020, /* cannot cancel, set slf_frame.data to 1 (hackish) */
210	};	204	};
211		205
212	/* the structure where most of the perl state is stored, overlaid on the cxstack */	206	/* the structure where most of the perl state is stored, overlaid on the cxstack */
213	typedef struct	207	typedef struct
214	{	208	{
…		…
220	#define VAR(name,type) type name;	214	#define VAR(name,type) type name;
221	# include "state.h"	215	# include "state.h"
222	#undef VAR	216	#undef VAR
223	} perl_slots;	217	} perl_slots;
224		218
		219	// how many context stack entries do we need for perl_slots
225	#define SLOT_COUNT ((sizeof (perl_slots) + sizeof (PERL_CONTEXT) - 1) / sizeof (PERL_CONTEXT))	220	#define SLOT_COUNT ((sizeof (perl_slots) + sizeof (PERL_CONTEXT) - 1) / sizeof (PERL_CONTEXT))
226		221
227	/* this is a structure representing a perl-level coroutine */	222	/* this is a structure representing a perl-level coroutine */
228	struct coro {	223	struct coro
		224	{
229	/* the C coroutine allocated to this perl coroutine, if any */	225	/* the C coroutine allocated to this perl coroutine, if any */
230	coro_cctx *cctx;	226	coro_cctx *cctx;
231		227
232	/* ready queue */	228	/* ready queue */
233	struct coro *next_ready;	229	struct coro *next_ready;
…		…
235	/* state data */	231	/* state data */
236	struct CoroSLF slf_frame; /* saved slf frame */	232	struct CoroSLF slf_frame; /* saved slf frame */
237	AV *mainstack;	233	AV *mainstack;
238	perl_slots *slot; /* basically the saved sp */	234	perl_slots *slot; /* basically the saved sp */
239		235
240	CV *startcv; /* the CV to execute */	236	CV *startcv; /* the CV to execute */
241	AV *args; /* data associated with this coroutine (initial args) */	237	AV *args; /* data associated with this coroutine (initial args) */
242	int refcnt; /* coroutines are refcounted, yes */
243	int flags; /* CF_ flags */	238	int flags; /* CF_ flags */
244	HV *hv; /* the perl hash associated with this coro, if any */	239	HV *hv; /* the perl hash associated with this coro, if any */
245	void (*on_destroy)(pTHX_ struct coro *coro); /* for temporary use by xs in critical sections */
246		240
247	/* statistics */	241	/* statistics */
248	int usecount; /* number of transfers to this coro */	242	int usecount; /* number of transfers to this coro */
249		243
250	/* coro process data */	244	/* coro process data */
251	int prio;	245	int prio;
252	SV *except; /* exception to be thrown */	246	SV *except; /* exception to be thrown */
253	SV *rouse_cb;	247	SV *rouse_cb; /* last rouse callback */
		248	AV *on_destroy; /* callbacks or coros to notify on destroy */
		249	AV *status; /* the exit status list */
254		250
255	/* async_pool */	251	/* async_pool */
256	SV *saved_deffh;	252	SV *saved_deffh;
257	SV *invoke_cb;	253	SV *invoke_cb;
258	AV *invoke_av;	254	AV *invoke_av;
…		…
274	typedef struct coro *Coro__State;	270	typedef struct coro *Coro__State;
275	typedef struct coro *Coro__State_or_hashref;	271	typedef struct coro *Coro__State_or_hashref;
276		272
277	/* the following variables are effectively part of the perl context */	273	/* the following variables are effectively part of the perl context */
278	/* and get copied between struct coro and these variables */	274	/* and get copied between struct coro and these variables */
279	/* the mainr easonw e don't support windows process emulation */	275	/* the main reason we don't support windows process emulation */
280	static struct CoroSLF slf_frame; /* the current slf frame */	276	static struct CoroSLF slf_frame; /* the current slf frame */
281		277
282	/** Coro ********************************************************************/	278	/** Coro ********************************************************************/
283		279
284	#define CORO_PRIO_MAX 3	280	#define CORO_PRIO_MAX 3
…		…
290		286
291	/* for Coro.pm */	287	/* for Coro.pm */
292	static SV *coro_current;	288	static SV *coro_current;
293	static SV *coro_readyhook;	289	static SV *coro_readyhook;
294	static struct coro *coro_ready [CORO_PRIO_MAX - CORO_PRIO_MIN + 1][2]; /* head|tail */	290	static struct coro *coro_ready [CORO_PRIO_MAX - CORO_PRIO_MIN + 1][2]; /* head|tail */
295	static CV *cv_coro_run, *cv_coro_terminate;	291	static CV *cv_coro_run;
296	static struct coro *coro_first;	292	static struct coro *coro_first;
297	#define coro_nready coroapi.nready	293	#define coro_nready coroapi.nready
298		294
299	/** Coro::Select ************************************************************/	295	/** Coro::Select ************************************************************/
300		296
…		…
318		314
319	/** time stuff **************************************************************/	315	/** time stuff **************************************************************/
320		316
321	#ifdef HAS_GETTIMEOFDAY	317	#ifdef HAS_GETTIMEOFDAY
322		318
323	static void	319	ECB_INLINE void
324	coro_u2time (aTHX_ UV ret[2])	320	coro_u2time (pTHX_ UV ret[2])
325	{	321	{
326	struct timeval tv;	322	struct timeval tv;
327	gettimeofday (&tv, 0);	323	gettimeofday (&tv, 0);
328		324
329	ret [0] = tv.tv_sec;	325	ret [0] = tv.tv_sec;
330	ret [1] = tv.tv_usec;	326	ret [1] = tv.tv_usec;
331	}	327	}
332		328
333	static double	329	ECB_INLINE double
334	coro_nvtime ()	330	coro_nvtime ()
335	{	331	{
336	struct timeval tv;	332	struct timeval tv;
337	gettimeofday (&tv, 0);	333	gettimeofday (&tv, 0);
338		334
339	return tv.tv_sec + tv.tv_usec * 1e-6;	335	return tv.tv_sec + tv.tv_usec * 1e-6;
340	}	336	}
341		337
342	static void	338	ECB_INLINE void
343	time_init (void)	339	time_init (pTHX)
344	{	340	{
345	nvtime = coro_nvtime;	341	nvtime = coro_nvtime;
346	u2time = coro_u2time;	342	u2time = coro_u2time;
347	}	343	}
348		344
349	#else	345	#else
350		346
351	static void	347	ECB_INLINE void
352	time_init (void)	348	time_init (pTHX)
353	{	349	{
354	SV **svp;	350	SV **svp;
355		351
356	require_pv ("Time::HiRes");	352	require_pv ("Time/HiRes.pm");
357		353
358	svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);	354	svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
359		355
360	if (!svp) croak ("Time::HiRes is required");	356	if (!svp) croak ("Time::HiRes is required, but missing. Caught");
361	if (!SvIOK (*svp)) croak ("Time::NVtime isn't a function pointer");	357	if (!SvIOK (*svp)) croak ("Time::NVtime isn't a function pointer. Caught");
362		358
363	nvtime = INT2PTR (double (*)(), SvIV (*svp));	359	nvtime = INT2PTR (double (*)(), SvIV (*svp));
364		360
365	svp = hv_fetch (PL_modglobal, "Time::U2time", 12, 0);	361	svp = hv_fetch (PL_modglobal, "Time::U2time", 12, 0);
366	u2time = INT2PTR (void (*)(pTHX_ UV ret[2]), SvIV (*svp));	362	u2time = INT2PTR (void (*)(pTHX_ UV ret[2]), SvIV (*svp));
…		…
368		364
369	#endif	365	#endif
370		366
371	/** lowlevel stuff **********************************************************/	367	/** lowlevel stuff **********************************************************/
372		368
373	static SV *	369	static SV * ecb_noinline
374	coro_get_sv (pTHX_ const char *name, int create)	370	coro_get_sv (pTHX_ const char *name, int create)
375	{	371	{
376	#if PERL_VERSION_ATLEAST (5,10,0)	372	#if PERL_VERSION_ATLEAST (5,10,0)
377	/* silence stupid and wrong 5.10 warning that I am unable to switch off */	373	/* silence stupid and wrong 5.10 warning that I am unable to switch off */
378	get_sv (name, create);	374	get_sv (name, create);
379	#endif	375	#endif
380	return get_sv (name, create);	376	return get_sv (name, create);
381	}	377	}
382		378
383	static AV *	379	static AV * ecb_noinline
384	coro_get_av (pTHX_ const char *name, int create)	380	coro_get_av (pTHX_ const char *name, int create)
385	{	381	{
386	#if PERL_VERSION_ATLEAST (5,10,0)	382	#if PERL_VERSION_ATLEAST (5,10,0)
387	/* silence stupid and wrong 5.10 warning that I am unable to switch off */	383	/* silence stupid and wrong 5.10 warning that I am unable to switch off */
388	get_av (name, create);	384	get_av (name, create);
389	#endif	385	#endif
390	return get_av (name, create);	386	return get_av (name, create);
391	}	387	}
392		388
393	static HV *	389	static HV * ecb_noinline
394	coro_get_hv (pTHX_ const char *name, int create)	390	coro_get_hv (pTHX_ const char *name, int create)
395	{	391	{
396	#if PERL_VERSION_ATLEAST (5,10,0)	392	#if PERL_VERSION_ATLEAST (5,10,0)
397	/* silence stupid and wrong 5.10 warning that I am unable to switch off */	393	/* silence stupid and wrong 5.10 warning that I am unable to switch off */
398	get_hv (name, create);	394	get_hv (name, create);
399	#endif	395	#endif
400	return get_hv (name, create);	396	return get_hv (name, create);
401	}	397	}
402		398
403	INLINE void	399	ECB_INLINE void
404	coro_times_update ()	400	coro_times_update ()
405	{	401	{
406	#ifdef coro_clock_gettime	402	#ifdef coro_clock_gettime
407	struct timespec ts;	403	struct timespec ts;
408		404
…		…
421	time_real [0] = tv [0];	417	time_real [0] = tv [0];
422	time_real [1] = tv [1] * 1000;	418	time_real [1] = tv [1] * 1000;
423	#endif	419	#endif
424	}	420	}
425		421
426	INLINE void	422	ECB_INLINE void
427	coro_times_add (struct coro *c)	423	coro_times_add (struct coro *c)
428	{	424	{
429	c->t_real [1] += time_real [1];	425	c->t_real [1] += time_real [1];
430	if (c->t_real [1] > 1000000000) { c->t_real [1] -= 1000000000; ++c->t_real [0]; }	426	if (c->t_real [1] > 1000000000) { c->t_real [1] -= 1000000000; ++c->t_real [0]; }
431	c->t_real [0] += time_real [0];	427	c->t_real [0] += time_real [0];
…		…
433	c->t_cpu [1] += time_cpu [1];	429	c->t_cpu [1] += time_cpu [1];
434	if (c->t_cpu [1] > 1000000000) { c->t_cpu [1] -= 1000000000; ++c->t_cpu [0]; }	430	if (c->t_cpu [1] > 1000000000) { c->t_cpu [1] -= 1000000000; ++c->t_cpu [0]; }
435	c->t_cpu [0] += time_cpu [0];	431	c->t_cpu [0] += time_cpu [0];
436	}	432	}
437		433
438	INLINE void	434	ECB_INLINE void
439	coro_times_sub (struct coro *c)	435	coro_times_sub (struct coro *c)
440	{	436	{
441	if (c->t_real [1] < time_real [1]) { c->t_real [1] += 1000000000; --c->t_real [0]; }	437	if (c->t_real [1] < time_real [1]) { c->t_real [1] += 1000000000; --c->t_real [0]; }
442	c->t_real [1] -= time_real [1];	438	c->t_real [1] -= time_real [1];
443	c->t_real [0] -= time_real [0];	439	c->t_real [0] -= time_real [0];
…		…
451	/* magic glue */	447	/* magic glue */
452		448
453	#define CORO_MAGIC_type_cv 26	449	#define CORO_MAGIC_type_cv 26
454	#define CORO_MAGIC_type_state PERL_MAGIC_ext	450	#define CORO_MAGIC_type_state PERL_MAGIC_ext
455		451
456	#define CORO_MAGIC_NN(sv, type) \	452	#define CORO_MAGIC_NN(sv, type) \
457	(expect_true (SvMAGIC (sv)->mg_type == type) \	453	(ecb_expect_true (SvMAGIC (sv)->mg_type == type) \
458	? SvMAGIC (sv) \	454	? SvMAGIC (sv) \
459	: mg_find (sv, type))	455	: mg_find (sv, type))
460		456
461	#define CORO_MAGIC(sv, type) \	457	#define CORO_MAGIC(sv, type) \
462	(expect_true (SvMAGIC (sv)) \	458	(ecb_expect_true (SvMAGIC (sv)) \
463	? CORO_MAGIC_NN (sv, type) \	459	? CORO_MAGIC_NN (sv, type) \
464	: 0)	460	: 0)
465		461
466	#define CORO_MAGIC_cv(cv) CORO_MAGIC (((SV *)(cv)), CORO_MAGIC_type_cv)	462	#define CORO_MAGIC_cv(cv) CORO_MAGIC (((SV *)(cv)), CORO_MAGIC_type_cv)
467	#define CORO_MAGIC_state(sv) CORO_MAGIC_NN (((SV *)(sv)), CORO_MAGIC_type_state)	463	#define CORO_MAGIC_state(sv) CORO_MAGIC_NN (((SV *)(sv)), CORO_MAGIC_type_state)
468		464
		465	ECB_INLINE MAGIC *
		466	SvSTATEhv_p (pTHX_ SV *coro)
		467	{
		468	MAGIC *mg;
		469
		470	if (ecb_expect_true (
		471	SvTYPE (coro) == SVt_PVHV
		472	&& (mg = CORO_MAGIC_state (coro))
		473	&& mg->mg_virtual == &coro_state_vtbl
		474	))
		475	return mg;
		476
		477	return 0;
		478	}
		479
469	INLINE struct coro *	480	ECB_INLINE struct coro *
470	SvSTATE_ (pTHX_ SV *coro)	481	SvSTATE_ (pTHX_ SV *coro)
471	{	482	{
472	HV *stash;
473	MAGIC *mg;	483	MAGIC *mg;
474		484
475	if (SvROK (coro))	485	if (SvROK (coro))
476	coro = SvRV (coro);	486	coro = SvRV (coro);
477		487
478	if (expect_false (SvTYPE (coro) != SVt_PVHV))	488	mg = SvSTATEhv_p (aTHX_ coro);
		489	if (!mg)
479	croak ("Coro::State object required");	490	croak ("Coro::State object required");
480		491
481	stash = SvSTASH (coro);
482	if (expect_false (stash != coro_stash && stash != coro_state_stash))
483	{
484	/* very slow, but rare, check */
485	if (!sv_derived_from (sv_2mortal (newRV_inc (coro)), "Coro::State"))
486	croak ("Coro::State object required");
487	}
488
489	mg = CORO_MAGIC_state (coro);
490	return (struct coro *)mg->mg_ptr;	492	return (struct coro *)mg->mg_ptr;
491	}	493	}
492		494
493	#define SvSTATE(sv) SvSTATE_ (aTHX_ (sv))	495	#define SvSTATE(sv) SvSTATE_ (aTHX_ (sv))
494		496
…		…
497	#define SvSTATE_current SvSTATE_hv (SvRV (coro_current))	499	#define SvSTATE_current SvSTATE_hv (SvRV (coro_current))
498		500
499	/*****************************************************************************/	501	/*****************************************************************************/
500	/* padlist management and caching */	502	/* padlist management and caching */
501		503
502	static AV *	504	ECB_INLINE AV *
503	coro_derive_padlist (pTHX_ CV *cv)	505	coro_derive_padlist (pTHX_ CV *cv)
504	{	506	{
505	AV *padlist = CvPADLIST (cv);	507	AV *padlist = CvPADLIST (cv);
506	AV *newpadlist, *newpad;	508	AV *newpadlist, *newpad;
507		509
…		…
519	av_store (newpadlist, 1, (SV *)newpad);	521	av_store (newpadlist, 1, (SV *)newpad);
520		522
521	return newpadlist;	523	return newpadlist;
522	}	524	}
523		525
524	static void	526	ECB_INLINE void
525	free_padlist (pTHX_ AV *padlist)	527	free_padlist (pTHX_ AV *padlist)
526	{	528	{
527	/* may be during global destruction */	529	/* may be during global destruction */
528	if (!IN_DESTRUCT)	530	if (!IN_DESTRUCT)
529	{	531	{
…		…
572	0, 0, 0, 0,	574	0, 0, 0, 0,
573	coro_cv_free	575	coro_cv_free
574	};	576	};
575		577
576	/* the next two functions merely cache the padlists */	578	/* the next two functions merely cache the padlists */
577	static void	579	ECB_INLINE void
578	get_padlist (pTHX_ CV *cv)	580	get_padlist (pTHX_ CV *cv)
579	{	581	{
580	MAGIC *mg = CORO_MAGIC_cv (cv);	582	MAGIC *mg = CORO_MAGIC_cv (cv);
581	AV *av;	583	AV *av;
582		584
583	if (expect_true (mg && AvFILLp ((av = (AV *)mg->mg_obj)) >= 0))	585	if (ecb_expect_true (mg && AvFILLp ((av = (AV *)mg->mg_obj)) >= 0))
584	CvPADLIST (cv) = (AV *)AvARRAY (av)[AvFILLp (av)--];	586	CvPADLIST (cv) = (AV *)AvARRAY (av)[AvFILLp (av)--];
585	else	587	else
586	{	588	{
587	#if CORO_PREFER_PERL_FUNCTIONS	589	#if CORO_PREFER_PERL_FUNCTIONS
588	/* this is probably cleaner? but also slower! */	590	/* this is probably cleaner? but also slower! */
…		…
595	CvPADLIST (cv) = coro_derive_padlist (aTHX_ cv);	597	CvPADLIST (cv) = coro_derive_padlist (aTHX_ cv);
596	#endif	598	#endif
597	}	599	}
598	}	600	}
599		601
600	static void	602	ECB_INLINE void
601	put_padlist (pTHX_ CV *cv)	603	put_padlist (pTHX_ CV *cv)
602	{	604	{
603	MAGIC *mg = CORO_MAGIC_cv (cv);	605	MAGIC *mg = CORO_MAGIC_cv (cv);
604	AV *av;	606	AV *av;
605		607
606	if (expect_false (!mg))	608	if (ecb_expect_false (!mg))
607	mg = sv_magicext ((SV *)cv, (SV *)newAV (), CORO_MAGIC_type_cv, &coro_cv_vtbl, 0, 0);	609	mg = sv_magicext ((SV *)cv, (SV *)newAV (), CORO_MAGIC_type_cv, &coro_cv_vtbl, 0, 0);
608		610
609	av = (AV *)mg->mg_obj;	611	av = (AV *)mg->mg_obj;
610		612
611	if (expect_false (AvFILLp (av) >= AvMAX (av)))	613	if (ecb_expect_false (AvFILLp (av) >= AvMAX (av)))
612	av_extend (av, AvFILLp (av) + 1);	614	av_extend (av, AvFILLp (av) + 1);
613		615
614	AvARRAY (av)[++AvFILLp (av)] = (SV *)CvPADLIST (cv);	616	AvARRAY (av)[++AvFILLp (av)] = (SV *)CvPADLIST (cv);
615	}	617	}
616		618
…		…
661	}	663	}
662	#endif	664	#endif
663	}	665	}
664	}	666	}
665		667
666	#define SWAP_SVS(coro) \	668	#define SWAP_SVS(coro) \
667	if (expect_false ((coro)->swap_sv)) \	669	if (ecb_expect_false ((coro)->swap_sv)) \
668	swap_svs (aTHX_ (coro))	670	swap_svs (aTHX_ (coro))
669		671
670	static void	672	static void
671	on_enterleave_call (pTHX_ SV *cb);	673	on_enterleave_call (pTHX_ SV *cb);
672		674
…		…
692	dSP;	694	dSP;
693		695
694	CV *cv;	696	CV *cv;
695		697
696	/* now do the ugly restore mess */	698	/* now do the ugly restore mess */
697	while (expect_true (cv = (CV *)POPs))	699	while (ecb_expect_true (cv = (CV *)POPs))
698	{	700	{
699	put_padlist (aTHX_ cv); /* mark this padlist as available */	701	put_padlist (aTHX_ cv); /* mark this padlist as available */
700	CvDEPTH (cv) = PTR2IV (POPs);	702	CvDEPTH (cv) = PTR2IV (POPs);
701	CvPADLIST (cv) = (AV *)POPs;	703	CvPADLIST (cv) = (AV *)POPs;
702	}	704	}
…		…
705	}	707	}
706		708
707	slf_frame = c->slf_frame;	709	slf_frame = c->slf_frame;
708	CORO_THROW = c->except;	710	CORO_THROW = c->except;
709		711
710	if (expect_false (enable_times))	712	if (ecb_expect_false (enable_times))
711	{	713	{
712	if (expect_false (!times_valid))	714	if (ecb_expect_false (!times_valid))
713	coro_times_update ();	715	coro_times_update ();
714		716
715	coro_times_sub (c);	717	coro_times_sub (c);
716	}	718	}
717		719
718	if (expect_false (c->on_enter))	720	if (ecb_expect_false (c->on_enter))
719	{	721	{
720	int i;	722	int i;
721		723
722	for (i = 0; i <= AvFILLp (c->on_enter); ++i)	724	for (i = 0; i <= AvFILLp (c->on_enter); ++i)
723	on_enterleave_call (aTHX_ AvARRAY (c->on_enter)[i]);	725	on_enterleave_call (aTHX_ AvARRAY (c->on_enter)[i]);
…		…
729	static void	731	static void
730	save_perl (pTHX_ Coro__State c)	732	save_perl (pTHX_ Coro__State c)
731	{	733	{
732	SWAP_SVS (c);	734	SWAP_SVS (c);
733		735
734	if (expect_false (c->on_leave))	736	if (ecb_expect_false (c->on_leave))
735	{	737	{
736	int i;	738	int i;
737		739
738	for (i = AvFILLp (c->on_leave); i >= 0; --i)	740	for (i = AvFILLp (c->on_leave); i >= 0; --i)
739	on_enterleave_call (aTHX_ AvARRAY (c->on_leave)[i]);	741	on_enterleave_call (aTHX_ AvARRAY (c->on_leave)[i]);
740	}	742	}
741		743
742	times_valid = 0;	744	times_valid = 0;
743		745
744	if (expect_false (enable_times))	746	if (ecb_expect_false (enable_times))
745	{	747	{
746	coro_times_update (); times_valid = 1;	748	coro_times_update (); times_valid = 1;
747	coro_times_add (c);	749	coro_times_add (c);
748	}	750	}
749		751
…		…
763		765
764	XPUSHs (Nullsv);	766	XPUSHs (Nullsv);
765	/* this loop was inspired by pp_caller */	767	/* this loop was inspired by pp_caller */
766	for (;;)	768	for (;;)
767	{	769	{
768	while (expect_true (cxix >= 0))	770	while (ecb_expect_true (cxix >= 0))
769	{	771	{
770	PERL_CONTEXT *cx = &ccstk[cxix--];	772	PERL_CONTEXT *cx = &ccstk[cxix--];
771		773
772	if (expect_true (CxTYPE (cx) == CXt_SUB) || expect_false (CxTYPE (cx) == CXt_FORMAT))	774	if (ecb_expect_true (CxTYPE (cx) == CXt_SUB) || ecb_expect_false (CxTYPE (cx) == CXt_FORMAT))
773	{	775	{
774	CV *cv = cx->blk_sub.cv;	776	CV *cv = cx->blk_sub.cv;
775		777
776	if (expect_true (CvDEPTH (cv)))	778	if (ecb_expect_true (CvDEPTH (cv)))
777	{	779	{
778	EXTEND (SP, 3);	780	EXTEND (SP, 3);
779	PUSHs ((SV *)CvPADLIST (cv));	781	PUSHs ((SV *)CvPADLIST (cv));
780	PUSHs (INT2PTR (SV *, (IV)CvDEPTH (cv)));	782	PUSHs (INT2PTR (SV *, (IV)CvDEPTH (cv)));
781	PUSHs ((SV *)cv);	783	PUSHs ((SV *)cv);
…		…
784	get_padlist (aTHX_ cv);	786	get_padlist (aTHX_ cv);
785	}	787	}
786	}	788	}
787	}	789	}
788		790
789	if (expect_true (top_si->si_type == PERLSI_MAIN))	791	if (ecb_expect_true (top_si->si_type == PERLSI_MAIN))
790	break;	792	break;
791		793
792	top_si = top_si->si_prev;	794	top_si = top_si->si_prev;
793	ccstk = top_si->si_cxstack;	795	ccstk = top_si->si_cxstack;
794	cxix = top_si->si_cxix;	796	cxix = top_si->si_cxix;
…		…
796		798
797	PUTBACK;	799	PUTBACK;
798	}	800	}
799		801
800	/* allocate some space on the context stack for our purposes */	802	/* allocate some space on the context stack for our purposes */
801	/* we manually unroll here, as usually 2 slots is enough */	803	if (ecb_expect_false (cxstack_ix + SLOT_COUNT >= cxstack_max))
802	if (SLOT_COUNT >= 1) CXINC;
803	if (SLOT_COUNT >= 2) CXINC;
804	if (SLOT_COUNT >= 3) CXINC;
805	{	804	{
806	unsigned int i;	805	unsigned int i;
		806
807	for (i = 3; i < SLOT_COUNT; ++i)	807	for (i = 0; i < SLOT_COUNT; ++i)
808	CXINC;	808	CXINC;
809	}	809
810	cxstack_ix -= SLOT_COUNT; /* undo allocation */	810	cxstack_ix -= SLOT_COUNT; /* undo allocation */
		811	}
811		812
812	c->mainstack = PL_mainstack;	813	c->mainstack = PL_mainstack;
813		814
814	{	815	{
815	perl_slots *slot = c->slot = (perl_slots *)(cxstack + cxstack_ix + 1);	816	perl_slots *slot = c->slot = (perl_slots *)(cxstack + cxstack_ix + 1);
…		…
836	# define coro_init_stacks(thx) init_stacks ()	837	# define coro_init_stacks(thx) init_stacks ()
837	#else	838	#else
838	static void	839	static void
839	coro_init_stacks (pTHX)	840	coro_init_stacks (pTHX)
840	{	841	{
841	PL_curstackinfo = new_stackinfo(32, 8);	842	PL_curstackinfo = new_stackinfo(32, 4 + SLOT_COUNT); /* 3 is minimum due to perl rounding down in scope.c:GROW() */
842	PL_curstackinfo->si_type = PERLSI_MAIN;	843	PL_curstackinfo->si_type = PERLSI_MAIN;
843	PL_curstack = PL_curstackinfo->si_stack;	844	PL_curstack = PL_curstackinfo->si_stack;
844	PL_mainstack = PL_curstack; /* remember in case we switch stacks */	845	PL_mainstack = PL_curstack; /* remember in case we switch stacks */
845		846
846	PL_stack_base = AvARRAY(PL_curstack);	847	PL_stack_base = AvARRAY(PL_curstack);
…		…
953	#endif	954	#endif
954		955
955	/*	956	/*
956	* This overrides the default magic get method of %SIG elements.	957	* This overrides the default magic get method of %SIG elements.
957	* The original one doesn't provide for reading back of PL_diehook/PL_warnhook	958	* The original one doesn't provide for reading back of PL_diehook/PL_warnhook
958	* and instead of trying to save and restore the hash elements, we just provide	959	* and instead of trying to save and restore the hash elements (extremely slow),
959	* readback here.	960	* we just provide our own readback here.
960	*/	961	*/
961	static int	962	static int ecb_cold
962	coro_sigelem_get (pTHX_ SV *sv, MAGIC *mg)	963	coro_sigelem_get (pTHX_ SV *sv, MAGIC *mg)
963	{	964	{
964	const char *s = MgPV_nolen_const (mg);	965	const char *s = MgPV_nolen_const (mg);
965		966
966	if (*s == '_')	967	if (*s == '_')
…		…
978	}	979	}
979		980
980	return orig_sigelem_get ? orig_sigelem_get (aTHX_ sv, mg) : 0;	981	return orig_sigelem_get ? orig_sigelem_get (aTHX_ sv, mg) : 0;
981	}	982	}
982		983
983	static int	984	static int ecb_cold
984	coro_sigelem_clr (pTHX_ SV *sv, MAGIC *mg)	985	coro_sigelem_clr (pTHX_ SV *sv, MAGIC *mg)
985	{	986	{
986	const char *s = MgPV_nolen_const (mg);	987	const char *s = MgPV_nolen_const (mg);
987		988
988	if (*s == '_')	989	if (*s == '_')
…		…
1002	}	1003	}
1003		1004
1004	return orig_sigelem_clr ? orig_sigelem_clr (aTHX_ sv, mg) : 0;	1005	return orig_sigelem_clr ? orig_sigelem_clr (aTHX_ sv, mg) : 0;
1005	}	1006	}
1006		1007
1007	static int	1008	static int ecb_cold
1008	coro_sigelem_set (pTHX_ SV *sv, MAGIC *mg)	1009	coro_sigelem_set (pTHX_ SV *sv, MAGIC *mg)
1009	{	1010	{
1010	const char *s = MgPV_nolen_const (mg);	1011	const char *s = MgPV_nolen_const (mg);
1011		1012
1012	if (*s == '_')	1013	if (*s == '_')
…		…
1047	return 1;	1048	return 1;
1048	}	1049	}
1049		1050
1050	static UNOP init_perl_op;	1051	static UNOP init_perl_op;
1051		1052
1052	static void NOINLINE /* noinline to keep it out of the transfer fast path */	1053	ecb_noinline static void /* noinline to keep it out of the transfer fast path */
1053	init_perl (pTHX_ struct coro *coro)	1054	init_perl (pTHX_ struct coro *coro)
1054	{	1055	{
1055	/*	1056	/*
1056	* emulate part of the perl startup here.	1057	* emulate part of the perl startup here.
1057	*/	1058	*/
…		…
1072	PL_parser = 0;	1073	PL_parser = 0;
1073	#endif	1074	#endif
1074	PL_hints = 0;	1075	PL_hints = 0;
1075		1076
1076	/* recreate the die/warn hooks */	1077	/* recreate the die/warn hooks */
1077	PL_diehook = 0; SvSetMagicSV (*hv_fetch (hv_sig, "__DIE__" , sizeof ("__DIE__" ) - 1, 1), rv_diehook );	1078	PL_diehook = SvREFCNT_inc (rv_diehook);
1078	PL_warnhook = 0; SvSetMagicSV (*hv_fetch (hv_sig, "__WARN__", sizeof ("__WARN__") - 1, 1), rv_warnhook);	1079	PL_warnhook = SvREFCNT_inc (rv_warnhook);
1079		1080
1080	GvSV (PL_defgv) = newSV (0);	1081	GvSV (PL_defgv) = newSV (0);
1081	GvAV (PL_defgv) = coro->args; coro->args = 0;	1082	GvAV (PL_defgv) = coro->args; coro->args = 0;
1082	GvSV (PL_errgv) = newSV (0);	1083	GvSV (PL_errgv) = newSV (0);
1083	GvSV (irsgv) = newSVpvn ("\n", 1); sv_magic (GvSV (irsgv), (SV *)irsgv, PERL_MAGIC_sv, "/", 0);	1084	GvSV (irsgv) = newSVpvn ("\n", 1); sv_magic (GvSV (irsgv), (SV *)irsgv, PERL_MAGIC_sv, "/", 0);
…		…
1104	/* this newly created coroutine might be run on an existing cctx which most	1105	/* this newly created coroutine might be run on an existing cctx which most
1105	* likely was suspended in pp_slf, so we have to emulate entering pp_slf here.	1106	* likely was suspended in pp_slf, so we have to emulate entering pp_slf here.
1106	*/	1107	*/
1107	slf_frame.prepare = prepare_nop; /* provide a nop function for an eventual pp_slf */	1108	slf_frame.prepare = prepare_nop; /* provide a nop function for an eventual pp_slf */
1108	slf_frame.check = slf_check_nop; /* signal pp_slf to not repeat */	1109	slf_frame.check = slf_check_nop; /* signal pp_slf to not repeat */
		1110	slf_frame.destroy = 0;
1109		1111
1110	/* and we have to provide the pp_slf op in any case, so pp_slf can skip it */	1112	/* and we have to provide the pp_slf op in any case, so pp_slf can skip it */
1111	init_perl_op.op_next = PL_op;	1113	init_perl_op.op_next = PL_op;
1112	init_perl_op.op_type = OP_ENTERSUB;	1114	init_perl_op.op_type = OP_ENTERSUB;
1113	init_perl_op.op_ppaddr = pp_slf;	1115	init_perl_op.op_ppaddr = pp_slf;
…		…
1118	/* copy throw, in case it was set before init_perl */	1120	/* copy throw, in case it was set before init_perl */
1119	CORO_THROW = coro->except;	1121	CORO_THROW = coro->except;
1120		1122
1121	SWAP_SVS (coro);	1123	SWAP_SVS (coro);
1122		1124
1123	if (expect_false (enable_times))	1125	if (ecb_expect_false (enable_times))
1124	{	1126	{
1125	coro_times_update ();	1127	coro_times_update ();
1126	coro_times_sub (coro);	1128	coro_times_sub (coro);
1127	}	1129	}
1128	}	1130	}
…		…
1152	destroy_perl (pTHX_ struct coro *coro)	1154	destroy_perl (pTHX_ struct coro *coro)
1153	{	1155	{
1154	SV *svf [9];	1156	SV *svf [9];
1155		1157
1156	{	1158	{
		1159	SV *old_current = SvRV (coro_current);
1157	struct coro *current = SvSTATE_current;	1160	struct coro *current = SvSTATE (old_current);
1158		1161
1159	assert (("FATAL: tried to destroy currently running coroutine", coro->mainstack != PL_mainstack));	1162	assert (("FATAL: tried to destroy currently running coroutine", coro->mainstack != PL_mainstack));
1160		1163
1161	save_perl (aTHX_ current);	1164	save_perl (aTHX_ current);
		1165
		1166	/* this will cause transfer_check to croak on block*/
		1167	SvRV_set (coro_current, (SV *)coro->hv);
		1168
1162	load_perl (aTHX_ coro);	1169	load_perl (aTHX_ coro);
1163		1170
1164	coro_unwind_stacks (aTHX);	1171	coro_unwind_stacks (aTHX);
1165	coro_destruct_stacks (aTHX);
1166		1172
1167	/* restore swapped sv's */	1173	/* restore swapped sv's */
1168	SWAP_SVS (coro);	1174	SWAP_SVS (coro);
		1175
		1176	coro_destruct_stacks (aTHX);
1169		1177
1170	// now save some sv's to be free'd later	1178	// now save some sv's to be free'd later
1171	svf [0] = GvSV (PL_defgv);	1179	svf [0] = GvSV (PL_defgv);
1172	svf [1] = (SV *)GvAV (PL_defgv);	1180	svf [1] = (SV *)GvAV (PL_defgv);
1173	svf [2] = GvSV (PL_errgv);	1181	svf [2] = GvSV (PL_errgv);
…		…
1177	svf [6] = (SV *)GvHV (PL_hintgv);	1185	svf [6] = (SV *)GvHV (PL_hintgv);
1178	svf [7] = PL_diehook;	1186	svf [7] = PL_diehook;
1179	svf [8] = PL_warnhook;	1187	svf [8] = PL_warnhook;
1180	assert (9 == sizeof (svf) / sizeof (*svf));	1188	assert (9 == sizeof (svf) / sizeof (*svf));
1181		1189
		1190	SvRV_set (coro_current, old_current);
		1191
1182	load_perl (aTHX_ current);	1192	load_perl (aTHX_ current);
1183	}	1193	}
1184		1194
1185	{	1195	{
1186	unsigned int i;	1196	unsigned int i;
…		…
1193	SvREFCNT_dec (coro->invoke_cb);	1203	SvREFCNT_dec (coro->invoke_cb);
1194	SvREFCNT_dec (coro->invoke_av);	1204	SvREFCNT_dec (coro->invoke_av);
1195	}	1205	}
1196	}	1206	}
1197		1207
1198	INLINE void	1208	ECB_INLINE void
1199	free_coro_mortal (pTHX)	1209	free_coro_mortal (pTHX)
1200	{	1210	{
1201	if (expect_true (coro_mortal))	1211	if (ecb_expect_true (coro_mortal))
1202	{	1212	{
1203	SvREFCNT_dec (coro_mortal);	1213	SvREFCNT_dec ((SV *)coro_mortal);
1204	coro_mortal = 0;	1214	coro_mortal = 0;
1205	}	1215	}
1206	}	1216	}
1207		1217
1208	static int	1218	static int
…		…
1341		1351
1342	return frame->check (aTHX_ frame); /* execute the restored frame - there must be one */	1352	return frame->check (aTHX_ frame); /* execute the restored frame - there must be one */
1343	}	1353	}
1344		1354
1345	/* initialises PL_top_env and injects a pseudo-slf-call to set the stacklevel */	1355	/* initialises PL_top_env and injects a pseudo-slf-call to set the stacklevel */
1346	static void NOINLINE	1356	static void ecb_noinline
1347	cctx_prepare (pTHX)	1357	cctx_prepare (pTHX)
1348	{	1358	{
1349	PL_top_env = &PL_start_env;	1359	PL_top_env = &PL_start_env;
1350		1360
1351	if (cctx_current->flags & CC_TRACE)	1361	if (cctx_current->flags & CC_TRACE)
…		…
1362	slf_frame.prepare = slf_prepare_set_stacklevel;	1372	slf_frame.prepare = slf_prepare_set_stacklevel;
1363	slf_frame.check = slf_check_set_stacklevel;	1373	slf_frame.check = slf_check_set_stacklevel;
1364	}	1374	}
1365		1375
1366	/* the tail of transfer: execute stuff we can only do after a transfer */	1376	/* the tail of transfer: execute stuff we can only do after a transfer */
1367	INLINE void	1377	ECB_INLINE void
1368	transfer_tail (pTHX)	1378	transfer_tail (pTHX)
1369	{	1379	{
1370	free_coro_mortal (aTHX);	1380	free_coro_mortal (aTHX);
1371	}	1381	}
1372		1382
…		…
1495	cctx_destroy (coro_cctx *cctx)	1505	cctx_destroy (coro_cctx *cctx)
1496	{	1506	{
1497	if (!cctx)	1507	if (!cctx)
1498	return;	1508	return;
1499		1509
1500	assert (("FATAL: tried to destroy current cctx", cctx != cctx_current));//D temporary?	1510	assert (("FATAL: tried to destroy current cctx", cctx != cctx_current));
1501		1511
1502	--cctx_count;	1512	--cctx_count;
1503	coro_destroy (&cctx->cctx);	1513	coro_destroy (&cctx->cctx);
1504		1514
1505	/* coro_transfer creates new, empty cctx's */	1515	/* coro_transfer creates new, empty cctx's */
…		…
1524	#define CCTX_EXPIRED(cctx) ((cctx)->gen != cctx_gen || ((cctx)->flags & CC_NOREUSE))	1534	#define CCTX_EXPIRED(cctx) ((cctx)->gen != cctx_gen || ((cctx)->flags & CC_NOREUSE))
1525		1535
1526	static coro_cctx *	1536	static coro_cctx *
1527	cctx_get (pTHX)	1537	cctx_get (pTHX)
1528	{	1538	{
1529	while (expect_true (cctx_first))	1539	while (ecb_expect_true (cctx_first))
1530	{	1540	{
1531	coro_cctx *cctx = cctx_first;	1541	coro_cctx *cctx = cctx_first;
1532	cctx_first = cctx->next;	1542	cctx_first = cctx->next;
1533	--cctx_idle;	1543	--cctx_idle;
1534		1544
1535	if (expect_true (!CCTX_EXPIRED (cctx)))	1545	if (ecb_expect_true (!CCTX_EXPIRED (cctx)))
1536	return cctx;	1546	return cctx;
1537		1547
1538	cctx_destroy (cctx);	1548	cctx_destroy (cctx);
1539	}	1549	}
1540		1550
…		…
1545	cctx_put (coro_cctx *cctx)	1555	cctx_put (coro_cctx *cctx)
1546	{	1556	{
1547	assert (("FATAL: cctx_put called on non-initialised cctx in Coro (please report)", cctx->sptr));	1557	assert (("FATAL: cctx_put called on non-initialised cctx in Coro (please report)", cctx->sptr));
1548		1558
1549	/* free another cctx if overlimit */	1559	/* free another cctx if overlimit */
1550	if (expect_false (cctx_idle >= cctx_max_idle))	1560	if (ecb_expect_false (cctx_idle >= cctx_max_idle))
1551	{	1561	{
1552	coro_cctx *first = cctx_first;	1562	coro_cctx *first = cctx_first;
1553	cctx_first = first->next;	1563	cctx_first = first->next;
1554	--cctx_idle;	1564	--cctx_idle;
1555		1565
…		…
1566	static void	1576	static void
1567	transfer_check (pTHX_ struct coro *prev, struct coro *next)	1577	transfer_check (pTHX_ struct coro *prev, struct coro *next)
1568	{	1578	{
1569	/* TODO: throwing up here is considered harmful */	1579	/* TODO: throwing up here is considered harmful */
1570		1580
1571	if (expect_true (prev != next))	1581	if (ecb_expect_true (prev != next))
1572	{	1582	{
1573	if (expect_false (!(prev->flags & (CF_RUNNING | CF_NEW))))	1583	if (ecb_expect_false (!(prev->flags & (CF_RUNNING | CF_NEW))))
1574	croak ("Coro::State::transfer called with a blocked prev Coro::State, but can only transfer from running or new states,");	1584	croak ("Coro::State::transfer called with a blocked prev Coro::State, but can only transfer from running or new states,");
1575		1585
1576	if (expect_false (next->flags & (CF_RUNNING | CF_DESTROYED | CF_SUSPENDED)))	1586	if (ecb_expect_false (next->flags & (CF_RUNNING | CF_ZOMBIE | CF_SUSPENDED)))
1577	croak ("Coro::State::transfer called with running, destroyed or suspended next Coro::State, but can only transfer to inactive states,");	1587	croak ("Coro::State::transfer called with running, destroyed or suspended next Coro::State, but can only transfer to inactive states,");
1578		1588
1579	#if !PERL_VERSION_ATLEAST (5,10,0)	1589	#if !PERL_VERSION_ATLEAST (5,10,0)
1580	if (expect_false (PL_lex_state != LEX_NOTPARSING))	1590	if (ecb_expect_false (PL_lex_state != LEX_NOTPARSING))
1581	croak ("Coro::State::transfer called while parsing, but this is not supported in your perl version,");	1591	croak ("Coro::State::transfer called while parsing, but this is not supported in your perl version,");
1582	#endif	1592	#endif
1583	}	1593	}
1584	}	1594	}
1585		1595
1586	/* always use the TRANSFER macro */	1596	/* always use the TRANSFER macro */
1587	static void NOINLINE /* noinline so we have a fixed stackframe */	1597	static void ecb_noinline /* noinline so we have a fixed stackframe */
1588	transfer (pTHX_ struct coro *prev, struct coro *next, int force_cctx)	1598	transfer (pTHX_ struct coro *prev, struct coro *next, int force_cctx)
1589	{	1599	{
1590	dSTACKLEVEL;	1600	dSTACKLEVEL;
1591		1601
1592	/* sometimes transfer is only called to set idle_sp */	1602	/* sometimes transfer is only called to set idle_sp */
1593	if (expect_false (!prev))	1603	if (ecb_expect_false (!prev))
1594	{	1604	{
1595	cctx_current->idle_sp = STACKLEVEL;	1605	cctx_current->idle_sp = STACKLEVEL;
1596	assert (cctx_current->idle_te = PL_top_env); /* just for the side-effect when asserts are enabled */	1606	assert (cctx_current->idle_te = PL_top_env); /* just for the side-effect when asserts are enabled */
1597	}	1607	}
1598	else if (expect_true (prev != next))	1608	else if (ecb_expect_true (prev != next))
1599	{	1609	{
1600	coro_cctx *cctx_prev;	1610	coro_cctx *cctx_prev;
1601		1611
1602	if (expect_false (prev->flags & CF_NEW))	1612	if (ecb_expect_false (prev->flags & CF_NEW))
1603	{	1613	{
1604	/* create a new empty/source context */	1614	/* create a new empty/source context */
1605	prev->flags &= ~CF_NEW;	1615	prev->flags &= ~CF_NEW;
1606	prev->flags |= CF_RUNNING;	1616	prev->flags |= CF_RUNNING;
1607	}	1617	}
…		…
1610	next->flags |= CF_RUNNING;	1620	next->flags |= CF_RUNNING;
1611		1621
1612	/* first get rid of the old state */	1622	/* first get rid of the old state */
1613	save_perl (aTHX_ prev);	1623	save_perl (aTHX_ prev);
1614		1624
1615	if (expect_false (next->flags & CF_NEW))	1625	if (ecb_expect_false (next->flags & CF_NEW))
1616	{	1626	{
1617	/* need to start coroutine */	1627	/* need to start coroutine */
1618	next->flags &= ~CF_NEW;	1628	next->flags &= ~CF_NEW;
1619	/* setup coroutine call */	1629	/* setup coroutine call */
1620	init_perl (aTHX_ next);	1630	init_perl (aTHX_ next);
1621	}	1631	}
1622	else	1632	else
1623	load_perl (aTHX_ next);	1633	load_perl (aTHX_ next);
1624		1634
1625	/* possibly untie and reuse the cctx */	1635	/* possibly untie and reuse the cctx */
1626	if (expect_true (	1636	if (ecb_expect_true (
1627	cctx_current->idle_sp == STACKLEVEL	1637	cctx_current->idle_sp == STACKLEVEL
1628	&& !(cctx_current->flags & CC_TRACE)	1638	&& !(cctx_current->flags & CC_TRACE)
1629	&& !force_cctx	1639	&& !force_cctx
1630	))	1640	))
1631	{	1641	{
1632	/* I assume that stacklevel is a stronger indicator than PL_top_env changes */	1642	/* I assume that stacklevel is a stronger indicator than PL_top_env changes */
1633	assert (("FATAL: current top_env must equal previous top_env in Coro (please report)", PL_top_env == cctx_current->idle_te));	1643	assert (("FATAL: current top_env must equal previous top_env in Coro (please report)", PL_top_env == cctx_current->idle_te));
1634		1644
1635	/* if the cctx is about to be destroyed we need to make sure we won't see it in cctx_get. */	1645	/* if the cctx is about to be destroyed we need to make sure we won't see it in cctx_get. */
1636	/* without this the next cctx_get might destroy the running cctx while still in use */	1646	/* without this the next cctx_get might destroy the running cctx while still in use */
1637	if (expect_false (CCTX_EXPIRED (cctx_current)))	1647	if (ecb_expect_false (CCTX_EXPIRED (cctx_current)))
1638	if (expect_true (!next->cctx))	1648	if (ecb_expect_true (!next->cctx))
1639	next->cctx = cctx_get (aTHX);	1649	next->cctx = cctx_get (aTHX);
1640		1650
1641	cctx_put (cctx_current);	1651	cctx_put (cctx_current);
1642	}	1652	}
1643	else	1653	else
1644	prev->cctx = cctx_current;	1654	prev->cctx = cctx_current;
1645		1655
1646	++next->usecount;	1656	++next->usecount;
1647		1657
1648	cctx_prev = cctx_current;	1658	cctx_prev = cctx_current;
1649	cctx_current = expect_false (next->cctx) ? next->cctx : cctx_get (aTHX);	1659	cctx_current = ecb_expect_false (next->cctx) ? next->cctx : cctx_get (aTHX);
1650		1660
1651	next->cctx = 0;	1661	next->cctx = 0;
1652		1662
1653	if (expect_false (cctx_prev != cctx_current))	1663	if (ecb_expect_false (cctx_prev != cctx_current))
1654	{	1664	{
1655	cctx_prev->top_env = PL_top_env;	1665	cctx_prev->top_env = PL_top_env;
1656	PL_top_env = cctx_current->top_env;	1666	PL_top_env = cctx_current->top_env;
1657	coro_transfer (&cctx_prev->cctx, &cctx_current->cctx);	1667	coro_transfer (&cctx_prev->cctx, &cctx_current->cctx);
1658	}	1668	}
…		…
1664	#define TRANSFER(ta, force_cctx) transfer (aTHX_ (ta).prev, (ta).next, (force_cctx))	1674	#define TRANSFER(ta, force_cctx) transfer (aTHX_ (ta).prev, (ta).next, (force_cctx))
1665	#define TRANSFER_CHECK(ta) transfer_check (aTHX_ (ta).prev, (ta).next)	1675	#define TRANSFER_CHECK(ta) transfer_check (aTHX_ (ta).prev, (ta).next)
1666		1676
1667	/** high level stuff ********************************************************/	1677	/** high level stuff ********************************************************/
1668		1678
		1679	/* this function is actually Coro, not Coro::State, but we call it from here */
		1680	/* because it is convenient - but it hasn't been declared yet for that reason */
1669	static int	1681	static void
		1682	coro_call_on_destroy (pTHX_ struct coro *coro);
		1683
		1684	static void
1670	coro_state_destroy (pTHX_ struct coro *coro)	1685	coro_state_destroy (pTHX_ struct coro *coro)
1671	{	1686	{
1672	if (coro->flags & CF_DESTROYED)	1687	if (coro->flags & CF_ZOMBIE)
1673	return 0;	1688	return;
1674		1689
1675	if (coro->on_destroy && !PL_dirty)
1676	coro->on_destroy (aTHX_ coro);	1690	slf_destroy (aTHX_ coro);
1677		1691
1678	coro->flags |= CF_DESTROYED;	1692	coro->flags |= CF_ZOMBIE;
1679		1693
1680	if (coro->flags & CF_READY)	1694	if (coro->flags & CF_READY)
1681	{	1695	{
1682	/* reduce nready, as destroying a ready coro effectively unreadies it */	1696	/* reduce nready, as destroying a ready coro effectively unreadies it */
1683	/* alternative: look through all ready queues and remove the coro */	1697	/* alternative: look through all ready queues and remove the coro */
1684	--coro_nready;	1698	--coro_nready;
1685	}	1699	}
1686	else	1700	else
1687	coro->flags |= CF_READY; /* make sure it is NOT put into the readyqueue */	1701	coro->flags |= CF_READY; /* make sure it is NOT put into the readyqueue */
		1702
		1703	if (coro->next) coro->next->prev = coro->prev;
		1704	if (coro->prev) coro->prev->next = coro->next;
		1705	if (coro == coro_first) coro_first = coro->next;
1688		1706
1689	if (coro->mainstack	1707	if (coro->mainstack
1690	&& coro->mainstack != main_mainstack	1708	&& coro->mainstack != main_mainstack
1691	&& coro->slot	1709	&& coro->slot
1692	&& !PL_dirty)	1710	&& !PL_dirty)
1693	destroy_perl (aTHX_ coro);	1711	destroy_perl (aTHX_ coro);
1694		1712
1695	if (coro->next) coro->next->prev = coro->prev;
1696	if (coro->prev) coro->prev->next = coro->next;
1697	if (coro == coro_first) coro_first = coro->next;
1698
1699	cctx_destroy (coro->cctx);	1713	cctx_destroy (coro->cctx);
1700	SvREFCNT_dec (coro->startcv);	1714	SvREFCNT_dec (coro->startcv);
1701	SvREFCNT_dec (coro->args);	1715	SvREFCNT_dec (coro->args);
1702	SvREFCNT_dec (coro->swap_sv);	1716	SvREFCNT_dec (coro->swap_sv);
1703	SvREFCNT_dec (CORO_THROW);	1717	SvREFCNT_dec (CORO_THROW);
1704		1718
1705	return 1;	1719	coro_call_on_destroy (aTHX_ coro);
		1720
		1721	/* more destruction mayhem in coro_state_free */
1706	}	1722	}
1707		1723
1708	static int	1724	static int
1709	coro_state_free (pTHX_ SV *sv, MAGIC *mg)	1725	coro_state_free (pTHX_ SV *sv, MAGIC *mg)
1710	{	1726	{
1711	struct coro *coro = (struct coro *)mg->mg_ptr;	1727	struct coro *coro = (struct coro *)mg->mg_ptr;
1712	mg->mg_ptr = 0;	1728	mg->mg_ptr = 0;
1713		1729
1714	coro->hv = 0;
1715
1716	if (--coro->refcnt < 0)
1717	{
1718	coro_state_destroy (aTHX_ coro);	1730	coro_state_destroy (aTHX_ coro);
		1731	SvREFCNT_dec (coro->on_destroy);
		1732	SvREFCNT_dec (coro->status);
		1733
1719	Safefree (coro);	1734	Safefree (coro);
1720	}
1721		1735
1722	return 0;	1736	return 0;
1723	}	1737	}
1724		1738
1725	static int	1739	static int ecb_cold
1726	coro_state_dup (pTHX_ MAGIC *mg, CLONE_PARAMS *params)	1740	coro_state_dup (pTHX_ MAGIC *mg, CLONE_PARAMS *params)
1727	{	1741	{
1728	struct coro *coro = (struct coro *)mg->mg_ptr;	1742	/* called when perl clones the current process the slow way (windows process emulation) */
1729		1743	/* WE SIMply nuke the pointers in the copy, causing perl to croak */
1730	++coro->refcnt;	1744	mg->mg_ptr = 0;
		1745	mg->mg_virtual = 0;
1731		1746
1732	return 0;	1747	return 0;
1733	}	1748	}
1734		1749
1735	static MGVTBL coro_state_vtbl = {	1750	static MGVTBL coro_state_vtbl = {
…		…
1760	TRANSFER (ta, 1);	1775	TRANSFER (ta, 1);
1761	}	1776	}
1762		1777
1763	/** Coro ********************************************************************/	1778	/** Coro ********************************************************************/
1764		1779
1765	INLINE void	1780	ECB_INLINE void
1766	coro_enq (pTHX_ struct coro *coro)	1781	coro_enq (pTHX_ struct coro *coro)
1767	{	1782	{
1768	struct coro **ready = coro_ready [coro->prio - CORO_PRIO_MIN];	1783	struct coro **ready = coro_ready [coro->prio - CORO_PRIO_MIN];
1769		1784
1770	SvREFCNT_inc_NN (coro->hv);	1785	SvREFCNT_inc_NN (coro->hv);
…		…
1772	coro->next_ready = 0;	1787	coro->next_ready = 0;
1773	*(ready [0] ? &ready [1]->next_ready : &ready [0]) = coro;	1788	*(ready [0] ? &ready [1]->next_ready : &ready [0]) = coro;
1774	ready [1] = coro;	1789	ready [1] = coro;
1775	}	1790	}
1776		1791
1777	INLINE struct coro *	1792	ECB_INLINE struct coro *
1778	coro_deq (pTHX)	1793	coro_deq (pTHX)
1779	{	1794	{
1780	int prio;	1795	int prio;
1781		1796
1782	for (prio = CORO_PRIO_MAX - CORO_PRIO_MIN + 1; --prio >= 0; )	1797	for (prio = CORO_PRIO_MAX - CORO_PRIO_MIN + 1; --prio >= 0; )
…		…
1835	{	1850	{
1836	return !!(SvSTATE (coro_sv)->flags & CF_READY);	1851	return !!(SvSTATE (coro_sv)->flags & CF_READY);
1837	}	1852	}
1838		1853
1839	/* expects to own a reference to next->hv */	1854	/* expects to own a reference to next->hv */
1840	INLINE void	1855	ECB_INLINE void
1841	prepare_schedule_to (pTHX_ struct coro_transfer_args *ta, struct coro *next)	1856	prepare_schedule_to (pTHX_ struct coro_transfer_args *ta, struct coro *next)
1842	{	1857	{
1843	SV *prev_sv = SvRV (coro_current);	1858	SV *prev_sv = SvRV (coro_current);
1844		1859
1845	ta->prev = SvSTATE_hv (prev_sv);	1860	ta->prev = SvSTATE_hv (prev_sv);
…		…
1858	{	1873	{
1859	for (;;)	1874	for (;;)
1860	{	1875	{
1861	struct coro *next = coro_deq (aTHX);	1876	struct coro *next = coro_deq (aTHX);
1862		1877
1863	if (expect_true (next))	1878	if (ecb_expect_true (next))
1864	{	1879	{
1865	/* cannot transfer to destroyed coros, skip and look for next */	1880	/* cannot transfer to destroyed coros, skip and look for next */
1866	if (expect_false (next->flags & (CF_DESTROYED | CF_SUSPENDED)))	1881	if (ecb_expect_false (next->flags & (CF_ZOMBIE | CF_SUSPENDED)))
1867	SvREFCNT_dec (next->hv); /* coro_nready has already been taken care of by destroy */	1882	SvREFCNT_dec (next->hv); /* coro_nready has already been taken care of by destroy */
1868	else	1883	else
1869	{	1884	{
1870	next->flags &= ~CF_READY;	1885	next->flags &= ~CF_READY;
1871	--coro_nready;	1886	--coro_nready;
…		…
1904	}	1919	}
1905	}	1920	}
1906	}	1921	}
1907	}	1922	}
1908		1923
1909	INLINE void	1924	ECB_INLINE void
1910	prepare_cede (pTHX_ struct coro_transfer_args *ta)	1925	prepare_cede (pTHX_ struct coro_transfer_args *ta)
1911	{	1926	{
1912	api_ready (aTHX_ coro_current);	1927	api_ready (aTHX_ coro_current);
1913	prepare_schedule (aTHX_ ta);	1928	prepare_schedule (aTHX_ ta);
1914	}	1929	}
1915		1930
1916	INLINE void	1931	ECB_INLINE void
1917	prepare_cede_notself (pTHX_ struct coro_transfer_args *ta)	1932	prepare_cede_notself (pTHX_ struct coro_transfer_args *ta)
1918	{	1933	{
1919	SV *prev = SvRV (coro_current);	1934	SV *prev = SvRV (coro_current);
1920		1935
1921	if (coro_nready)	1936	if (coro_nready)
…		…
1951	{	1966	{
1952	struct coro_transfer_args ta;	1967	struct coro_transfer_args ta;
1953		1968
1954	prepare_cede (aTHX_ &ta);	1969	prepare_cede (aTHX_ &ta);
1955		1970
1956	if (expect_true (ta.prev != ta.next))	1971	if (ecb_expect_true (ta.prev != ta.next))
1957	{	1972	{
1958	TRANSFER (ta, 1);	1973	TRANSFER (ta, 1);
1959	return 1;	1974	return 1;
1960	}	1975	}
1961	else	1976	else
…		…
2004	coro->slot->runops = RUNOPS_DEFAULT;	2019	coro->slot->runops = RUNOPS_DEFAULT;
2005	}	2020	}
2006	}	2021	}
2007		2022
2008	static void	2023	static void
		2024	coro_push_av (pTHX_ AV *av, I32 gimme_v)
		2025	{
		2026	if (AvFILLp (av) >= 0 && gimme_v != G_VOID)
		2027	{
		2028	dSP;
		2029
		2030	if (gimme_v == G_SCALAR)
		2031	XPUSHs (AvARRAY (av)[AvFILLp (av)]);
		2032	else
		2033	{
		2034	int i;
		2035	EXTEND (SP, AvFILLp (av) + 1);
		2036
		2037	for (i = 0; i <= AvFILLp (av); ++i)
		2038	PUSHs (AvARRAY (av)[i]);
		2039	}
		2040
		2041	PUTBACK;
		2042	}
		2043	}
		2044
		2045	static void
		2046	coro_push_on_destroy (pTHX_ struct coro *coro, SV *cb)
		2047	{
		2048	if (!coro->on_destroy)
		2049	coro->on_destroy = newAV ();
		2050
		2051	av_push (coro->on_destroy, cb);
		2052	}
		2053
		2054	static void
		2055	slf_destroy_join (pTHX_ struct CoroSLF *frame)
		2056	{
		2057	SvREFCNT_dec ((SV *)((struct coro *)frame->data)->hv);
		2058	}
		2059
		2060	static int
		2061	slf_check_join (pTHX_ struct CoroSLF *frame)
		2062	{
		2063	struct coro *coro = (struct coro *)frame->data;
		2064
		2065	if (!coro->status)
		2066	return 1;
		2067
		2068	frame->destroy = 0;
		2069
		2070	coro_push_av (aTHX_ coro->status, GIMME_V);
		2071
		2072	SvREFCNT_dec ((SV *)coro->hv);
		2073
		2074	return 0;
		2075	}
		2076
		2077	static void
		2078	slf_init_join (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
		2079	{
		2080	struct coro *coro = SvSTATE (items > 0 ? arg [0] : &PL_sv_undef);
		2081
		2082	if (items > 1)
		2083	croak ("join called with too many arguments");
		2084
		2085	if (coro->status)
		2086	frame->prepare = prepare_nop;
		2087	else
		2088	{
		2089	coro_push_on_destroy (aTHX_ coro, SvREFCNT_inc_NN (SvRV (coro_current)));
		2090	frame->prepare = prepare_schedule;
		2091	}
		2092
		2093	frame->check = slf_check_join;
		2094	frame->destroy = slf_destroy_join;
		2095	frame->data = (void *)coro;
		2096	SvREFCNT_inc (coro->hv);
		2097	}
		2098
		2099	static void
2009	coro_call_on_destroy (pTHX_ struct coro *coro)	2100	coro_call_on_destroy (pTHX_ struct coro *coro)
2010	{	2101	{
2011	SV **on_destroyp = hv_fetch (coro->hv, "_on_destroy", sizeof ("_on_destroy") - 1, 0);	2102	AV *od = coro->on_destroy;
2012	SV **statusp = hv_fetch (coro->hv, "_status", sizeof ("_status") - 1, 0);
2013		2103
2014	if (on_destroyp)	2104	if (!od)
2015	{	2105	return;
2016	AV *on_destroy = (AV *)SvRV (*on_destroyp);
2017		2106
2018	while (AvFILLp (on_destroy) >= 0)	2107	while (AvFILLp (od) >= 0)
		2108	{
		2109	SV *cb = sv_2mortal (av_pop (od));
		2110
		2111	/* coro hv's (and only hv's at the moment) are supported as well */
		2112	if (SvSTATEhv_p (aTHX_ cb))
		2113	api_ready (aTHX_ cb);
		2114	else
2019	{	2115	{
2020	dSP; /* don't disturb outer sp */	2116	dSP; /* don't disturb outer sp */
2021	SV *cb = av_pop (on_destroy);
2022
2023	PUSHMARK (SP);	2117	PUSHMARK (SP);
2024		2118
2025	if (statusp)	2119	if (coro->status)
2026	{	2120	{
2027	int i;	2121	PUTBACK;
2028	AV *status = (AV *)SvRV (*statusp);	2122	coro_push_av (aTHX_ coro->status, G_ARRAY);
2029	EXTEND (SP, AvFILLp (status) + 1);	2123	SPAGAIN;
2030
2031	for (i = 0; i <= AvFILLp (status); ++i)
2032	PUSHs (AvARRAY (status)[i]);
2033	}	2124	}
2034		2125
2035	PUTBACK;	2126	PUTBACK;
2036	call_sv (sv_2mortal (cb), G_VOID | G_DISCARD);	2127	call_sv (cb, G_VOID | G_DISCARD);
2037	}	2128	}
2038	}	2129	}
2039	}	2130	}
2040		2131
2041	static void	2132	static void
2042	slf_init_terminate (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)	2133	coro_set_status (pTHX_ struct coro *coro, SV **arg, int items)
2043	{	2134	{
2044	int i;	2135	AV *av;
2045	HV *hv = (HV *)SvRV (coro_current);	2136
2046	AV *av = newAV ();	2137	if (coro->status)
		2138	{
		2139	av = coro->status;
		2140	av_clear (av);
		2141	}
		2142	else
		2143	av = coro->status = newAV ();
2047		2144
2048	/* items are actually not so common, so optimise for this case */	2145	/* items are actually not so common, so optimise for this case */
2049	if (items)	2146	if (items)
2050	{	2147	{
		2148	int i;
		2149
2051	av_extend (av, items - 1);	2150	av_extend (av, items - 1);
2052		2151
2053	for (i = 0; i < items; ++i)	2152	for (i = 0; i < items; ++i)
2054	av_push (av, SvREFCNT_inc_NN (arg [i]));	2153	av_push (av, SvREFCNT_inc_NN (arg [i]));
2055	}	2154	}
		2155	}
2056		2156
2057	hv_store (hv, "_status", sizeof ("_status") - 1, newRV_noinc ((SV *)av), 0);	2157	static void
2058		2158	slf_init_terminate_cancel_common (pTHX_ struct CoroSLF *frame, HV *coro_hv)
		2159	{
2059	av_push (av_destroy, (SV *)newRV_inc ((SV *)hv)); /* RVinc for perl */	2160	av_push (av_destroy, (SV *)newRV_inc ((SV *)coro_hv)); /* RVinc for perl */
2060	api_ready (aTHX_ sv_manager);	2161	api_ready (aTHX_ sv_manager);
2061		2162
2062	frame->prepare = prepare_schedule;	2163	frame->prepare = prepare_schedule;
2063	frame->check = slf_check_repeat;	2164	frame->check = slf_check_repeat;
2064		2165
2065	/* as a minor optimisation, we could unwind all stacks here */	2166	/* as a minor optimisation, we could unwind all stacks here */
2066	/* but that puts extra pressure on pp_slf, and is not worth much */	2167	/* but that puts extra pressure on pp_slf, and is not worth much */
2067	/*coro_unwind_stacks (aTHX);*/	2168	/*coro_unwind_stacks (aTHX);*/
		2169	}
		2170
		2171	static void
		2172	slf_init_terminate (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
		2173	{
		2174	HV *coro_hv = (HV *)SvRV (coro_current);
		2175
		2176	coro_set_status (aTHX_ SvSTATE ((SV *)coro_hv), arg, items);
		2177	slf_init_terminate_cancel_common (aTHX_ frame, coro_hv);
		2178	}
		2179
		2180	static void
		2181	slf_init_cancel (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
		2182	{
		2183	HV *coro_hv;
		2184	struct coro *coro;
		2185
		2186	if (items <= 0)
		2187	croak ("Coro::cancel called without coro object,");
		2188
		2189	coro = SvSTATE (arg [0]);
		2190	coro_hv = coro->hv;
		2191
		2192	coro_set_status (aTHX_ coro, arg + 1, items - 1);
		2193
		2194	if (ecb_expect_false (coro->flags & CF_NOCANCEL))
		2195	{
		2196	/* coro currently busy cancelling something, so just notify it */
		2197	coro->slf_frame.data = (void *)coro;
		2198
		2199	frame->prepare = prepare_nop;
		2200	frame->check = slf_check_nop;
		2201	}
		2202	else if (coro_hv == (HV *)SvRV (coro_current))
		2203	{
		2204	/* cancelling the current coro is allowed, and equals terminate */
		2205	slf_init_terminate_cancel_common (aTHX_ frame, coro_hv);
		2206	}
		2207	else
		2208	{
		2209	struct coro *self = SvSTATE_current;
		2210
		2211	/* otherwise we cancel directly, purely for speed reasons
		2212	* unfortunately, this requires some magic trickery, as
		2213	* somebody else could cancel us, so we have to fight the cancellation.
		2214	* this is ugly, and hopefully fully worth the extra speed.
		2215	* besides, I can't get the slow-but-safe version working...
		2216	*/
		2217	slf_frame.data = 0;
		2218	self->flags |= CF_NOCANCEL;
		2219	coro_state_destroy (aTHX_ coro);
		2220	self->flags &= ~CF_NOCANCEL;
		2221
		2222	if (slf_frame.data)
		2223	{
		2224	/* while we were busy we have been cancelled, so terminate */
		2225	slf_init_terminate_cancel_common (aTHX_ frame, self->hv);
		2226	}
		2227	else
		2228	{
		2229	frame->prepare = prepare_nop;
		2230	frame->check = slf_check_nop;
		2231	}
		2232	}
		2233	}
		2234
		2235	static int
		2236	slf_check_safe_cancel (pTHX_ struct CoroSLF *frame)
		2237	{
		2238	frame->prepare = 0;
		2239	coro_unwind_stacks (aTHX);
		2240
		2241	slf_init_terminate_cancel_common (aTHX_ frame, (HV *)SvRV (coro_current));
		2242
		2243	return 1;
		2244	}
		2245
		2246	static int
		2247	safe_cancel (pTHX_ struct coro *coro, SV **arg, int items)
		2248	{
		2249	if (coro->cctx)
		2250	croak ("coro inside C callback, unable to cancel at this time, caught");
		2251
		2252	if (coro->flags & CF_NEW)
		2253	{
		2254	coro_set_status (aTHX_ coro, arg, items);
		2255	coro_state_destroy (aTHX_ coro);
		2256	}
		2257	else
		2258	{
		2259	if (!coro->slf_frame.prepare)
		2260	croak ("coro outside an SLF function, unable to cancel at this time, caught");
		2261
		2262	slf_destroy (aTHX_ coro);
		2263
		2264	coro_set_status (aTHX_ coro, arg, items);
		2265	coro->slf_frame.prepare = prepare_nop;
		2266	coro->slf_frame.check = slf_check_safe_cancel;
		2267
		2268	api_ready (aTHX_ (SV *)coro->hv);
		2269	}
		2270
		2271	return 1;
2068	}	2272	}
2069		2273
2070	/*****************************************************************************/	2274	/*****************************************************************************/
2071	/* async pool handler */	2275	/* async pool handler */
2072		2276
…		…
2103	slf_init_pool_handler (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)	2307	slf_init_pool_handler (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2104	{	2308	{
2105	HV *hv = (HV *)SvRV (coro_current);	2309	HV *hv = (HV *)SvRV (coro_current);
2106	struct coro *coro = SvSTATE_hv ((SV *)hv);	2310	struct coro *coro = SvSTATE_hv ((SV *)hv);
2107		2311
2108	if (expect_true (coro->saved_deffh))	2312	if (ecb_expect_true (coro->saved_deffh))
2109	{	2313	{
2110	/* subsequent iteration */	2314	/* subsequent iteration */
2111	SvREFCNT_dec ((SV *)PL_defoutgv); PL_defoutgv = (GV *)coro->saved_deffh;	2315	SvREFCNT_dec ((SV *)PL_defoutgv); PL_defoutgv = (GV *)coro->saved_deffh;
2112	coro->saved_deffh = 0;	2316	coro->saved_deffh = 0;
2113		2317
2114	if (coro_rss (aTHX_ coro) > SvUV (sv_pool_rss)	2318	if (coro_rss (aTHX_ coro) > SvUV (sv_pool_rss)
2115	|| av_len (av_async_pool) + 1 >= SvIV (sv_pool_size))	2319	|| av_len (av_async_pool) + 1 >= SvIV (sv_pool_size))
2116	{	2320	{
2117	coro->invoke_cb = SvREFCNT_inc_NN ((SV *)cv_coro_terminate);	2321	slf_init_terminate_cancel_common (aTHX_ frame, hv);
2118	coro->invoke_av = newAV ();	2322	return;
2119
2120	frame->prepare = prepare_nop;
2121	}	2323	}
2122	else	2324	else
2123	{	2325	{
2124	av_clear (GvAV (PL_defgv));	2326	av_clear (GvAV (PL_defgv));
2125	hv_store (hv, "desc", sizeof ("desc") - 1, SvREFCNT_inc_NN (sv_async_pool_idle), 0);	2327	hv_store (hv, "desc", sizeof ("desc") - 1, SvREFCNT_inc_NN (sv_async_pool_idle), 0);
…		…
2348	static void	2550	static void
2349	slf_init_cede_notself (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)	2551	slf_init_cede_notself (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2350	{	2552	{
2351	frame->prepare = prepare_cede_notself;	2553	frame->prepare = prepare_cede_notself;
2352	frame->check = slf_check_nop;	2554	frame->check = slf_check_nop;
		2555	}
		2556
		2557	/* "undo"/cancel a running slf call - used when cancelling a coro, mainly */
		2558	static void
		2559	slf_destroy (pTHX_ struct coro *coro)
		2560	{
		2561	/* this callback is reserved for slf functions needing to do cleanup */
		2562	if (coro->slf_frame.destroy && coro->slf_frame.prepare && !PL_dirty)
		2563	coro->slf_frame.destroy (aTHX_ &coro->slf_frame);
		2564
		2565	/*
		2566	* The on_destroy above most likely is from an SLF call.
		2567	* Since by definition the SLF call will not finish when we destroy
		2568	* the coro, we will have to force-finish it here, otherwise
		2569	* cleanup functions cannot call SLF functions.
		2570	*/
		2571	coro->slf_frame.prepare = 0;
2353	}	2572	}
2354		2573
2355	/*	2574	/*
2356	* these not obviously related functions are all rolled into one	2575	* these not obviously related functions are all rolled into one
2357	* function to increase chances that they all will call transfer with the same	2576	* function to increase chances that they all will call transfer with the same
…		…
2364	I32 checkmark; /* mark SP to see how many elements check has pushed */	2583	I32 checkmark; /* mark SP to see how many elements check has pushed */
2365		2584
2366	/* set up the slf frame, unless it has already been set-up */	2585	/* set up the slf frame, unless it has already been set-up */
2367	/* the latter happens when a new coro has been started */	2586	/* the latter happens when a new coro has been started */
2368	/* or when a new cctx was attached to an existing coroutine */	2587	/* or when a new cctx was attached to an existing coroutine */
2369	if (expect_true (!slf_frame.prepare))	2588	if (ecb_expect_true (!slf_frame.prepare))
2370	{	2589	{
2371	/* first iteration */	2590	/* first iteration */
2372	dSP;	2591	dSP;
2373	SV **arg = PL_stack_base + TOPMARK + 1;	2592	SV **arg = PL_stack_base + TOPMARK + 1;
2374	int items = SP - arg; /* args without function object */	2593	int items = SP - arg; /* args without function object */
…		…
2415	while (slf_frame.check (aTHX_ &slf_frame));	2634	while (slf_frame.check (aTHX_ &slf_frame));
2416		2635
2417	slf_frame.prepare = 0; /* invalidate the frame, we are done processing it */	2636	slf_frame.prepare = 0; /* invalidate the frame, we are done processing it */
2418		2637
2419	/* exception handling */	2638	/* exception handling */
2420	if (expect_false (CORO_THROW))	2639	if (ecb_expect_false (CORO_THROW))
2421	{	2640	{
2422	SV *exception = sv_2mortal (CORO_THROW);	2641	SV *exception = sv_2mortal (CORO_THROW);
2423		2642
2424	CORO_THROW = 0;	2643	CORO_THROW = 0;
2425	sv_setsv (ERRSV, exception);	2644	sv_setsv (ERRSV, exception);
2426	croak (0);	2645	croak (0);
2427	}	2646	}
2428		2647
2429	/* return value handling - mostly like entersub */	2648	/* return value handling - mostly like entersub */
2430	/* make sure we put something on the stack in scalar context */	2649	/* make sure we put something on the stack in scalar context */
2431	if (GIMME_V == G_SCALAR)	2650	if (GIMME_V == G_SCALAR
		2651	&& ecb_expect_false (PL_stack_sp != PL_stack_base + checkmark + 1))
2432	{	2652	{
2433	dSP;	2653	dSP;
2434	SV **bot = PL_stack_base + checkmark;	2654	SV **bot = PL_stack_base + checkmark;
2435		2655
2436	if (sp == bot) /* too few, push undef */	2656	if (sp == bot) /* too few, push undef */
2437	bot [1] = &PL_sv_undef;	2657	bot [1] = &PL_sv_undef;
2438	else if (sp != bot + 1) /* too many, take last one */	2658	else /* too many, take last one */
2439	bot [1] = *sp;	2659	bot [1] = *sp;
2440		2660
2441	SP = bot + 1;	2661	SP = bot + 1;
2442		2662
2443	PUTBACK;	2663	PUTBACK;
…		…
2550	{	2770	{
2551	PerlIOBuf base;	2771	PerlIOBuf base;
2552	NV next, every;	2772	NV next, every;
2553	} PerlIOCede;	2773	} PerlIOCede;
2554		2774
2555	static IV	2775	static IV ecb_cold
2556	PerlIOCede_pushed (pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)	2776	PerlIOCede_pushed (pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
2557	{	2777	{
2558	PerlIOCede *self = PerlIOSelf (f, PerlIOCede);	2778	PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
2559		2779
2560	self->every = SvCUR (arg) ? SvNV (arg) : 0.01;	2780	self->every = SvCUR (arg) ? SvNV (arg) : 0.01;
2561	self->next = nvtime () + self->every;	2781	self->next = nvtime () + self->every;
2562		2782
2563	return PerlIOBuf_pushed (aTHX_ f, mode, Nullsv, tab);	2783	return PerlIOBuf_pushed (aTHX_ f, mode, Nullsv, tab);
2564	}	2784	}
2565		2785
2566	static SV *	2786	static SV * ecb_cold
2567	PerlIOCede_getarg (pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)	2787	PerlIOCede_getarg (pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)
2568	{	2788	{
2569	PerlIOCede *self = PerlIOSelf (f, PerlIOCede);	2789	PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
2570		2790
2571	return newSVnv (self->every);	2791	return newSVnv (self->every);
…		…
2683	SvREFCNT_dec (cb);	2903	SvREFCNT_dec (cb);
2684	}	2904	}
2685	}	2905	}
2686		2906
2687	static void	2907	static void
2688	coro_semaphore_on_destroy (pTHX_ struct coro *coro)	2908	coro_semaphore_destroy (pTHX_ struct CoroSLF *frame)
2689	{	2909	{
2690	/* call $sem->adjust (0) to possibly wake up some other waiters */	2910	/* call $sem->adjust (0) to possibly wake up some other waiters */
2691	coro_semaphore_adjust (aTHX_ (AV *)coro->slf_frame.data, 0);	2911	coro_semaphore_adjust (aTHX_ (AV *)frame->data, 0);
2692	}	2912	}
2693		2913
2694	static int	2914	static int
2695	slf_check_semaphore_down_or_wait (pTHX_ struct CoroSLF *frame, int acquire)	2915	slf_check_semaphore_down_or_wait (pTHX_ struct CoroSLF *frame, int acquire)
2696	{	2916	{
2697	AV *av = (AV *)frame->data;	2917	AV *av = (AV *)frame->data;
2698	SV *count_sv = AvARRAY (av)[0];	2918	SV *count_sv = AvARRAY (av)[0];
		2919	SV *coro_hv = SvRV (coro_current);
2699		2920
2700	/* if we are about to throw, don't actually acquire the lock, just throw */	2921	/* if we are about to throw, don't actually acquire the lock, just throw */
2701	if (CORO_THROW)	2922	if (CORO_THROW)
2702	return 0;	2923	return 0;
2703	else if (SvIVX (count_sv) > 0)	2924	else if (SvIVX (count_sv) > 0)
2704	{	2925	{
2705	SvSTATE_current->on_destroy = 0;	2926	frame->destroy = 0;
2706		2927
2707	if (acquire)	2928	if (acquire)
2708	SvIVX (count_sv) = SvIVX (count_sv) - 1;	2929	SvIVX (count_sv) = SvIVX (count_sv) - 1;
2709	else	2930	else
2710	coro_semaphore_adjust (aTHX_ av, 0);	2931	coro_semaphore_adjust (aTHX_ av, 0);
…		…
2715	{	2936	{
2716	int i;	2937	int i;
2717	/* if we were woken up but can't down, we look through the whole */	2938	/* if we were woken up but can't down, we look through the whole */
2718	/* waiters list and only add us if we aren't in there already */	2939	/* waiters list and only add us if we aren't in there already */
2719	/* this avoids some degenerate memory usage cases */	2940	/* this avoids some degenerate memory usage cases */
2720		2941	for (i = AvFILLp (av); i > 0; --i) // i > 0 is not an off-by-one bug
2721	for (i = 1; i <= AvFILLp (av); ++i)
2722	if (AvARRAY (av)[i] == SvRV (coro_current))	2942	if (AvARRAY (av)[i] == coro_hv)
2723	return 1;	2943	return 1;
2724		2944
2725	av_push (av, SvREFCNT_inc (SvRV (coro_current)));	2945	av_push (av, SvREFCNT_inc (coro_hv));
2726	return 1;	2946	return 1;
2727	}	2947	}
2728	}	2948	}
2729		2949
2730	static int	2950	static int
…		…
2753	{	2973	{
2754	av_push (av, SvREFCNT_inc (SvRV (coro_current)));	2974	av_push (av, SvREFCNT_inc (SvRV (coro_current)));
2755		2975
2756	frame->data = (void *)sv_2mortal (SvREFCNT_inc ((SV *)av));	2976	frame->data = (void *)sv_2mortal (SvREFCNT_inc ((SV *)av));
2757	frame->prepare = prepare_schedule;	2977	frame->prepare = prepare_schedule;
2758
2759	/* to avoid race conditions when a woken-up coro gets terminated */	2978	/* to avoid race conditions when a woken-up coro gets terminated */
2760	/* we arrange for a temporary on_destroy that calls adjust (0) */	2979	/* we arrange for a temporary on_destroy that calls adjust (0) */
2761	SvSTATE_current->on_destroy = coro_semaphore_on_destroy;	2980	frame->destroy = coro_semaphore_destroy;
2762	}	2981	}
2763	}	2982	}
2764		2983
2765	static void	2984	static void
2766	slf_init_semaphore_down (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)	2985	slf_init_semaphore_down (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
…		…
2984	dSP;	3203	dSP;
2985		3204
2986	static SV *prio_cv;	3205	static SV *prio_cv;
2987	static SV *prio_sv;	3206	static SV *prio_sv;
2988		3207
2989	if (expect_false (!prio_cv))	3208	if (ecb_expect_false (!prio_cv))
2990	{	3209	{
2991	prio_cv = (SV *)get_cv ("IO::AIO::aioreq_pri", 0);	3210	prio_cv = (SV *)get_cv ("IO::AIO::aioreq_pri", 0);
2992	prio_sv = newSViv (0);	3211	prio_sv = newSViv (0);
2993	}	3212	}
2994		3213
…		…
3100	}	3319	}
3101		3320
3102	return coro_sv;	3321	return coro_sv;
3103	}	3322	}
3104		3323
		3324	#ifndef __cplusplus
		3325	ecb_cold XS(boot_Coro__State);
		3326	#endif
		3327
3105	MODULE = Coro::State PACKAGE = Coro::State PREFIX = api_	3328	MODULE = Coro::State PACKAGE = Coro::State PREFIX = api_
3106		3329
3107	PROTOTYPES: DISABLE	3330	PROTOTYPES: DISABLE
3108		3331
3109	BOOT:	3332	BOOT:
…		…
3161	coroapi.prepare_nop = prepare_nop;	3384	coroapi.prepare_nop = prepare_nop;
3162	coroapi.prepare_schedule = prepare_schedule;	3385	coroapi.prepare_schedule = prepare_schedule;
3163	coroapi.prepare_cede = prepare_cede;	3386	coroapi.prepare_cede = prepare_cede;
3164	coroapi.prepare_cede_notself = prepare_cede_notself;	3387	coroapi.prepare_cede_notself = prepare_cede_notself;
3165		3388
3166	time_init ();	3389	time_init (aTHX);
3167		3390
3168	assert (("PRIO_NORMAL must be 0", !CORO_PRIO_NORMAL));	3391	assert (("PRIO_NORMAL must be 0", !CORO_PRIO_NORMAL));
3169	}	3392	}
3170		3393
3171	SV *	3394	SV *
…		…
3180	void	3403	void
3181	transfer (...)	3404	transfer (...)
3182	PROTOTYPE: $$	3405	PROTOTYPE: $$
3183	CODE:	3406	CODE:
3184	CORO_EXECUTE_SLF_XS (slf_init_transfer);	3407	CORO_EXECUTE_SLF_XS (slf_init_transfer);
3185
3186	bool
3187	_destroy (SV *coro_sv)
3188	CODE:
3189	RETVAL = coro_state_destroy (aTHX_ SvSTATE (coro_sv));
3190	OUTPUT:
3191	RETVAL
3192		3408
3193	void	3409	void
3194	_exit (int code)	3410	_exit (int code)
3195	PROTOTYPE: $	3411	PROTOTYPE: $
3196	CODE:	3412	CODE:
…		…
3272	CODE:	3488	CODE:
3273	{	3489	{
3274	if (coro->mainstack && ((coro->flags & CF_RUNNING) || coro->slot))	3490	if (coro->mainstack && ((coro->flags & CF_RUNNING) || coro->slot))
3275	{	3491	{
3276	struct coro *current = SvSTATE_current;	3492	struct coro *current = SvSTATE_current;
		3493	struct CoroSLF slf_save;
3277		3494
3278	if (current != coro)	3495	if (current != coro)
3279	{	3496	{
3280	PUTBACK;	3497	PUTBACK;
3281	save_perl (aTHX_ current);	3498	save_perl (aTHX_ current);
3282	load_perl (aTHX_ coro);	3499	load_perl (aTHX_ coro);
		3500	/* the coro is most likely in an active SLF call.
		3501	* while not strictly required (the code we execute is
		3502	* not allowed to call any SLF functions), it's cleaner
		3503	* to reinitialise the slf_frame and restore it later.
		3504	* This might one day allow us to actually do SLF calls
		3505	* from code executed here.
		3506	*/
		3507	slf_save = slf_frame;
		3508	slf_frame.prepare = 0;
3283	SPAGAIN;	3509	SPAGAIN;
3284	}	3510	}
3285		3511
3286	PUSHSTACK;	3512	PUSHSTACK;
3287		3513
…		…
3297	SPAGAIN;	3523	SPAGAIN;
3298		3524
3299	if (current != coro)	3525	if (current != coro)
3300	{	3526	{
3301	PUTBACK;	3527	PUTBACK;
		3528	slf_frame = slf_save;
3302	save_perl (aTHX_ coro);	3529	save_perl (aTHX_ coro);
3303	load_perl (aTHX_ current);	3530	load_perl (aTHX_ current);
3304	SPAGAIN;	3531	SPAGAIN;
3305	}	3532	}
3306	}	3533	}
…		…
3311	PROTOTYPE: $	3538	PROTOTYPE: $
3312	ALIAS:	3539	ALIAS:
3313	is_ready = CF_READY	3540	is_ready = CF_READY
3314	is_running = CF_RUNNING	3541	is_running = CF_RUNNING
3315	is_new = CF_NEW	3542	is_new = CF_NEW
3316	is_destroyed = CF_DESTROYED	3543	is_destroyed = CF_ZOMBIE
		3544	is_zombie = CF_ZOMBIE
3317	is_suspended = CF_SUSPENDED	3545	is_suspended = CF_SUSPENDED
3318	CODE:	3546	CODE:
3319	RETVAL = boolSV (coro->flags & ix);	3547	RETVAL = boolSV (coro->flags & ix);
3320	OUTPUT:	3548	OUTPUT:
3321	RETVAL	3549	RETVAL
…		…
3392		3620
3393	void	3621	void
3394	cancel (Coro::State self)	3622	cancel (Coro::State self)
3395	CODE:	3623	CODE:
3396	coro_state_destroy (aTHX_ self);	3624	coro_state_destroy (aTHX_ self);
3397	coro_call_on_destroy (aTHX_ self); /* actually only for Coro objects */
3398
3399		3625
3400	SV *	3626	SV *
3401	enable_times (int enabled = enable_times)	3627	enable_times (int enabled = enable_times)
3402	CODE:	3628	CODE:
3403	{	3629	{
…		…
3418	times (Coro::State self)	3644	times (Coro::State self)
3419	PPCODE:	3645	PPCODE:
3420	{	3646	{
3421	struct coro *current = SvSTATE (coro_current);	3647	struct coro *current = SvSTATE (coro_current);
3422		3648
3423	if (expect_false (current == self))	3649	if (ecb_expect_false (current == self))
3424	{	3650	{
3425	coro_times_update ();	3651	coro_times_update ();
3426	coro_times_add (SvSTATE (coro_current));	3652	coro_times_add (SvSTATE (coro_current));
3427	}	3653	}
3428		3654
3429	EXTEND (SP, 2);	3655	EXTEND (SP, 2);
3430	PUSHs (sv_2mortal (newSVnv (self->t_real [0] + self->t_real [1] * 1e-9)));	3656	PUSHs (sv_2mortal (newSVnv (self->t_real [0] + self->t_real [1] * 1e-9)));
3431	PUSHs (sv_2mortal (newSVnv (self->t_cpu [0] + self->t_cpu [1] * 1e-9)));	3657	PUSHs (sv_2mortal (newSVnv (self->t_cpu [0] + self->t_cpu [1] * 1e-9)));
3432		3658
3433	if (expect_false (current == self))	3659	if (ecb_expect_false (current == self))
3434	coro_times_sub (SvSTATE (coro_current));	3660	coro_times_sub (SvSTATE (coro_current));
3435	}	3661	}
3436		3662
3437	void	3663	void
3438	swap_sv (Coro::State coro, SV *sv, SV *swapsv)	3664	swap_sv (Coro::State coro, SV *sv, SV *swapsv)
…		…
3459	BOOT:	3685	BOOT:
3460	{	3686	{
3461	sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE);	3687	sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE);
3462	sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE);	3688	sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE);
3463	cv_coro_run = get_cv ( "Coro::_coro_run" , GV_ADD);	3689	cv_coro_run = get_cv ( "Coro::_coro_run" , GV_ADD);
3464	cv_coro_terminate = get_cv ( "Coro::terminate" , GV_ADD);
3465	coro_current = coro_get_sv (aTHX_ "Coro::current" , FALSE); SvREADONLY_on (coro_current);	3690	coro_current = coro_get_sv (aTHX_ "Coro::current" , FALSE); SvREADONLY_on (coro_current);
3466	av_async_pool = coro_get_av (aTHX_ "Coro::async_pool", TRUE);	3691	av_async_pool = coro_get_av (aTHX_ "Coro::async_pool", TRUE);
3467	av_destroy = coro_get_av (aTHX_ "Coro::destroy" , TRUE);	3692	av_destroy = coro_get_av (aTHX_ "Coro::destroy" , TRUE);
3468	sv_manager = coro_get_sv (aTHX_ "Coro::manager" , TRUE);	3693	sv_manager = coro_get_sv (aTHX_ "Coro::manager" , TRUE);
3469	sv_idle = coro_get_sv (aTHX_ "Coro::idle" , TRUE);	3694	sv_idle = coro_get_sv (aTHX_ "Coro::idle" , TRUE);
…		…
3508	api_ready (aTHX_ RETVAL);	3733	api_ready (aTHX_ RETVAL);
3509	OUTPUT:	3734	OUTPUT:
3510	RETVAL	3735	RETVAL
3511		3736
3512	void	3737	void
		3738	_destroy (Coro::State coro)
		3739	CODE:
		3740	/* used by the manager thread */
		3741	coro_state_destroy (aTHX_ coro);
		3742
		3743	void
		3744	on_destroy (Coro::State coro, SV *cb)
		3745	CODE:
		3746	coro_push_on_destroy (aTHX_ coro, newSVsv (cb));
		3747
		3748	void
		3749	join (...)
		3750	CODE:
		3751	CORO_EXECUTE_SLF_XS (slf_init_join);
		3752
		3753	void
3513	terminate (...)	3754	terminate (...)
3514	CODE:	3755	CODE:
3515	CORO_EXECUTE_SLF_XS (slf_init_terminate);	3756	CORO_EXECUTE_SLF_XS (slf_init_terminate);
		3757
		3758	void
		3759	cancel (...)
		3760	CODE:
		3761	CORO_EXECUTE_SLF_XS (slf_init_cancel);
		3762
		3763	int
		3764	safe_cancel (Coro::State self, ...)
		3765	C_ARGS: aTHX_ self, &ST (1), items - 1
3516		3766
3517	void	3767	void
3518	schedule (...)	3768	schedule (...)
3519	CODE:	3769	CODE:
3520	CORO_EXECUTE_SLF_XS (slf_init_schedule);	3770	CORO_EXECUTE_SLF_XS (slf_init_schedule);

Diff Legend

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