ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/Coro/Coro/State.xs

Comparing Coro/Coro/State.xs (file contents):
Revision 1.383 by root, Sun Feb 13 04:39:16 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);
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
…		…
314	PL_op->op_flags |= OPf_STACKED;	310	PL_op->op_flags |= OPf_STACKED;
315	PL_op->op_private = 0;	311	PL_op->op_private = 0;
316	return PL_ppaddr [OP_ENTERSUB](aTHX);	312	return PL_ppaddr [OP_ENTERSUB](aTHX);
317	}	313	}
318		314
		315	/** time stuff **************************************************************/
		316
		317	#ifdef HAS_GETTIMEOFDAY
		318
		319	ECB_INLINE void
		320	coro_u2time (pTHX_ UV ret[2])
		321	{
		322	struct timeval tv;
		323	gettimeofday (&tv, 0);
		324
		325	ret [0] = tv.tv_sec;
		326	ret [1] = tv.tv_usec;
		327	}
		328
		329	ECB_INLINE double
		330	coro_nvtime ()
		331	{
		332	struct timeval tv;
		333	gettimeofday (&tv, 0);
		334
		335	return tv.tv_sec + tv.tv_usec * 1e-6;
		336	}
		337
		338	ECB_INLINE void
		339	time_init (pTHX)
		340	{
		341	nvtime = coro_nvtime;
		342	u2time = coro_u2time;
		343	}
		344
		345	#else
		346
		347	ECB_INLINE void
		348	time_init (pTHX)
		349	{
		350	SV **svp;
		351
		352	require_pv ("Time/HiRes.pm");
		353
		354	svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
		355
		356	if (!svp) croak ("Time::HiRes is required, but missing. Caught");
		357	if (!SvIOK (*svp)) croak ("Time::NVtime isn't a function pointer. Caught");
		358
		359	nvtime = INT2PTR (double (*)(), SvIV (*svp));
		360
		361	svp = hv_fetch (PL_modglobal, "Time::U2time", 12, 0);
		362	u2time = INT2PTR (void (*)(pTHX_ UV ret[2]), SvIV (*svp));
		363	}
		364
		365	#endif
		366
319	/** lowlevel stuff **********************************************************/	367	/** lowlevel stuff **********************************************************/
320		368
321	static SV *	369	static SV * ecb_noinline
322	coro_get_sv (pTHX_ const char *name, int create)	370	coro_get_sv (pTHX_ const char *name, int create)
323	{	371	{
324	#if PERL_VERSION_ATLEAST (5,10,0)	372	#if PERL_VERSION_ATLEAST (5,10,0)
325	/* 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 */
326	get_sv (name, create);	374	get_sv (name, create);
327	#endif	375	#endif
328	return get_sv (name, create);	376	return get_sv (name, create);
329	}	377	}
330		378
331	static AV *	379	static AV * ecb_noinline
332	coro_get_av (pTHX_ const char *name, int create)	380	coro_get_av (pTHX_ const char *name, int create)
333	{	381	{
334	#if PERL_VERSION_ATLEAST (5,10,0)	382	#if PERL_VERSION_ATLEAST (5,10,0)
335	/* 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 */
336	get_av (name, create);	384	get_av (name, create);
337	#endif	385	#endif
338	return get_av (name, create);	386	return get_av (name, create);
339	}	387	}
340		388
341	static HV *	389	static HV * ecb_noinline
342	coro_get_hv (pTHX_ const char *name, int create)	390	coro_get_hv (pTHX_ const char *name, int create)
343	{	391	{
344	#if PERL_VERSION_ATLEAST (5,10,0)	392	#if PERL_VERSION_ATLEAST (5,10,0)
345	/* 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 */
346	get_hv (name, create);	394	get_hv (name, create);
347	#endif	395	#endif
348	return get_hv (name, create);	396	return get_hv (name, create);
349	}	397	}
350		398
351	INLINE void	399	ECB_INLINE void
352	coro_times_update ()	400	coro_times_update ()
353	{	401	{
354	#ifdef coro_clock_gettime	402	#ifdef coro_clock_gettime
355	struct timespec ts;	403	struct timespec ts;
356		404
…		…
369	time_real [0] = tv [0];	417	time_real [0] = tv [0];
370	time_real [1] = tv [1] * 1000;	418	time_real [1] = tv [1] * 1000;
371	#endif	419	#endif
372	}	420	}
373		421
374	INLINE void	422	ECB_INLINE void
375	coro_times_add (struct coro *c)	423	coro_times_add (struct coro *c)
376	{	424	{
377	c->t_real [1] += time_real [1];	425	c->t_real [1] += time_real [1];
378	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]; }
379	c->t_real [0] += time_real [0];	427	c->t_real [0] += time_real [0];
…		…
381	c->t_cpu [1] += time_cpu [1];	429	c->t_cpu [1] += time_cpu [1];
382	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]; }
383	c->t_cpu [0] += time_cpu [0];	431	c->t_cpu [0] += time_cpu [0];
384	}	432	}
385		433
386	INLINE void	434	ECB_INLINE void
387	coro_times_sub (struct coro *c)	435	coro_times_sub (struct coro *c)
388	{	436	{
389	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]; }
390	c->t_real [1] -= time_real [1];	438	c->t_real [1] -= time_real [1];
391	c->t_real [0] -= time_real [0];	439	c->t_real [0] -= time_real [0];
…		…
399	/* magic glue */	447	/* magic glue */
400		448
401	#define CORO_MAGIC_type_cv 26	449	#define CORO_MAGIC_type_cv 26
402	#define CORO_MAGIC_type_state PERL_MAGIC_ext	450	#define CORO_MAGIC_type_state PERL_MAGIC_ext
403		451
404	#define CORO_MAGIC_NN(sv, type) \	452	#define CORO_MAGIC_NN(sv, type) \
405	(expect_true (SvMAGIC (sv)->mg_type == type) \	453	(ecb_expect_true (SvMAGIC (sv)->mg_type == type) \
406	? SvMAGIC (sv) \	454	? SvMAGIC (sv) \
407	: mg_find (sv, type))	455	: mg_find (sv, type))
408		456
409	#define CORO_MAGIC(sv, type) \	457	#define CORO_MAGIC(sv, type) \
410	(expect_true (SvMAGIC (sv)) \	458	(ecb_expect_true (SvMAGIC (sv)) \
411	? CORO_MAGIC_NN (sv, type) \	459	? CORO_MAGIC_NN (sv, type) \
412	: 0)	460	: 0)
413		461
414	#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)
415	#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)
416		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
417	INLINE struct coro *	480	ECB_INLINE struct coro *
418	SvSTATE_ (pTHX_ SV *coro)	481	SvSTATE_ (pTHX_ SV *coro)
419	{	482	{
420	HV *stash;
421	MAGIC *mg;	483	MAGIC *mg;
422		484
423	if (SvROK (coro))	485	if (SvROK (coro))
424	coro = SvRV (coro);	486	coro = SvRV (coro);
425		487
426	if (expect_false (SvTYPE (coro) != SVt_PVHV))	488	mg = SvSTATEhv_p (aTHX_ coro);
		489	if (!mg)
427	croak ("Coro::State object required");	490	croak ("Coro::State object required");
428		491
429	stash = SvSTASH (coro);
430	if (expect_false (stash != coro_stash && stash != coro_state_stash))
431	{
432	/* very slow, but rare, check */
433	if (!sv_derived_from (sv_2mortal (newRV_inc (coro)), "Coro::State"))
434	croak ("Coro::State object required");
435	}
436
437	mg = CORO_MAGIC_state (coro);
438	return (struct coro *)mg->mg_ptr;	492	return (struct coro *)mg->mg_ptr;
439	}	493	}
440		494
441	#define SvSTATE(sv) SvSTATE_ (aTHX_ (sv))	495	#define SvSTATE(sv) SvSTATE_ (aTHX_ (sv))
442		496
…		…
445	#define SvSTATE_current SvSTATE_hv (SvRV (coro_current))	499	#define SvSTATE_current SvSTATE_hv (SvRV (coro_current))
446		500
447	/*****************************************************************************/	501	/*****************************************************************************/
448	/* padlist management and caching */	502	/* padlist management and caching */
449		503
450	static AV *	504	ECB_INLINE AV *
451	coro_derive_padlist (pTHX_ CV *cv)	505	coro_derive_padlist (pTHX_ CV *cv)
452	{	506	{
453	AV *padlist = CvPADLIST (cv);	507	AV *padlist = CvPADLIST (cv);
454	AV *newpadlist, *newpad;	508	AV *newpadlist, *newpad;
455		509
…		…
467	av_store (newpadlist, 1, (SV *)newpad);	521	av_store (newpadlist, 1, (SV *)newpad);
468		522
469	return newpadlist;	523	return newpadlist;
470	}	524	}
471		525
472	static void	526	ECB_INLINE void
473	free_padlist (pTHX_ AV *padlist)	527	free_padlist (pTHX_ AV *padlist)
474	{	528	{
475	/* may be during global destruction */	529	/* may be during global destruction */
476	if (!IN_DESTRUCT)	530	if (!IN_DESTRUCT)
477	{	531	{
…		…
520	0, 0, 0, 0,	574	0, 0, 0, 0,
521	coro_cv_free	575	coro_cv_free
522	};	576	};
523		577
524	/* the next two functions merely cache the padlists */	578	/* the next two functions merely cache the padlists */
525	static void	579	ECB_INLINE void
526	get_padlist (pTHX_ CV *cv)	580	get_padlist (pTHX_ CV *cv)
527	{	581	{
528	MAGIC *mg = CORO_MAGIC_cv (cv);	582	MAGIC *mg = CORO_MAGIC_cv (cv);
529	AV *av;	583	AV *av;
530		584
531	if (expect_true (mg && AvFILLp ((av = (AV *)mg->mg_obj)) >= 0))	585	if (ecb_expect_true (mg && AvFILLp ((av = (AV *)mg->mg_obj)) >= 0))
532	CvPADLIST (cv) = (AV *)AvARRAY (av)[AvFILLp (av)--];	586	CvPADLIST (cv) = (AV *)AvARRAY (av)[AvFILLp (av)--];
533	else	587	else
534	{	588	{
535	#if CORO_PREFER_PERL_FUNCTIONS	589	#if CORO_PREFER_PERL_FUNCTIONS
536	/* this is probably cleaner? but also slower! */	590	/* this is probably cleaner? but also slower! */
…		…
543	CvPADLIST (cv) = coro_derive_padlist (aTHX_ cv);	597	CvPADLIST (cv) = coro_derive_padlist (aTHX_ cv);
544	#endif	598	#endif
545	}	599	}
546	}	600	}
547		601
548	static void	602	ECB_INLINE void
549	put_padlist (pTHX_ CV *cv)	603	put_padlist (pTHX_ CV *cv)
550	{	604	{
551	MAGIC *mg = CORO_MAGIC_cv (cv);	605	MAGIC *mg = CORO_MAGIC_cv (cv);
552	AV *av;	606	AV *av;
553		607
554	if (expect_false (!mg))	608	if (ecb_expect_false (!mg))
555	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);
556		610
557	av = (AV *)mg->mg_obj;	611	av = (AV *)mg->mg_obj;
558		612
559	if (expect_false (AvFILLp (av) >= AvMAX (av)))	613	if (ecb_expect_false (AvFILLp (av) >= AvMAX (av)))
560	av_extend (av, AvFILLp (av) + 1);	614	av_extend (av, AvFILLp (av) + 1);
561		615
562	AvARRAY (av)[++AvFILLp (av)] = (SV *)CvPADLIST (cv);	616	AvARRAY (av)[++AvFILLp (av)] = (SV *)CvPADLIST (cv);
563	}	617	}
564		618
…		…
586	SvFLAGS (a) = (SvFLAGS (a) & keep) | (SvFLAGS (b ) & ~keep);	640	SvFLAGS (a) = (SvFLAGS (a) & keep) | (SvFLAGS (b ) & ~keep);
587	SvFLAGS (b) = (SvFLAGS (b) & keep) | (SvFLAGS (&tmp) & ~keep);	641	SvFLAGS (b) = (SvFLAGS (b) & keep) | (SvFLAGS (&tmp) & ~keep);
588		642
589	#if PERL_VERSION_ATLEAST (5,10,0)	643	#if PERL_VERSION_ATLEAST (5,10,0)
590	/* perl 5.10 complicates this _quite_ a bit, but it also is	644	/* perl 5.10 complicates this _quite_ a bit, but it also is
591	* is much faster, so no quarrels here. alternatively, we could	645	* much faster, so no quarrels here. alternatively, we could
592	* sv_upgrade to avoid this.	646	* sv_upgrade to avoid this.
593	*/	647	*/
594	{	648	{
595	/* swap sv_u */	649	/* swap sv_u */
596	tmp.sv_u = a->sv_u; a->sv_u = b->sv_u; b->sv_u = tmp.sv_u;	650	tmp.sv_u = a->sv_u; a->sv_u = b->sv_u; b->sv_u = tmp.sv_u;
…		…
609	}	663	}
610	#endif	664	#endif
611	}	665	}
612	}	666	}
613		667
614	#define SWAP_SVS(coro) \	668	#define SWAP_SVS(coro) \
615	if (expect_false ((coro)->swap_sv)) \	669	if (ecb_expect_false ((coro)->swap_sv)) \
616	swap_svs (aTHX_ (coro))	670	swap_svs (aTHX_ (coro))
617		671
618	static void	672	static void
619	on_enterleave_call (pTHX_ SV *cb);	673	on_enterleave_call (pTHX_ SV *cb);
620		674
…		…
640	dSP;	694	dSP;
641		695
642	CV *cv;	696	CV *cv;
643		697
644	/* now do the ugly restore mess */	698	/* now do the ugly restore mess */
645	while (expect_true (cv = (CV *)POPs))	699	while (ecb_expect_true (cv = (CV *)POPs))
646	{	700	{
647	put_padlist (aTHX_ cv); /* mark this padlist as available */	701	put_padlist (aTHX_ cv); /* mark this padlist as available */
648	CvDEPTH (cv) = PTR2IV (POPs);	702	CvDEPTH (cv) = PTR2IV (POPs);
649	CvPADLIST (cv) = (AV *)POPs;	703	CvPADLIST (cv) = (AV *)POPs;
650	}	704	}
…		…
653	}	707	}
654		708
655	slf_frame = c->slf_frame;	709	slf_frame = c->slf_frame;
656	CORO_THROW = c->except;	710	CORO_THROW = c->except;
657		711
658	if (expect_false (enable_times))	712	if (ecb_expect_false (enable_times))
659	{	713	{
660	if (expect_false (!times_valid))	714	if (ecb_expect_false (!times_valid))
661	coro_times_update ();	715	coro_times_update ();
662		716
663	coro_times_sub (c);	717	coro_times_sub (c);
664	}	718	}
665		719
666	if (expect_false (c->on_enter))	720	if (ecb_expect_false (c->on_enter))
667	{	721	{
668	int i;	722	int i;
669		723
670	for (i = 0; i <= AvFILLp (c->on_enter); ++i)	724	for (i = 0; i <= AvFILLp (c->on_enter); ++i)
671	on_enterleave_call (aTHX_ AvARRAY (c->on_enter)[i]);	725	on_enterleave_call (aTHX_ AvARRAY (c->on_enter)[i]);
…		…
677	static void	731	static void
678	save_perl (pTHX_ Coro__State c)	732	save_perl (pTHX_ Coro__State c)
679	{	733	{
680	SWAP_SVS (c);	734	SWAP_SVS (c);
681		735
682	if (expect_false (c->on_leave))	736	if (ecb_expect_false (c->on_leave))
683	{	737	{
684	int i;	738	int i;
685		739
686	for (i = AvFILLp (c->on_leave); i >= 0; --i)	740	for (i = AvFILLp (c->on_leave); i >= 0; --i)
687	on_enterleave_call (aTHX_ AvARRAY (c->on_leave)[i]);	741	on_enterleave_call (aTHX_ AvARRAY (c->on_leave)[i]);
688	}	742	}
689		743
690	times_valid = 0;	744	times_valid = 0;
691		745
692	if (expect_false (enable_times))	746	if (ecb_expect_false (enable_times))
693	{	747	{
694	coro_times_update (); times_valid = 1;	748	coro_times_update (); times_valid = 1;
695	coro_times_add (c);	749	coro_times_add (c);
696	}	750	}
697		751
…		…
711		765
712	XPUSHs (Nullsv);	766	XPUSHs (Nullsv);
713	/* this loop was inspired by pp_caller */	767	/* this loop was inspired by pp_caller */
714	for (;;)	768	for (;;)
715	{	769	{
716	while (expect_true (cxix >= 0))	770	while (ecb_expect_true (cxix >= 0))
717	{	771	{
718	PERL_CONTEXT *cx = &ccstk[cxix--];	772	PERL_CONTEXT *cx = &ccstk[cxix--];
719		773
720	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))
721	{	775	{
722	CV *cv = cx->blk_sub.cv;	776	CV *cv = cx->blk_sub.cv;
723		777
724	if (expect_true (CvDEPTH (cv)))	778	if (ecb_expect_true (CvDEPTH (cv)))
725	{	779	{
726	EXTEND (SP, 3);	780	EXTEND (SP, 3);
727	PUSHs ((SV *)CvPADLIST (cv));	781	PUSHs ((SV *)CvPADLIST (cv));
728	PUSHs (INT2PTR (SV *, (IV)CvDEPTH (cv)));	782	PUSHs (INT2PTR (SV *, (IV)CvDEPTH (cv)));
729	PUSHs ((SV *)cv);	783	PUSHs ((SV *)cv);
…		…
732	get_padlist (aTHX_ cv);	786	get_padlist (aTHX_ cv);
733	}	787	}
734	}	788	}
735	}	789	}
736		790
737	if (expect_true (top_si->si_type == PERLSI_MAIN))	791	if (ecb_expect_true (top_si->si_type == PERLSI_MAIN))
738	break;	792	break;
739		793
740	top_si = top_si->si_prev;	794	top_si = top_si->si_prev;
741	ccstk = top_si->si_cxstack;	795	ccstk = top_si->si_cxstack;
742	cxix = top_si->si_cxix;	796	cxix = top_si->si_cxix;
…		…
744		798
745	PUTBACK;	799	PUTBACK;
746	}	800	}
747		801
748	/* allocate some space on the context stack for our purposes */	802	/* allocate some space on the context stack for our purposes */
749	/* we manually unroll here, as usually 2 slots is enough */	803	if (ecb_expect_false (cxstack_ix + SLOT_COUNT >= cxstack_max))
750	if (SLOT_COUNT >= 1) CXINC;
751	if (SLOT_COUNT >= 2) CXINC;
752	if (SLOT_COUNT >= 3) CXINC;
753	{	804	{
754	unsigned int i;	805	unsigned int i;
		806
755	for (i = 3; i < SLOT_COUNT; ++i)	807	for (i = 0; i < SLOT_COUNT; ++i)
756	CXINC;	808	CXINC;
757	}	809
758	cxstack_ix -= SLOT_COUNT; /* undo allocation */	810	cxstack_ix -= SLOT_COUNT; /* undo allocation */
		811	}
759		812
760	c->mainstack = PL_mainstack;	813	c->mainstack = PL_mainstack;
761		814
762	{	815	{
763	perl_slots *slot = c->slot = (perl_slots *)(cxstack + cxstack_ix + 1);	816	perl_slots *slot = c->slot = (perl_slots *)(cxstack + cxstack_ix + 1);
…		…
784	# define coro_init_stacks(thx) init_stacks ()	837	# define coro_init_stacks(thx) init_stacks ()
785	#else	838	#else
786	static void	839	static void
787	coro_init_stacks (pTHX)	840	coro_init_stacks (pTHX)
788	{	841	{
789	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() */
790	PL_curstackinfo->si_type = PERLSI_MAIN;	843	PL_curstackinfo->si_type = PERLSI_MAIN;
791	PL_curstack = PL_curstackinfo->si_stack;	844	PL_curstack = PL_curstackinfo->si_stack;
792	PL_mainstack = PL_curstack; /* remember in case we switch stacks */	845	PL_mainstack = PL_curstack; /* remember in case we switch stacks */
793		846
794	PL_stack_base = AvARRAY(PL_curstack);	847	PL_stack_base = AvARRAY(PL_curstack);
…		…
901	#endif	954	#endif
902		955
903	/*	956	/*
904	* This overrides the default magic get method of %SIG elements.	957	* This overrides the default magic get method of %SIG elements.
905	* 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
906	* 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),
907	* readback here.	960	* we just provide our own readback here.
908	*/	961	*/
909	static int	962	static int ecb_cold
910	coro_sigelem_get (pTHX_ SV *sv, MAGIC *mg)	963	coro_sigelem_get (pTHX_ SV *sv, MAGIC *mg)
911	{	964	{
912	const char *s = MgPV_nolen_const (mg);	965	const char *s = MgPV_nolen_const (mg);
913		966
914	if (*s == '_')	967	if (*s == '_')
…		…
926	}	979	}
927		980
928	return orig_sigelem_get ? orig_sigelem_get (aTHX_ sv, mg) : 0;	981	return orig_sigelem_get ? orig_sigelem_get (aTHX_ sv, mg) : 0;
929	}	982	}
930		983
931	static int	984	static int ecb_cold
932	coro_sigelem_clr (pTHX_ SV *sv, MAGIC *mg)	985	coro_sigelem_clr (pTHX_ SV *sv, MAGIC *mg)
933	{	986	{
934	const char *s = MgPV_nolen_const (mg);	987	const char *s = MgPV_nolen_const (mg);
935		988
936	if (*s == '_')	989	if (*s == '_')
…		…
950	}	1003	}
951		1004
952	return orig_sigelem_clr ? orig_sigelem_clr (aTHX_ sv, mg) : 0;	1005	return orig_sigelem_clr ? orig_sigelem_clr (aTHX_ sv, mg) : 0;
953	}	1006	}
954		1007
955	static int	1008	static int ecb_cold
956	coro_sigelem_set (pTHX_ SV *sv, MAGIC *mg)	1009	coro_sigelem_set (pTHX_ SV *sv, MAGIC *mg)
957	{	1010	{
958	const char *s = MgPV_nolen_const (mg);	1011	const char *s = MgPV_nolen_const (mg);
959		1012
960	if (*s == '_')	1013	if (*s == '_')
…		…
995	return 1;	1048	return 1;
996	}	1049	}
997		1050
998	static UNOP init_perl_op;	1051	static UNOP init_perl_op;
999		1052
1000	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 */
1001	init_perl (pTHX_ struct coro *coro)	1054	init_perl (pTHX_ struct coro *coro)
1002	{	1055	{
1003	/*	1056	/*
1004	* emulate part of the perl startup here.	1057	* emulate part of the perl startup here.
1005	*/	1058	*/
…		…
1020	PL_parser = 0;	1073	PL_parser = 0;
1021	#endif	1074	#endif
1022	PL_hints = 0;	1075	PL_hints = 0;
1023		1076
1024	/* recreate the die/warn hooks */	1077	/* recreate the die/warn hooks */
1025	PL_diehook = 0; SvSetMagicSV (*hv_fetch (hv_sig, "__DIE__" , sizeof ("__DIE__" ) - 1, 1), rv_diehook );	1078	PL_diehook = SvREFCNT_inc (rv_diehook);
1026	PL_warnhook = 0; SvSetMagicSV (*hv_fetch (hv_sig, "__WARN__", sizeof ("__WARN__") - 1, 1), rv_warnhook);	1079	PL_warnhook = SvREFCNT_inc (rv_warnhook);
1027		1080
1028	GvSV (PL_defgv) = newSV (0);	1081	GvSV (PL_defgv) = newSV (0);
1029	GvAV (PL_defgv) = coro->args; coro->args = 0;	1082	GvAV (PL_defgv) = coro->args; coro->args = 0;
1030	GvSV (PL_errgv) = newSV (0);	1083	GvSV (PL_errgv) = newSV (0);
1031	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);
…		…
1052	/* 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
1053	* 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.
1054	*/	1107	*/
1055	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 */
1056	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;
1057		1111
1058	/* 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 */
1059	init_perl_op.op_next = PL_op;	1113	init_perl_op.op_next = PL_op;
1060	init_perl_op.op_type = OP_ENTERSUB;	1114	init_perl_op.op_type = OP_ENTERSUB;
1061	init_perl_op.op_ppaddr = pp_slf;	1115	init_perl_op.op_ppaddr = pp_slf;
…		…
1066	/* copy throw, in case it was set before init_perl */	1120	/* copy throw, in case it was set before init_perl */
1067	CORO_THROW = coro->except;	1121	CORO_THROW = coro->except;
1068		1122
1069	SWAP_SVS (coro);	1123	SWAP_SVS (coro);
1070		1124
1071	if (expect_false (enable_times))	1125	if (ecb_expect_false (enable_times))
1072	{	1126	{
1073	coro_times_update ();	1127	coro_times_update ();
1074	coro_times_sub (coro);	1128	coro_times_sub (coro);
1075	}	1129	}
1076	}	1130	}
…		…
1100	destroy_perl (pTHX_ struct coro *coro)	1154	destroy_perl (pTHX_ struct coro *coro)
1101	{	1155	{
1102	SV *svf [9];	1156	SV *svf [9];
1103		1157
1104	{	1158	{
		1159	SV *old_current = SvRV (coro_current);
1105	struct coro *current = SvSTATE_current;	1160	struct coro *current = SvSTATE (old_current);
1106		1161
1107	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));
1108		1163
1109	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
1110	load_perl (aTHX_ coro);	1169	load_perl (aTHX_ coro);
1111		1170
1112	coro_unwind_stacks (aTHX);	1171	coro_unwind_stacks (aTHX);
1113	coro_destruct_stacks (aTHX);
1114		1172
1115	/* restore swapped sv's */	1173	/* restore swapped sv's */
1116	SWAP_SVS (coro);	1174	SWAP_SVS (coro);
		1175
		1176	coro_destruct_stacks (aTHX);
1117		1177
1118	// now save some sv's to be free'd later	1178	// now save some sv's to be free'd later
1119	svf [0] = GvSV (PL_defgv);	1179	svf [0] = GvSV (PL_defgv);
1120	svf [1] = (SV *)GvAV (PL_defgv);	1180	svf [1] = (SV *)GvAV (PL_defgv);
1121	svf [2] = GvSV (PL_errgv);	1181	svf [2] = GvSV (PL_errgv);
…		…
1125	svf [6] = (SV *)GvHV (PL_hintgv);	1185	svf [6] = (SV *)GvHV (PL_hintgv);
1126	svf [7] = PL_diehook;	1186	svf [7] = PL_diehook;
1127	svf [8] = PL_warnhook;	1187	svf [8] = PL_warnhook;
1128	assert (9 == sizeof (svf) / sizeof (*svf));	1188	assert (9 == sizeof (svf) / sizeof (*svf));
1129		1189
		1190	SvRV_set (coro_current, old_current);
		1191
1130	load_perl (aTHX_ current);	1192	load_perl (aTHX_ current);
1131	}	1193	}
1132		1194
1133	{	1195	{
1134	unsigned int i;	1196	unsigned int i;
…		…
1141	SvREFCNT_dec (coro->invoke_cb);	1203	SvREFCNT_dec (coro->invoke_cb);
1142	SvREFCNT_dec (coro->invoke_av);	1204	SvREFCNT_dec (coro->invoke_av);
1143	}	1205	}
1144	}	1206	}
1145		1207
1146	INLINE void	1208	ECB_INLINE void
1147	free_coro_mortal (pTHX)	1209	free_coro_mortal (pTHX)
1148	{	1210	{
1149	if (expect_true (coro_mortal))	1211	if (ecb_expect_true (coro_mortal))
1150	{	1212	{
1151	SvREFCNT_dec (coro_mortal);	1213	SvREFCNT_dec ((SV *)coro_mortal);
1152	coro_mortal = 0;	1214	coro_mortal = 0;
1153	}	1215	}
1154	}	1216	}
1155		1217
1156	static int	1218	static int
…		…
1289		1351
1290	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 */
1291	}	1353	}
1292		1354
1293	/* 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 */
1294	static void NOINLINE	1356	static void ecb_noinline
1295	cctx_prepare (pTHX)	1357	cctx_prepare (pTHX)
1296	{	1358	{
1297	PL_top_env = &PL_start_env;	1359	PL_top_env = &PL_start_env;
1298		1360
1299	if (cctx_current->flags & CC_TRACE)	1361	if (cctx_current->flags & CC_TRACE)
…		…
1310	slf_frame.prepare = slf_prepare_set_stacklevel;	1372	slf_frame.prepare = slf_prepare_set_stacklevel;
1311	slf_frame.check = slf_check_set_stacklevel;	1373	slf_frame.check = slf_check_set_stacklevel;
1312	}	1374	}
1313		1375
1314	/* 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 */
1315	INLINE void	1377	ECB_INLINE void
1316	transfer_tail (pTHX)	1378	transfer_tail (pTHX)
1317	{	1379	{
1318	free_coro_mortal (aTHX);	1380	free_coro_mortal (aTHX);
1319	}	1381	}
1320		1382
…		…
1443	cctx_destroy (coro_cctx *cctx)	1505	cctx_destroy (coro_cctx *cctx)
1444	{	1506	{
1445	if (!cctx)	1507	if (!cctx)
1446	return;	1508	return;
1447		1509
1448	assert (("FATAL: tried to destroy current cctx", cctx != cctx_current));//D temporary?	1510	assert (("FATAL: tried to destroy current cctx", cctx != cctx_current));
1449		1511
1450	--cctx_count;	1512	--cctx_count;
1451	coro_destroy (&cctx->cctx);	1513	coro_destroy (&cctx->cctx);
1452		1514
1453	/* coro_transfer creates new, empty cctx's */	1515	/* coro_transfer creates new, empty cctx's */
…		…
1472	#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))
1473		1535
1474	static coro_cctx *	1536	static coro_cctx *
1475	cctx_get (pTHX)	1537	cctx_get (pTHX)
1476	{	1538	{
1477	while (expect_true (cctx_first))	1539	while (ecb_expect_true (cctx_first))
1478	{	1540	{
1479	coro_cctx *cctx = cctx_first;	1541	coro_cctx *cctx = cctx_first;
1480	cctx_first = cctx->next;	1542	cctx_first = cctx->next;
1481	--cctx_idle;	1543	--cctx_idle;
1482		1544
1483	if (expect_true (!CCTX_EXPIRED (cctx)))	1545	if (ecb_expect_true (!CCTX_EXPIRED (cctx)))
1484	return cctx;	1546	return cctx;
1485		1547
1486	cctx_destroy (cctx);	1548	cctx_destroy (cctx);
1487	}	1549	}
1488		1550
…		…
1493	cctx_put (coro_cctx *cctx)	1555	cctx_put (coro_cctx *cctx)
1494	{	1556	{
1495	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));
1496		1558
1497	/* free another cctx if overlimit */	1559	/* free another cctx if overlimit */
1498	if (expect_false (cctx_idle >= cctx_max_idle))	1560	if (ecb_expect_false (cctx_idle >= cctx_max_idle))
1499	{	1561	{
1500	coro_cctx *first = cctx_first;	1562	coro_cctx *first = cctx_first;
1501	cctx_first = first->next;	1563	cctx_first = first->next;
1502	--cctx_idle;	1564	--cctx_idle;
1503		1565
…		…
1514	static void	1576	static void
1515	transfer_check (pTHX_ struct coro *prev, struct coro *next)	1577	transfer_check (pTHX_ struct coro *prev, struct coro *next)
1516	{	1578	{
1517	/* TODO: throwing up here is considered harmful */	1579	/* TODO: throwing up here is considered harmful */
1518		1580
1519	if (expect_true (prev != next))	1581	if (ecb_expect_true (prev != next))
1520	{	1582	{
1521	if (expect_false (!(prev->flags & (CF_RUNNING | CF_NEW))))	1583	if (ecb_expect_false (!(prev->flags & (CF_RUNNING | CF_NEW))))
1522	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,");
1523		1585
1524	if (expect_false (next->flags & (CF_RUNNING | CF_DESTROYED | CF_SUSPENDED)))	1586	if (ecb_expect_false (next->flags & (CF_RUNNING | CF_ZOMBIE | CF_SUSPENDED)))
1525	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,");
1526		1588
1527	#if !PERL_VERSION_ATLEAST (5,10,0)	1589	#if !PERL_VERSION_ATLEAST (5,10,0)
1528	if (expect_false (PL_lex_state != LEX_NOTPARSING))	1590	if (ecb_expect_false (PL_lex_state != LEX_NOTPARSING))
1529	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,");
1530	#endif	1592	#endif
1531	}	1593	}
1532	}	1594	}
1533		1595
1534	/* always use the TRANSFER macro */	1596	/* always use the TRANSFER macro */
1535	static void NOINLINE /* noinline so we have a fixed stackframe */	1597	static void ecb_noinline /* noinline so we have a fixed stackframe */
1536	transfer (pTHX_ struct coro *prev, struct coro *next, int force_cctx)	1598	transfer (pTHX_ struct coro *prev, struct coro *next, int force_cctx)
1537	{	1599	{
1538	dSTACKLEVEL;	1600	dSTACKLEVEL;
1539		1601
1540	/* sometimes transfer is only called to set idle_sp */	1602	/* sometimes transfer is only called to set idle_sp */
1541	if (expect_false (!prev))	1603	if (ecb_expect_false (!prev))
1542	{	1604	{
1543	cctx_current->idle_sp = STACKLEVEL;	1605	cctx_current->idle_sp = STACKLEVEL;
1544	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 */
1545	}	1607	}
1546	else if (expect_true (prev != next))	1608	else if (ecb_expect_true (prev != next))
1547	{	1609	{
1548	coro_cctx *cctx_prev;	1610	coro_cctx *cctx_prev;
1549		1611
1550	if (expect_false (prev->flags & CF_NEW))	1612	if (ecb_expect_false (prev->flags & CF_NEW))
1551	{	1613	{
1552	/* create a new empty/source context */	1614	/* create a new empty/source context */
1553	prev->flags &= ~CF_NEW;	1615	prev->flags &= ~CF_NEW;
1554	prev->flags |= CF_RUNNING;	1616	prev->flags |= CF_RUNNING;
1555	}	1617	}
…		…
1558	next->flags |= CF_RUNNING;	1620	next->flags |= CF_RUNNING;
1559		1621
1560	/* first get rid of the old state */	1622	/* first get rid of the old state */
1561	save_perl (aTHX_ prev);	1623	save_perl (aTHX_ prev);
1562		1624
1563	if (expect_false (next->flags & CF_NEW))	1625	if (ecb_expect_false (next->flags & CF_NEW))
1564	{	1626	{
1565	/* need to start coroutine */	1627	/* need to start coroutine */
1566	next->flags &= ~CF_NEW;	1628	next->flags &= ~CF_NEW;
1567	/* setup coroutine call */	1629	/* setup coroutine call */
1568	init_perl (aTHX_ next);	1630	init_perl (aTHX_ next);
1569	}	1631	}
1570	else	1632	else
1571	load_perl (aTHX_ next);	1633	load_perl (aTHX_ next);
1572		1634
1573	/* possibly untie and reuse the cctx */	1635	/* possibly untie and reuse the cctx */
1574	if (expect_true (	1636	if (ecb_expect_true (
1575	cctx_current->idle_sp == STACKLEVEL	1637	cctx_current->idle_sp == STACKLEVEL
1576	&& !(cctx_current->flags & CC_TRACE)	1638	&& !(cctx_current->flags & CC_TRACE)
1577	&& !force_cctx	1639	&& !force_cctx
1578	))	1640	))
1579	{	1641	{
1580	/* 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 */
1581	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));
1582		1644
1583	/* 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. */
1584	/* 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 */
1585	if (expect_false (CCTX_EXPIRED (cctx_current)))	1647	if (ecb_expect_false (CCTX_EXPIRED (cctx_current)))
1586	if (expect_true (!next->cctx))	1648	if (ecb_expect_true (!next->cctx))
1587	next->cctx = cctx_get (aTHX);	1649	next->cctx = cctx_get (aTHX);
1588		1650
1589	cctx_put (cctx_current);	1651	cctx_put (cctx_current);
1590	}	1652	}
1591	else	1653	else
1592	prev->cctx = cctx_current;	1654	prev->cctx = cctx_current;
1593		1655
1594	++next->usecount;	1656	++next->usecount;
1595		1657
1596	cctx_prev = cctx_current;	1658	cctx_prev = cctx_current;
1597	cctx_current = expect_false (next->cctx) ? next->cctx : cctx_get (aTHX);	1659	cctx_current = ecb_expect_false (next->cctx) ? next->cctx : cctx_get (aTHX);
1598		1660
1599	next->cctx = 0;	1661	next->cctx = 0;
1600		1662
1601	if (expect_false (cctx_prev != cctx_current))	1663	if (ecb_expect_false (cctx_prev != cctx_current))
1602	{	1664	{
1603	cctx_prev->top_env = PL_top_env;	1665	cctx_prev->top_env = PL_top_env;
1604	PL_top_env = cctx_current->top_env;	1666	PL_top_env = cctx_current->top_env;
1605	coro_transfer (&cctx_prev->cctx, &cctx_current->cctx);	1667	coro_transfer (&cctx_prev->cctx, &cctx_current->cctx);
1606	}	1668	}
…		…
1612	#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))
1613	#define TRANSFER_CHECK(ta) transfer_check (aTHX_ (ta).prev, (ta).next)	1675	#define TRANSFER_CHECK(ta) transfer_check (aTHX_ (ta).prev, (ta).next)
1614		1676
1615	/** high level stuff ********************************************************/	1677	/** high level stuff ********************************************************/
1616		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 */
1617	static int	1681	static void
		1682	coro_call_on_destroy (pTHX_ struct coro *coro);
		1683
		1684	static void
1618	coro_state_destroy (pTHX_ struct coro *coro)	1685	coro_state_destroy (pTHX_ struct coro *coro)
1619	{	1686	{
1620	if (coro->flags & CF_DESTROYED)	1687	if (coro->flags & CF_ZOMBIE)
1621	return 0;	1688	return;
1622		1689
1623	if (coro->on_destroy && !PL_dirty)
1624	coro->on_destroy (aTHX_ coro);	1690	slf_destroy (aTHX_ coro);
1625		1691
1626	coro->flags |= CF_DESTROYED;	1692	coro->flags |= CF_ZOMBIE;
1627		1693
1628	if (coro->flags & CF_READY)	1694	if (coro->flags & CF_READY)
1629	{	1695	{
1630	/* reduce nready, as destroying a ready coro effectively unreadies it */	1696	/* reduce nready, as destroying a ready coro effectively unreadies it */
1631	/* alternative: look through all ready queues and remove the coro */	1697	/* alternative: look through all ready queues and remove the coro */
1632	--coro_nready;	1698	--coro_nready;
1633	}	1699	}
1634	else	1700	else
1635	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;
1636		1706
1637	if (coro->mainstack	1707	if (coro->mainstack
1638	&& coro->mainstack != main_mainstack	1708	&& coro->mainstack != main_mainstack
1639	&& coro->slot	1709	&& coro->slot
1640	&& !PL_dirty)	1710	&& !PL_dirty)
1641	destroy_perl (aTHX_ coro);	1711	destroy_perl (aTHX_ coro);
1642		1712
1643	if (coro->next) coro->next->prev = coro->prev;
1644	if (coro->prev) coro->prev->next = coro->next;
1645	if (coro == coro_first) coro_first = coro->next;
1646
1647	cctx_destroy (coro->cctx);	1713	cctx_destroy (coro->cctx);
1648	SvREFCNT_dec (coro->startcv);	1714	SvREFCNT_dec (coro->startcv);
1649	SvREFCNT_dec (coro->args);	1715	SvREFCNT_dec (coro->args);
1650	SvREFCNT_dec (coro->swap_sv);	1716	SvREFCNT_dec (coro->swap_sv);
1651	SvREFCNT_dec (CORO_THROW);	1717	SvREFCNT_dec (CORO_THROW);
1652		1718
1653	return 1;	1719	coro_call_on_destroy (aTHX_ coro);
		1720
		1721	/* more destruction mayhem in coro_state_free */
1654	}	1722	}
1655		1723
1656	static int	1724	static int
1657	coro_state_free (pTHX_ SV *sv, MAGIC *mg)	1725	coro_state_free (pTHX_ SV *sv, MAGIC *mg)
1658	{	1726	{
1659	struct coro *coro = (struct coro *)mg->mg_ptr;	1727	struct coro *coro = (struct coro *)mg->mg_ptr;
1660	mg->mg_ptr = 0;	1728	mg->mg_ptr = 0;
1661		1729
1662	coro->hv = 0;
1663
1664	if (--coro->refcnt < 0)
1665	{
1666	coro_state_destroy (aTHX_ coro);	1730	coro_state_destroy (aTHX_ coro);
		1731	SvREFCNT_dec (coro->on_destroy);
		1732	SvREFCNT_dec (coro->status);
		1733
1667	Safefree (coro);	1734	Safefree (coro);
1668	}
1669		1735
1670	return 0;	1736	return 0;
1671	}	1737	}
1672		1738
1673	static int	1739	static int ecb_cold
1674	coro_state_dup (pTHX_ MAGIC *mg, CLONE_PARAMS *params)	1740	coro_state_dup (pTHX_ MAGIC *mg, CLONE_PARAMS *params)
1675	{	1741	{
1676	struct coro *coro = (struct coro *)mg->mg_ptr;	1742	/* called when perl clones the current process the slow way (windows process emulation) */
1677		1743	/* WE SIMply nuke the pointers in the copy, causing perl to croak */
1678	++coro->refcnt;	1744	mg->mg_ptr = 0;
		1745	mg->mg_virtual = 0;
1679		1746
1680	return 0;	1747	return 0;
1681	}	1748	}
1682		1749
1683	static MGVTBL coro_state_vtbl = {	1750	static MGVTBL coro_state_vtbl = {
…		…
1708	TRANSFER (ta, 1);	1775	TRANSFER (ta, 1);
1709	}	1776	}
1710		1777
1711	/** Coro ********************************************************************/	1778	/** Coro ********************************************************************/
1712		1779
1713	INLINE void	1780	ECB_INLINE void
1714	coro_enq (pTHX_ struct coro *coro)	1781	coro_enq (pTHX_ struct coro *coro)
1715	{	1782	{
1716	struct coro **ready = coro_ready [coro->prio - CORO_PRIO_MIN];	1783	struct coro **ready = coro_ready [coro->prio - CORO_PRIO_MIN];
1717		1784
1718	SvREFCNT_inc_NN (coro->hv);	1785	SvREFCNT_inc_NN (coro->hv);
…		…
1720	coro->next_ready = 0;	1787	coro->next_ready = 0;
1721	*(ready [0] ? &ready [1]->next_ready : &ready [0]) = coro;	1788	*(ready [0] ? &ready [1]->next_ready : &ready [0]) = coro;
1722	ready [1] = coro;	1789	ready [1] = coro;
1723	}	1790	}
1724		1791
1725	INLINE struct coro *	1792	ECB_INLINE struct coro *
1726	coro_deq (pTHX)	1793	coro_deq (pTHX)
1727	{	1794	{
1728	int prio;	1795	int prio;
1729		1796
1730	for (prio = CORO_PRIO_MAX - CORO_PRIO_MIN + 1; --prio >= 0; )	1797	for (prio = CORO_PRIO_MAX - CORO_PRIO_MIN + 1; --prio >= 0; )
…		…
1783	{	1850	{
1784	return !!(SvSTATE (coro_sv)->flags & CF_READY);	1851	return !!(SvSTATE (coro_sv)->flags & CF_READY);
1785	}	1852	}
1786		1853
1787	/* expects to own a reference to next->hv */	1854	/* expects to own a reference to next->hv */
1788	INLINE void	1855	ECB_INLINE void
1789	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)
1790	{	1857	{
1791	SV *prev_sv = SvRV (coro_current);	1858	SV *prev_sv = SvRV (coro_current);
1792		1859
1793	ta->prev = SvSTATE_hv (prev_sv);	1860	ta->prev = SvSTATE_hv (prev_sv);
…		…
1806	{	1873	{
1807	for (;;)	1874	for (;;)
1808	{	1875	{
1809	struct coro *next = coro_deq (aTHX);	1876	struct coro *next = coro_deq (aTHX);
1810		1877
1811	if (expect_true (next))	1878	if (ecb_expect_true (next))
1812	{	1879	{
1813	/* cannot transfer to destroyed coros, skip and look for next */	1880	/* cannot transfer to destroyed coros, skip and look for next */
1814	if (expect_false (next->flags & (CF_DESTROYED | CF_SUSPENDED)))	1881	if (ecb_expect_false (next->flags & (CF_ZOMBIE | CF_SUSPENDED)))
1815	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 */
1816	else	1883	else
1817	{	1884	{
1818	next->flags &= ~CF_READY;	1885	next->flags &= ~CF_READY;
1819	--coro_nready;	1886	--coro_nready;
…		…
1852	}	1919	}
1853	}	1920	}
1854	}	1921	}
1855	}	1922	}
1856		1923
1857	INLINE void	1924	ECB_INLINE void
1858	prepare_cede (pTHX_ struct coro_transfer_args *ta)	1925	prepare_cede (pTHX_ struct coro_transfer_args *ta)
1859	{	1926	{
1860	api_ready (aTHX_ coro_current);	1927	api_ready (aTHX_ coro_current);
1861	prepare_schedule (aTHX_ ta);	1928	prepare_schedule (aTHX_ ta);
1862	}	1929	}
1863		1930
1864	INLINE void	1931	ECB_INLINE void
1865	prepare_cede_notself (pTHX_ struct coro_transfer_args *ta)	1932	prepare_cede_notself (pTHX_ struct coro_transfer_args *ta)
1866	{	1933	{
1867	SV *prev = SvRV (coro_current);	1934	SV *prev = SvRV (coro_current);
1868		1935
1869	if (coro_nready)	1936	if (coro_nready)
…		…
1899	{	1966	{
1900	struct coro_transfer_args ta;	1967	struct coro_transfer_args ta;
1901		1968
1902	prepare_cede (aTHX_ &ta);	1969	prepare_cede (aTHX_ &ta);
1903		1970
1904	if (expect_true (ta.prev != ta.next))	1971	if (ecb_expect_true (ta.prev != ta.next))
1905	{	1972	{
1906	TRANSFER (ta, 1);	1973	TRANSFER (ta, 1);
1907	return 1;	1974	return 1;
1908	}	1975	}
1909	else	1976	else
…		…
1952	coro->slot->runops = RUNOPS_DEFAULT;	2019	coro->slot->runops = RUNOPS_DEFAULT;
1953	}	2020	}
1954	}	2021	}
1955		2022
1956	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
1957	coro_call_on_destroy (pTHX_ struct coro *coro)	2100	coro_call_on_destroy (pTHX_ struct coro *coro)
1958	{	2101	{
1959	SV **on_destroyp = hv_fetch (coro->hv, "_on_destroy", sizeof ("_on_destroy") - 1, 0);	2102	AV *od = coro->on_destroy;
1960	SV **statusp = hv_fetch (coro->hv, "_status", sizeof ("_status") - 1, 0);
1961		2103
1962	if (on_destroyp)	2104	if (!od)
1963	{	2105	return;
1964	AV *on_destroy = (AV *)SvRV (*on_destroyp);
1965		2106
1966	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
1967	{	2115	{
1968	dSP; /* don't disturb outer sp */	2116	dSP; /* don't disturb outer sp */
1969	SV *cb = av_pop (on_destroy);
1970
1971	PUSHMARK (SP);	2117	PUSHMARK (SP);
1972		2118
1973	if (statusp)	2119	if (coro->status)
1974	{	2120	{
1975	int i;	2121	PUTBACK;
1976	AV *status = (AV *)SvRV (*statusp);	2122	coro_push_av (aTHX_ coro->status, G_ARRAY);
1977	EXTEND (SP, AvFILLp (status) + 1);	2123	SPAGAIN;
1978
1979	for (i = 0; i <= AvFILLp (status); ++i)
1980	PUSHs (AvARRAY (status)[i]);
1981	}	2124	}
1982		2125
1983	PUTBACK;	2126	PUTBACK;
1984	call_sv (sv_2mortal (cb), G_VOID | G_DISCARD);	2127	call_sv (cb, G_VOID | G_DISCARD);
1985	}	2128	}
1986	}	2129	}
1987	}	2130	}
1988		2131
1989	static void	2132	static void
1990	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)
1991	{	2134	{
1992	int i;	2135	AV *av;
1993	HV *hv = (HV *)SvRV (coro_current);	2136
1994	AV *av = newAV ();	2137	if (coro->status)
		2138	{
		2139	av = coro->status;
		2140	av_clear (av);
		2141	}
		2142	else
		2143	av = coro->status = newAV ();
1995		2144
1996	/* items are actually not so common, so optimise for this case */	2145	/* items are actually not so common, so optimise for this case */
1997	if (items)	2146	if (items)
1998	{	2147	{
		2148	int i;
		2149
1999	av_extend (av, items - 1);	2150	av_extend (av, items - 1);
2000		2151
2001	for (i = 0; i < items; ++i)	2152	for (i = 0; i < items; ++i)
2002	av_push (av, SvREFCNT_inc_NN (arg [i]));	2153	av_push (av, SvREFCNT_inc_NN (arg [i]));
2003	}	2154	}
		2155	}
2004		2156
2005	hv_store (hv, "_status", sizeof ("_status") - 1, newRV_noinc ((SV *)av), 0);	2157	static void
2006		2158	slf_init_terminate_cancel_common (pTHX_ struct CoroSLF *frame, HV *coro_hv)
		2159	{
2007	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 */
2008	api_ready (aTHX_ sv_manager);	2161	api_ready (aTHX_ sv_manager);
2009		2162
2010	frame->prepare = prepare_schedule;	2163	frame->prepare = prepare_schedule;
2011	frame->check = slf_check_repeat;	2164	frame->check = slf_check_repeat;
2012		2165
2013	/* as a minor optimisation, we could unwind all stacks here */	2166	/* as a minor optimisation, we could unwind all stacks here */
2014	/* 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 */
2015	/*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;
2016	}	2272	}
2017		2273
2018	/*****************************************************************************/	2274	/*****************************************************************************/
2019	/* async pool handler */	2275	/* async pool handler */
2020		2276
…		…
2051	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)
2052	{	2308	{
2053	HV *hv = (HV *)SvRV (coro_current);	2309	HV *hv = (HV *)SvRV (coro_current);
2054	struct coro *coro = SvSTATE_hv ((SV *)hv);	2310	struct coro *coro = SvSTATE_hv ((SV *)hv);
2055		2311
2056	if (expect_true (coro->saved_deffh))	2312	if (ecb_expect_true (coro->saved_deffh))
2057	{	2313	{
2058	/* subsequent iteration */	2314	/* subsequent iteration */
2059	SvREFCNT_dec ((SV *)PL_defoutgv); PL_defoutgv = (GV *)coro->saved_deffh;	2315	SvREFCNT_dec ((SV *)PL_defoutgv); PL_defoutgv = (GV *)coro->saved_deffh;
2060	coro->saved_deffh = 0;	2316	coro->saved_deffh = 0;
2061		2317
2062	if (coro_rss (aTHX_ coro) > SvUV (sv_pool_rss)	2318	if (coro_rss (aTHX_ coro) > SvUV (sv_pool_rss)
2063	|| av_len (av_async_pool) + 1 >= SvIV (sv_pool_size))	2319	|| av_len (av_async_pool) + 1 >= SvIV (sv_pool_size))
2064	{	2320	{
2065	coro->invoke_cb = SvREFCNT_inc_NN ((SV *)cv_coro_terminate);	2321	slf_init_terminate_cancel_common (aTHX_ frame, hv);
2066	coro->invoke_av = newAV ();	2322	return;
2067
2068	frame->prepare = prepare_nop;
2069	}	2323	}
2070	else	2324	else
2071	{	2325	{
2072	av_clear (GvAV (PL_defgv));	2326	av_clear (GvAV (PL_defgv));
2073	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);
…		…
2296	static void	2550	static void
2297	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)
2298	{	2552	{
2299	frame->prepare = prepare_cede_notself;	2553	frame->prepare = prepare_cede_notself;
2300	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;
2301	}	2572	}
2302		2573
2303	/*	2574	/*
2304	* these not obviously related functions are all rolled into one	2575	* these not obviously related functions are all rolled into one
2305	* 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
…		…
2312	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 */
2313		2584
2314	/* 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 */
2315	/* the latter happens when a new coro has been started */	2586	/* the latter happens when a new coro has been started */
2316	/* or when a new cctx was attached to an existing coroutine */	2587	/* or when a new cctx was attached to an existing coroutine */
2317	if (expect_true (!slf_frame.prepare))	2588	if (ecb_expect_true (!slf_frame.prepare))
2318	{	2589	{
2319	/* first iteration */	2590	/* first iteration */
2320	dSP;	2591	dSP;
2321	SV **arg = PL_stack_base + TOPMARK + 1;	2592	SV **arg = PL_stack_base + TOPMARK + 1;
2322	int items = SP - arg; /* args without function object */	2593	int items = SP - arg; /* args without function object */
…		…
2363	while (slf_frame.check (aTHX_ &slf_frame));	2634	while (slf_frame.check (aTHX_ &slf_frame));
2364		2635
2365	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 */
2366		2637
2367	/* exception handling */	2638	/* exception handling */
2368	if (expect_false (CORO_THROW))	2639	if (ecb_expect_false (CORO_THROW))
2369	{	2640	{
2370	SV *exception = sv_2mortal (CORO_THROW);	2641	SV *exception = sv_2mortal (CORO_THROW);
2371		2642
2372	CORO_THROW = 0;	2643	CORO_THROW = 0;
2373	sv_setsv (ERRSV, exception);	2644	sv_setsv (ERRSV, exception);
2374	croak (0);	2645	croak (0);
2375	}	2646	}
2376		2647
2377	/* return value handling - mostly like entersub */	2648	/* return value handling - mostly like entersub */
2378	/* make sure we put something on the stack in scalar context */	2649	/* make sure we put something on the stack in scalar context */
2379	if (GIMME_V == G_SCALAR)	2650	if (GIMME_V == G_SCALAR
		2651	&& ecb_expect_false (PL_stack_sp != PL_stack_base + checkmark + 1))
2380	{	2652	{
2381	dSP;	2653	dSP;
2382	SV **bot = PL_stack_base + checkmark;	2654	SV **bot = PL_stack_base + checkmark;
2383		2655
2384	if (sp == bot) /* too few, push undef */	2656	if (sp == bot) /* too few, push undef */
2385	bot [1] = &PL_sv_undef;	2657	bot [1] = &PL_sv_undef;
2386	else if (sp != bot + 1) /* too many, take last one */	2658	else /* too many, take last one */
2387	bot [1] = *sp;	2659	bot [1] = *sp;
2388		2660
2389	SP = bot + 1;	2661	SP = bot + 1;
2390		2662
2391	PUTBACK;	2663	PUTBACK;
…		…
2498	{	2770	{
2499	PerlIOBuf base;	2771	PerlIOBuf base;
2500	NV next, every;	2772	NV next, every;
2501	} PerlIOCede;	2773	} PerlIOCede;
2502		2774
2503	static IV	2775	static IV ecb_cold
2504	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)
2505	{	2777	{
2506	PerlIOCede *self = PerlIOSelf (f, PerlIOCede);	2778	PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
2507		2779
2508	self->every = SvCUR (arg) ? SvNV (arg) : 0.01;	2780	self->every = SvCUR (arg) ? SvNV (arg) : 0.01;
2509	self->next = nvtime () + self->every;	2781	self->next = nvtime () + self->every;
2510		2782
2511	return PerlIOBuf_pushed (aTHX_ f, mode, Nullsv, tab);	2783	return PerlIOBuf_pushed (aTHX_ f, mode, Nullsv, tab);
2512	}	2784	}
2513		2785
2514	static SV *	2786	static SV * ecb_cold
2515	PerlIOCede_getarg (pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)	2787	PerlIOCede_getarg (pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)
2516	{	2788	{
2517	PerlIOCede *self = PerlIOSelf (f, PerlIOCede);	2789	PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
2518		2790
2519	return newSVnv (self->every);	2791	return newSVnv (self->every);
…		…
2631	SvREFCNT_dec (cb);	2903	SvREFCNT_dec (cb);
2632	}	2904	}
2633	}	2905	}
2634		2906
2635	static void	2907	static void
2636	coro_semaphore_on_destroy (pTHX_ struct coro *coro)	2908	coro_semaphore_destroy (pTHX_ struct CoroSLF *frame)
2637	{	2909	{
2638	/* call $sem->adjust (0) to possibly wake up some other waiters */	2910	/* call $sem->adjust (0) to possibly wake up some other waiters */
2639	coro_semaphore_adjust (aTHX_ (AV *)coro->slf_frame.data, 0);	2911	coro_semaphore_adjust (aTHX_ (AV *)frame->data, 0);
2640	}	2912	}
2641		2913
2642	static int	2914	static int
2643	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)
2644	{	2916	{
2645	AV *av = (AV *)frame->data;	2917	AV *av = (AV *)frame->data;
2646	SV *count_sv = AvARRAY (av)[0];	2918	SV *count_sv = AvARRAY (av)[0];
		2919	SV *coro_hv = SvRV (coro_current);
2647		2920
2648	/* 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 */
2649	if (CORO_THROW)	2922	if (CORO_THROW)
2650	return 0;	2923	return 0;
2651	else if (SvIVX (count_sv) > 0)	2924	else if (SvIVX (count_sv) > 0)
2652	{	2925	{
2653	SvSTATE_current->on_destroy = 0;	2926	frame->destroy = 0;
2654		2927
2655	if (acquire)	2928	if (acquire)
2656	SvIVX (count_sv) = SvIVX (count_sv) - 1;	2929	SvIVX (count_sv) = SvIVX (count_sv) - 1;
2657	else	2930	else
2658	coro_semaphore_adjust (aTHX_ av, 0);	2931	coro_semaphore_adjust (aTHX_ av, 0);
…		…
2663	{	2936	{
2664	int i;	2937	int i;
2665	/* 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 */
2666	/* 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 */
2667	/* this avoids some degenerate memory usage cases */	2940	/* this avoids some degenerate memory usage cases */
2668		2941	for (i = AvFILLp (av); i > 0; --i) // i > 0 is not an off-by-one bug
2669	for (i = 1; i <= AvFILLp (av); ++i)
2670	if (AvARRAY (av)[i] == SvRV (coro_current))	2942	if (AvARRAY (av)[i] == coro_hv)
2671	return 1;	2943	return 1;
2672		2944
2673	av_push (av, SvREFCNT_inc (SvRV (coro_current)));	2945	av_push (av, SvREFCNT_inc (coro_hv));
2674	return 1;	2946	return 1;
2675	}	2947	}
2676	}	2948	}
2677		2949
2678	static int	2950	static int
…		…
2701	{	2973	{
2702	av_push (av, SvREFCNT_inc (SvRV (coro_current)));	2974	av_push (av, SvREFCNT_inc (SvRV (coro_current)));
2703		2975
2704	frame->data = (void *)sv_2mortal (SvREFCNT_inc ((SV *)av));	2976	frame->data = (void *)sv_2mortal (SvREFCNT_inc ((SV *)av));
2705	frame->prepare = prepare_schedule;	2977	frame->prepare = prepare_schedule;
2706
2707	/* to avoid race conditions when a woken-up coro gets terminated */	2978	/* to avoid race conditions when a woken-up coro gets terminated */
2708	/* we arrange for a temporary on_destroy that calls adjust (0) */	2979	/* we arrange for a temporary on_destroy that calls adjust (0) */
2709	SvSTATE_current->on_destroy = coro_semaphore_on_destroy;	2980	frame->destroy = coro_semaphore_destroy;
2710	}	2981	}
2711	}	2982	}
2712		2983
2713	static void	2984	static void
2714	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)
…		…
2932	dSP;	3203	dSP;
2933		3204
2934	static SV *prio_cv;	3205	static SV *prio_cv;
2935	static SV *prio_sv;	3206	static SV *prio_sv;
2936		3207
2937	if (expect_false (!prio_cv))	3208	if (ecb_expect_false (!prio_cv))
2938	{	3209	{
2939	prio_cv = (SV *)get_cv ("IO::AIO::aioreq_pri", 0);	3210	prio_cv = (SV *)get_cv ("IO::AIO::aioreq_pri", 0);
2940	prio_sv = newSViv (0);	3211	prio_sv = newSViv (0);
2941	}	3212	}
2942		3213
…		…
3048	}	3319	}
3049		3320
3050	return coro_sv;	3321	return coro_sv;
3051	}	3322	}
3052		3323
		3324	#ifndef __cplusplus
		3325	ecb_cold XS(boot_Coro__State);
		3326	#endif
		3327
3053	MODULE = Coro::State PACKAGE = Coro::State PREFIX = api_	3328	MODULE = Coro::State PACKAGE = Coro::State PREFIX = api_
3054		3329
3055	PROTOTYPES: DISABLE	3330	PROTOTYPES: DISABLE
3056		3331
3057	BOOT:	3332	BOOT:
…		…
3109	coroapi.prepare_nop = prepare_nop;	3384	coroapi.prepare_nop = prepare_nop;
3110	coroapi.prepare_schedule = prepare_schedule;	3385	coroapi.prepare_schedule = prepare_schedule;
3111	coroapi.prepare_cede = prepare_cede;	3386	coroapi.prepare_cede = prepare_cede;
3112	coroapi.prepare_cede_notself = prepare_cede_notself;	3387	coroapi.prepare_cede_notself = prepare_cede_notself;
3113		3388
3114	{	3389	time_init (aTHX);
3115	SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
3116
3117	if (!svp) croak ("Time::HiRes is required");
3118	if (!SvIOK (*svp)) croak ("Time::NVtime isn't a function pointer");
3119
3120	nvtime = INT2PTR (double (*)(), SvIV (*svp));
3121
3122	svp = hv_fetch (PL_modglobal, "Time::U2time", 12, 0);
3123	u2time = INT2PTR (void (*)(pTHX_ UV ret[2]), SvIV (*svp));
3124	}
3125		3390
3126	assert (("PRIO_NORMAL must be 0", !CORO_PRIO_NORMAL));	3391	assert (("PRIO_NORMAL must be 0", !CORO_PRIO_NORMAL));
3127	}	3392	}
3128		3393
3129	SV *	3394	SV *
…		…
3138	void	3403	void
3139	transfer (...)	3404	transfer (...)
3140	PROTOTYPE: $$	3405	PROTOTYPE: $$
3141	CODE:	3406	CODE:
3142	CORO_EXECUTE_SLF_XS (slf_init_transfer);	3407	CORO_EXECUTE_SLF_XS (slf_init_transfer);
3143
3144	bool
3145	_destroy (SV *coro_sv)
3146	CODE:
3147	RETVAL = coro_state_destroy (aTHX_ SvSTATE (coro_sv));
3148	OUTPUT:
3149	RETVAL
3150		3408
3151	void	3409	void
3152	_exit (int code)	3410	_exit (int code)
3153	PROTOTYPE: $	3411	PROTOTYPE: $
3154	CODE:	3412	CODE:
…		…
3230	CODE:	3488	CODE:
3231	{	3489	{
3232	if (coro->mainstack && ((coro->flags & CF_RUNNING) || coro->slot))	3490	if (coro->mainstack && ((coro->flags & CF_RUNNING) || coro->slot))
3233	{	3491	{
3234	struct coro *current = SvSTATE_current;	3492	struct coro *current = SvSTATE_current;
		3493	struct CoroSLF slf_save;
3235		3494
3236	if (current != coro)	3495	if (current != coro)
3237	{	3496	{
3238	PUTBACK;	3497	PUTBACK;
3239	save_perl (aTHX_ current);	3498	save_perl (aTHX_ current);
3240	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;
3241	SPAGAIN;	3509	SPAGAIN;
3242	}	3510	}
3243		3511
3244	PUSHSTACK;	3512	PUSHSTACK;
3245		3513
…		…
3255	SPAGAIN;	3523	SPAGAIN;
3256		3524
3257	if (current != coro)	3525	if (current != coro)
3258	{	3526	{
3259	PUTBACK;	3527	PUTBACK;
		3528	slf_frame = slf_save;
3260	save_perl (aTHX_ coro);	3529	save_perl (aTHX_ coro);
3261	load_perl (aTHX_ current);	3530	load_perl (aTHX_ current);
3262	SPAGAIN;	3531	SPAGAIN;
3263	}	3532	}
3264	}	3533	}
…		…
3269	PROTOTYPE: $	3538	PROTOTYPE: $
3270	ALIAS:	3539	ALIAS:
3271	is_ready = CF_READY	3540	is_ready = CF_READY
3272	is_running = CF_RUNNING	3541	is_running = CF_RUNNING
3273	is_new = CF_NEW	3542	is_new = CF_NEW
3274	is_destroyed = CF_DESTROYED	3543	is_destroyed = CF_ZOMBIE
		3544	is_zombie = CF_ZOMBIE
3275	is_suspended = CF_SUSPENDED	3545	is_suspended = CF_SUSPENDED
3276	CODE:	3546	CODE:
3277	RETVAL = boolSV (coro->flags & ix);	3547	RETVAL = boolSV (coro->flags & ix);
3278	OUTPUT:	3548	OUTPUT:
3279	RETVAL	3549	RETVAL
…		…
3350		3620
3351	void	3621	void
3352	cancel (Coro::State self)	3622	cancel (Coro::State self)
3353	CODE:	3623	CODE:
3354	coro_state_destroy (aTHX_ self);	3624	coro_state_destroy (aTHX_ self);
3355	coro_call_on_destroy (aTHX_ self); /* actually only for Coro objects */
3356
3357		3625
3358	SV *	3626	SV *
3359	enable_times (int enabled = enable_times)	3627	enable_times (int enabled = enable_times)
3360	CODE:	3628	CODE:
3361	{	3629	{
…		…
3376	times (Coro::State self)	3644	times (Coro::State self)
3377	PPCODE:	3645	PPCODE:
3378	{	3646	{
3379	struct coro *current = SvSTATE (coro_current);	3647	struct coro *current = SvSTATE (coro_current);
3380		3648
3381	if (expect_false (current == self))	3649	if (ecb_expect_false (current == self))
3382	{	3650	{
3383	coro_times_update ();	3651	coro_times_update ();
3384	coro_times_add (SvSTATE (coro_current));	3652	coro_times_add (SvSTATE (coro_current));
3385	}	3653	}
3386		3654
3387	EXTEND (SP, 2);	3655	EXTEND (SP, 2);
3388	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)));
3389	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)));
3390		3658
3391	if (expect_false (current == self))	3659	if (ecb_expect_false (current == self))
3392	coro_times_sub (SvSTATE (coro_current));	3660	coro_times_sub (SvSTATE (coro_current));
3393	}	3661	}
3394		3662
3395	void	3663	void
3396	swap_sv (Coro::State coro, SV *sv, SV *swapsv)	3664	swap_sv (Coro::State coro, SV *sv, SV *swapsv)
…		…
3417	BOOT:	3685	BOOT:
3418	{	3686	{
3419	sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE);	3687	sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE);
3420	sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE);	3688	sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE);
3421	cv_coro_run = get_cv ( "Coro::_coro_run" , GV_ADD);	3689	cv_coro_run = get_cv ( "Coro::_coro_run" , GV_ADD);
3422	cv_coro_terminate = get_cv ( "Coro::terminate" , GV_ADD);
3423	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);
3424	av_async_pool = coro_get_av (aTHX_ "Coro::async_pool", TRUE);	3691	av_async_pool = coro_get_av (aTHX_ "Coro::async_pool", TRUE);
3425	av_destroy = coro_get_av (aTHX_ "Coro::destroy" , TRUE);	3692	av_destroy = coro_get_av (aTHX_ "Coro::destroy" , TRUE);
3426	sv_manager = coro_get_sv (aTHX_ "Coro::manager" , TRUE);	3693	sv_manager = coro_get_sv (aTHX_ "Coro::manager" , TRUE);
3427	sv_idle = coro_get_sv (aTHX_ "Coro::idle" , TRUE);	3694	sv_idle = coro_get_sv (aTHX_ "Coro::idle" , TRUE);
…		…
3466	api_ready (aTHX_ RETVAL);	3733	api_ready (aTHX_ RETVAL);
3467	OUTPUT:	3734	OUTPUT:
3468	RETVAL	3735	RETVAL
3469		3736
3470	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
3471	terminate (...)	3754	terminate (...)
3472	CODE:	3755	CODE:
3473	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
3474		3766
3475	void	3767	void
3476	schedule (...)	3768	schedule (...)
3477	CODE:	3769	CODE:
3478	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