ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/Coro/Coro/State.xs

Comparing Coro/Coro/State.xs (file contents):
Revision 1.382 by root, Thu Feb 10 08:06:27 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	*/
…		…
1013	PL_comppad_name_fill = 0;	1066	PL_comppad_name_fill = 0;
1014	PL_comppad_name_floor = 0;	1067	PL_comppad_name_floor = 0;
1015	PL_curpm = 0;	1068	PL_curpm = 0;
1016	PL_curpad = 0;	1069	PL_curpad = 0;
1017	PL_localizing = 0;	1070	PL_localizing = 0;
1018	PL_dirty = 0;
1019	PL_restartop = 0;	1071	PL_restartop = 0;
1020	#if PERL_VERSION_ATLEAST (5,10,0)	1072	#if PERL_VERSION_ATLEAST (5,10,0)
1021	PL_parser = 0;	1073	PL_parser = 0;
1022	#endif	1074	#endif
1023	PL_hints = 0;	1075	PL_hints = 0;
1024		1076
1025	/* recreate the die/warn hooks */	1077	/* recreate the die/warn hooks */
1026	PL_diehook = 0; SvSetMagicSV (*hv_fetch (hv_sig, "__DIE__" , sizeof ("__DIE__" ) - 1, 1), rv_diehook );	1078	PL_diehook = SvREFCNT_inc (rv_diehook);
1027	PL_warnhook = 0; SvSetMagicSV (*hv_fetch (hv_sig, "__WARN__", sizeof ("__WARN__") - 1, 1), rv_warnhook);	1079	PL_warnhook = SvREFCNT_inc (rv_warnhook);
1028		1080
1029	GvSV (PL_defgv) = newSV (0);	1081	GvSV (PL_defgv) = newSV (0);
1030	GvAV (PL_defgv) = coro->args; coro->args = 0;	1082	GvAV (PL_defgv) = coro->args; coro->args = 0;
1031	GvSV (PL_errgv) = newSV (0);	1083	GvSV (PL_errgv) = newSV (0);
1032	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);
…		…
1053	/* 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
1054	* 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.
1055	*/	1107	*/
1056	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 */
1057	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;
1058		1111
1059	/* 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 */
1060	init_perl_op.op_next = PL_op;	1113	init_perl_op.op_next = PL_op;
1061	init_perl_op.op_type = OP_ENTERSUB;	1114	init_perl_op.op_type = OP_ENTERSUB;
1062	init_perl_op.op_ppaddr = pp_slf;	1115	init_perl_op.op_ppaddr = pp_slf;
…		…
1067	/* copy throw, in case it was set before init_perl */	1120	/* copy throw, in case it was set before init_perl */
1068	CORO_THROW = coro->except;	1121	CORO_THROW = coro->except;
1069		1122
1070	SWAP_SVS (coro);	1123	SWAP_SVS (coro);
1071		1124
1072	if (expect_false (enable_times))	1125	if (ecb_expect_false (enable_times))
1073	{	1126	{
1074	coro_times_update ();	1127	coro_times_update ();
1075	coro_times_sub (coro);	1128	coro_times_sub (coro);
1076	}	1129	}
1077	}	1130	}
…		…
1101	destroy_perl (pTHX_ struct coro *coro)	1154	destroy_perl (pTHX_ struct coro *coro)
1102	{	1155	{
1103	SV *svf [9];	1156	SV *svf [9];
1104		1157
1105	{	1158	{
		1159	SV *old_current = SvRV (coro_current);
1106	struct coro *current = SvSTATE_current;	1160	struct coro *current = SvSTATE (old_current);
1107		1161
1108	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));
1109		1163
1110	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
1111	load_perl (aTHX_ coro);	1169	load_perl (aTHX_ coro);
1112		1170
1113	coro_unwind_stacks (aTHX);	1171	coro_unwind_stacks (aTHX);
1114	coro_destruct_stacks (aTHX);
1115		1172
1116	/* restore swapped sv's */	1173	/* restore swapped sv's */
1117	SWAP_SVS (coro);	1174	SWAP_SVS (coro);
		1175
		1176	coro_destruct_stacks (aTHX);
1118		1177
1119	// now save some sv's to be free'd later	1178	// now save some sv's to be free'd later
1120	svf [0] = GvSV (PL_defgv);	1179	svf [0] = GvSV (PL_defgv);
1121	svf [1] = (SV *)GvAV (PL_defgv);	1180	svf [1] = (SV *)GvAV (PL_defgv);
1122	svf [2] = GvSV (PL_errgv);	1181	svf [2] = GvSV (PL_errgv);
…		…
1126	svf [6] = (SV *)GvHV (PL_hintgv);	1185	svf [6] = (SV *)GvHV (PL_hintgv);
1127	svf [7] = PL_diehook;	1186	svf [7] = PL_diehook;
1128	svf [8] = PL_warnhook;	1187	svf [8] = PL_warnhook;
1129	assert (9 == sizeof (svf) / sizeof (*svf));	1188	assert (9 == sizeof (svf) / sizeof (*svf));
1130		1189
		1190	SvRV_set (coro_current, old_current);
		1191
1131	load_perl (aTHX_ current);	1192	load_perl (aTHX_ current);
1132	}	1193	}
1133		1194
1134	{	1195	{
1135	unsigned int i;	1196	unsigned int i;
…		…
1142	SvREFCNT_dec (coro->invoke_cb);	1203	SvREFCNT_dec (coro->invoke_cb);
1143	SvREFCNT_dec (coro->invoke_av);	1204	SvREFCNT_dec (coro->invoke_av);
1144	}	1205	}
1145	}	1206	}
1146		1207
1147	INLINE void	1208	ECB_INLINE void
1148	free_coro_mortal (pTHX)	1209	free_coro_mortal (pTHX)
1149	{	1210	{
1150	if (expect_true (coro_mortal))	1211	if (ecb_expect_true (coro_mortal))
1151	{	1212	{
1152	SvREFCNT_dec (coro_mortal);	1213	SvREFCNT_dec ((SV *)coro_mortal);
1153	coro_mortal = 0;	1214	coro_mortal = 0;
1154	}	1215	}
1155	}	1216	}
1156		1217
1157	static int	1218	static int
…		…
1290		1351
1291	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 */
1292	}	1353	}
1293		1354
1294	/* 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 */
1295	static void NOINLINE	1356	static void ecb_noinline
1296	cctx_prepare (pTHX)	1357	cctx_prepare (pTHX)
1297	{	1358	{
1298	PL_top_env = &PL_start_env;	1359	PL_top_env = &PL_start_env;
1299		1360
1300	if (cctx_current->flags & CC_TRACE)	1361	if (cctx_current->flags & CC_TRACE)
…		…
1311	slf_frame.prepare = slf_prepare_set_stacklevel;	1372	slf_frame.prepare = slf_prepare_set_stacklevel;
1312	slf_frame.check = slf_check_set_stacklevel;	1373	slf_frame.check = slf_check_set_stacklevel;
1313	}	1374	}
1314		1375
1315	/* 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 */
1316	INLINE void	1377	ECB_INLINE void
1317	transfer_tail (pTHX)	1378	transfer_tail (pTHX)
1318	{	1379	{
1319	free_coro_mortal (aTHX);	1380	free_coro_mortal (aTHX);
1320	}	1381	}
1321		1382
…		…
1444	cctx_destroy (coro_cctx *cctx)	1505	cctx_destroy (coro_cctx *cctx)
1445	{	1506	{
1446	if (!cctx)	1507	if (!cctx)
1447	return;	1508	return;
1448		1509
1449	assert (("FATAL: tried to destroy current cctx", cctx != cctx_current));//D temporary?	1510	assert (("FATAL: tried to destroy current cctx", cctx != cctx_current));
1450		1511
1451	--cctx_count;	1512	--cctx_count;
1452	coro_destroy (&cctx->cctx);	1513	coro_destroy (&cctx->cctx);
1453		1514
1454	/* coro_transfer creates new, empty cctx's */	1515	/* coro_transfer creates new, empty cctx's */
…		…
1473	#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))
1474		1535
1475	static coro_cctx *	1536	static coro_cctx *
1476	cctx_get (pTHX)	1537	cctx_get (pTHX)
1477	{	1538	{
1478	while (expect_true (cctx_first))	1539	while (ecb_expect_true (cctx_first))
1479	{	1540	{
1480	coro_cctx *cctx = cctx_first;	1541	coro_cctx *cctx = cctx_first;
1481	cctx_first = cctx->next;	1542	cctx_first = cctx->next;
1482	--cctx_idle;	1543	--cctx_idle;
1483		1544
1484	if (expect_true (!CCTX_EXPIRED (cctx)))	1545	if (ecb_expect_true (!CCTX_EXPIRED (cctx)))
1485	return cctx;	1546	return cctx;
1486		1547
1487	cctx_destroy (cctx);	1548	cctx_destroy (cctx);
1488	}	1549	}
1489		1550
…		…
1494	cctx_put (coro_cctx *cctx)	1555	cctx_put (coro_cctx *cctx)
1495	{	1556	{
1496	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));
1497		1558
1498	/* free another cctx if overlimit */	1559	/* free another cctx if overlimit */
1499	if (expect_false (cctx_idle >= cctx_max_idle))	1560	if (ecb_expect_false (cctx_idle >= cctx_max_idle))
1500	{	1561	{
1501	coro_cctx *first = cctx_first;	1562	coro_cctx *first = cctx_first;
1502	cctx_first = first->next;	1563	cctx_first = first->next;
1503	--cctx_idle;	1564	--cctx_idle;
1504		1565
…		…
1515	static void	1576	static void
1516	transfer_check (pTHX_ struct coro *prev, struct coro *next)	1577	transfer_check (pTHX_ struct coro *prev, struct coro *next)
1517	{	1578	{
1518	/* TODO: throwing up here is considered harmful */	1579	/* TODO: throwing up here is considered harmful */
1519		1580
1520	if (expect_true (prev != next))	1581	if (ecb_expect_true (prev != next))
1521	{	1582	{
1522	if (expect_false (!(prev->flags & (CF_RUNNING | CF_NEW))))	1583	if (ecb_expect_false (!(prev->flags & (CF_RUNNING | CF_NEW))))
1523	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,");
1524		1585
1525	if (expect_false (next->flags & (CF_RUNNING | CF_DESTROYED | CF_SUSPENDED)))	1586	if (ecb_expect_false (next->flags & (CF_RUNNING | CF_ZOMBIE | CF_SUSPENDED)))
1526	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,");
1527		1588
1528	#if !PERL_VERSION_ATLEAST (5,10,0)	1589	#if !PERL_VERSION_ATLEAST (5,10,0)
1529	if (expect_false (PL_lex_state != LEX_NOTPARSING))	1590	if (ecb_expect_false (PL_lex_state != LEX_NOTPARSING))
1530	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,");
1531	#endif	1592	#endif
1532	}	1593	}
1533	}	1594	}
1534		1595
1535	/* always use the TRANSFER macro */	1596	/* always use the TRANSFER macro */
1536	static void NOINLINE /* noinline so we have a fixed stackframe */	1597	static void ecb_noinline /* noinline so we have a fixed stackframe */
1537	transfer (pTHX_ struct coro *prev, struct coro *next, int force_cctx)	1598	transfer (pTHX_ struct coro *prev, struct coro *next, int force_cctx)
1538	{	1599	{
1539	dSTACKLEVEL;	1600	dSTACKLEVEL;
1540		1601
1541	/* sometimes transfer is only called to set idle_sp */	1602	/* sometimes transfer is only called to set idle_sp */
1542	if (expect_false (!prev))	1603	if (ecb_expect_false (!prev))
1543	{	1604	{
1544	cctx_current->idle_sp = STACKLEVEL;	1605	cctx_current->idle_sp = STACKLEVEL;
1545	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 */
1546	}	1607	}
1547	else if (expect_true (prev != next))	1608	else if (ecb_expect_true (prev != next))
1548	{	1609	{
1549	coro_cctx *cctx_prev;	1610	coro_cctx *cctx_prev;
1550		1611
1551	if (expect_false (prev->flags & CF_NEW))	1612	if (ecb_expect_false (prev->flags & CF_NEW))
1552	{	1613	{
1553	/* create a new empty/source context */	1614	/* create a new empty/source context */
1554	prev->flags &= ~CF_NEW;	1615	prev->flags &= ~CF_NEW;
1555	prev->flags |= CF_RUNNING;	1616	prev->flags |= CF_RUNNING;
1556	}	1617	}
…		…
1559	next->flags |= CF_RUNNING;	1620	next->flags |= CF_RUNNING;
1560		1621
1561	/* first get rid of the old state */	1622	/* first get rid of the old state */
1562	save_perl (aTHX_ prev);	1623	save_perl (aTHX_ prev);
1563		1624
1564	if (expect_false (next->flags & CF_NEW))	1625	if (ecb_expect_false (next->flags & CF_NEW))
1565	{	1626	{
1566	/* need to start coroutine */	1627	/* need to start coroutine */
1567	next->flags &= ~CF_NEW;	1628	next->flags &= ~CF_NEW;
1568	/* setup coroutine call */	1629	/* setup coroutine call */
1569	init_perl (aTHX_ next);	1630	init_perl (aTHX_ next);
1570	}	1631	}
1571	else	1632	else
1572	load_perl (aTHX_ next);	1633	load_perl (aTHX_ next);
1573		1634
1574	/* possibly untie and reuse the cctx */	1635	/* possibly untie and reuse the cctx */
1575	if (expect_true (	1636	if (ecb_expect_true (
1576	cctx_current->idle_sp == STACKLEVEL	1637	cctx_current->idle_sp == STACKLEVEL
1577	&& !(cctx_current->flags & CC_TRACE)	1638	&& !(cctx_current->flags & CC_TRACE)
1578	&& !force_cctx	1639	&& !force_cctx
1579	))	1640	))
1580	{	1641	{
1581	/* 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 */
1582	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));
1583		1644
1584	/* 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. */
1585	/* 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 */
1586	if (expect_false (CCTX_EXPIRED (cctx_current)))	1647	if (ecb_expect_false (CCTX_EXPIRED (cctx_current)))
1587	if (expect_true (!next->cctx))	1648	if (ecb_expect_true (!next->cctx))
1588	next->cctx = cctx_get (aTHX);	1649	next->cctx = cctx_get (aTHX);
1589		1650
1590	cctx_put (cctx_current);	1651	cctx_put (cctx_current);
1591	}	1652	}
1592	else	1653	else
1593	prev->cctx = cctx_current;	1654	prev->cctx = cctx_current;
1594		1655
1595	++next->usecount;	1656	++next->usecount;
1596		1657
1597	cctx_prev = cctx_current;	1658	cctx_prev = cctx_current;
1598	cctx_current = expect_false (next->cctx) ? next->cctx : cctx_get (aTHX);	1659	cctx_current = ecb_expect_false (next->cctx) ? next->cctx : cctx_get (aTHX);
1599		1660
1600	next->cctx = 0;	1661	next->cctx = 0;
1601		1662
1602	if (expect_false (cctx_prev != cctx_current))	1663	if (ecb_expect_false (cctx_prev != cctx_current))
1603	{	1664	{
1604	cctx_prev->top_env = PL_top_env;	1665	cctx_prev->top_env = PL_top_env;
1605	PL_top_env = cctx_current->top_env;	1666	PL_top_env = cctx_current->top_env;
1606	coro_transfer (&cctx_prev->cctx, &cctx_current->cctx);	1667	coro_transfer (&cctx_prev->cctx, &cctx_current->cctx);
1607	}	1668	}
…		…
1613	#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))
1614	#define TRANSFER_CHECK(ta) transfer_check (aTHX_ (ta).prev, (ta).next)	1675	#define TRANSFER_CHECK(ta) transfer_check (aTHX_ (ta).prev, (ta).next)
1615		1676
1616	/** high level stuff ********************************************************/	1677	/** high level stuff ********************************************************/
1617		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 */
1618	static int	1681	static void
		1682	coro_call_on_destroy (pTHX_ struct coro *coro);
		1683
		1684	static void
1619	coro_state_destroy (pTHX_ struct coro *coro)	1685	coro_state_destroy (pTHX_ struct coro *coro)
1620	{	1686	{
1621	if (coro->flags & CF_DESTROYED)	1687	if (coro->flags & CF_ZOMBIE)
1622	return 0;	1688	return;
1623		1689
1624	if (coro->on_destroy && !PL_dirty)
1625	coro->on_destroy (aTHX_ coro);	1690	slf_destroy (aTHX_ coro);
1626		1691
1627	coro->flags |= CF_DESTROYED;	1692	coro->flags |= CF_ZOMBIE;
1628		1693
1629	if (coro->flags & CF_READY)	1694	if (coro->flags & CF_READY)
1630	{	1695	{
1631	/* reduce nready, as destroying a ready coro effectively unreadies it */	1696	/* reduce nready, as destroying a ready coro effectively unreadies it */
1632	/* alternative: look through all ready queues and remove the coro */	1697	/* alternative: look through all ready queues and remove the coro */
1633	--coro_nready;	1698	--coro_nready;
1634	}	1699	}
1635	else	1700	else
1636	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;
1637		1706
1638	if (coro->mainstack	1707	if (coro->mainstack
1639	&& coro->mainstack != main_mainstack	1708	&& coro->mainstack != main_mainstack
1640	&& coro->slot	1709	&& coro->slot
1641	&& !PL_dirty)	1710	&& !PL_dirty)
1642	destroy_perl (aTHX_ coro);	1711	destroy_perl (aTHX_ coro);
1643		1712
1644	if (coro->next) coro->next->prev = coro->prev;
1645	if (coro->prev) coro->prev->next = coro->next;
1646	if (coro == coro_first) coro_first = coro->next;
1647
1648	cctx_destroy (coro->cctx);	1713	cctx_destroy (coro->cctx);
1649	SvREFCNT_dec (coro->startcv);	1714	SvREFCNT_dec (coro->startcv);
1650	SvREFCNT_dec (coro->args);	1715	SvREFCNT_dec (coro->args);
1651	SvREFCNT_dec (coro->swap_sv);	1716	SvREFCNT_dec (coro->swap_sv);
1652	SvREFCNT_dec (CORO_THROW);	1717	SvREFCNT_dec (CORO_THROW);
1653		1718
1654	return 1;	1719	coro_call_on_destroy (aTHX_ coro);
		1720
		1721	/* more destruction mayhem in coro_state_free */
1655	}	1722	}
1656		1723
1657	static int	1724	static int
1658	coro_state_free (pTHX_ SV *sv, MAGIC *mg)	1725	coro_state_free (pTHX_ SV *sv, MAGIC *mg)
1659	{	1726	{
1660	struct coro *coro = (struct coro *)mg->mg_ptr;	1727	struct coro *coro = (struct coro *)mg->mg_ptr;
1661	mg->mg_ptr = 0;	1728	mg->mg_ptr = 0;
1662		1729
1663	coro->hv = 0;
1664
1665	if (--coro->refcnt < 0)
1666	{
1667	coro_state_destroy (aTHX_ coro);	1730	coro_state_destroy (aTHX_ coro);
		1731	SvREFCNT_dec (coro->on_destroy);
		1732	SvREFCNT_dec (coro->status);
		1733
1668	Safefree (coro);	1734	Safefree (coro);
1669	}
1670		1735
1671	return 0;	1736	return 0;
1672	}	1737	}
1673		1738
1674	static int	1739	static int ecb_cold
1675	coro_state_dup (pTHX_ MAGIC *mg, CLONE_PARAMS *params)	1740	coro_state_dup (pTHX_ MAGIC *mg, CLONE_PARAMS *params)
1676	{	1741	{
1677	struct coro *coro = (struct coro *)mg->mg_ptr;	1742	/* called when perl clones the current process the slow way (windows process emulation) */
1678		1743	/* WE SIMply nuke the pointers in the copy, causing perl to croak */
1679	++coro->refcnt;	1744	mg->mg_ptr = 0;
		1745	mg->mg_virtual = 0;
1680		1746
1681	return 0;	1747	return 0;
1682	}	1748	}
1683		1749
1684	static MGVTBL coro_state_vtbl = {	1750	static MGVTBL coro_state_vtbl = {
…		…
1709	TRANSFER (ta, 1);	1775	TRANSFER (ta, 1);
1710	}	1776	}
1711		1777
1712	/** Coro ********************************************************************/	1778	/** Coro ********************************************************************/
1713		1779
1714	INLINE void	1780	ECB_INLINE void
1715	coro_enq (pTHX_ struct coro *coro)	1781	coro_enq (pTHX_ struct coro *coro)
1716	{	1782	{
1717	struct coro **ready = coro_ready [coro->prio - CORO_PRIO_MIN];	1783	struct coro **ready = coro_ready [coro->prio - CORO_PRIO_MIN];
1718		1784
1719	SvREFCNT_inc_NN (coro->hv);	1785	SvREFCNT_inc_NN (coro->hv);
…		…
1721	coro->next_ready = 0;	1787	coro->next_ready = 0;
1722	*(ready [0] ? &ready [1]->next_ready : &ready [0]) = coro;	1788	*(ready [0] ? &ready [1]->next_ready : &ready [0]) = coro;
1723	ready [1] = coro;	1789	ready [1] = coro;
1724	}	1790	}
1725		1791
1726	INLINE struct coro *	1792	ECB_INLINE struct coro *
1727	coro_deq (pTHX)	1793	coro_deq (pTHX)
1728	{	1794	{
1729	int prio;	1795	int prio;
1730		1796
1731	for (prio = CORO_PRIO_MAX - CORO_PRIO_MIN + 1; --prio >= 0; )	1797	for (prio = CORO_PRIO_MAX - CORO_PRIO_MIN + 1; --prio >= 0; )
…		…
1784	{	1850	{
1785	return !!(SvSTATE (coro_sv)->flags & CF_READY);	1851	return !!(SvSTATE (coro_sv)->flags & CF_READY);
1786	}	1852	}
1787		1853
1788	/* expects to own a reference to next->hv */	1854	/* expects to own a reference to next->hv */
1789	INLINE void	1855	ECB_INLINE void
1790	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)
1791	{	1857	{
1792	SV *prev_sv = SvRV (coro_current);	1858	SV *prev_sv = SvRV (coro_current);
1793		1859
1794	ta->prev = SvSTATE_hv (prev_sv);	1860	ta->prev = SvSTATE_hv (prev_sv);
…		…
1807	{	1873	{
1808	for (;;)	1874	for (;;)
1809	{	1875	{
1810	struct coro *next = coro_deq (aTHX);	1876	struct coro *next = coro_deq (aTHX);
1811		1877
1812	if (expect_true (next))	1878	if (ecb_expect_true (next))
1813	{	1879	{
1814	/* cannot transfer to destroyed coros, skip and look for next */	1880	/* cannot transfer to destroyed coros, skip and look for next */
1815	if (expect_false (next->flags & (CF_DESTROYED | CF_SUSPENDED)))	1881	if (ecb_expect_false (next->flags & (CF_ZOMBIE | CF_SUSPENDED)))
1816	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 */
1817	else	1883	else
1818	{	1884	{
1819	next->flags &= ~CF_READY;	1885	next->flags &= ~CF_READY;
1820	--coro_nready;	1886	--coro_nready;
…		…
1853	}	1919	}
1854	}	1920	}
1855	}	1921	}
1856	}	1922	}
1857		1923
1858	INLINE void	1924	ECB_INLINE void
1859	prepare_cede (pTHX_ struct coro_transfer_args *ta)	1925	prepare_cede (pTHX_ struct coro_transfer_args *ta)
1860	{	1926	{
1861	api_ready (aTHX_ coro_current);	1927	api_ready (aTHX_ coro_current);
1862	prepare_schedule (aTHX_ ta);	1928	prepare_schedule (aTHX_ ta);
1863	}	1929	}
1864		1930
1865	INLINE void	1931	ECB_INLINE void
1866	prepare_cede_notself (pTHX_ struct coro_transfer_args *ta)	1932	prepare_cede_notself (pTHX_ struct coro_transfer_args *ta)
1867	{	1933	{
1868	SV *prev = SvRV (coro_current);	1934	SV *prev = SvRV (coro_current);
1869		1935
1870	if (coro_nready)	1936	if (coro_nready)
…		…
1900	{	1966	{
1901	struct coro_transfer_args ta;	1967	struct coro_transfer_args ta;
1902		1968
1903	prepare_cede (aTHX_ &ta);	1969	prepare_cede (aTHX_ &ta);
1904		1970
1905	if (expect_true (ta.prev != ta.next))	1971	if (ecb_expect_true (ta.prev != ta.next))
1906	{	1972	{
1907	TRANSFER (ta, 1);	1973	TRANSFER (ta, 1);
1908	return 1;	1974	return 1;
1909	}	1975	}
1910	else	1976	else
…		…
1953	coro->slot->runops = RUNOPS_DEFAULT;	2019	coro->slot->runops = RUNOPS_DEFAULT;
1954	}	2020	}
1955	}	2021	}
1956		2022
1957	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
1958	coro_call_on_destroy (pTHX_ struct coro *coro)	2100	coro_call_on_destroy (pTHX_ struct coro *coro)
1959	{	2101	{
1960	SV **on_destroyp = hv_fetch (coro->hv, "_on_destroy", sizeof ("_on_destroy") - 1, 0);	2102	AV *od = coro->on_destroy;
1961	SV **statusp = hv_fetch (coro->hv, "_status", sizeof ("_status") - 1, 0);
1962		2103
1963	if (on_destroyp)	2104	if (!od)
1964	{	2105	return;
1965	AV *on_destroy = (AV *)SvRV (*on_destroyp);
1966		2106
1967	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
1968	{	2115	{
1969	dSP; /* don't disturb outer sp */	2116	dSP; /* don't disturb outer sp */
1970	SV *cb = av_pop (on_destroy);
1971
1972	PUSHMARK (SP);	2117	PUSHMARK (SP);
1973		2118
1974	if (statusp)	2119	if (coro->status)
1975	{	2120	{
1976	int i;	2121	PUTBACK;
1977	AV *status = (AV *)SvRV (*statusp);	2122	coro_push_av (aTHX_ coro->status, G_ARRAY);
1978	EXTEND (SP, AvFILLp (status) + 1);	2123	SPAGAIN;
1979
1980	for (i = 0; i <= AvFILLp (status); ++i)
1981	PUSHs (AvARRAY (status)[i]);
1982	}	2124	}
1983		2125
1984	PUTBACK;	2126	PUTBACK;
1985	call_sv (sv_2mortal (cb), G_VOID | G_DISCARD);	2127	call_sv (cb, G_VOID | G_DISCARD);
1986	}	2128	}
1987	}	2129	}
1988	}	2130	}
1989		2131
1990	static void	2132	static void
1991	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)
1992	{	2134	{
1993	int i;	2135	AV *av;
1994	HV *hv = (HV *)SvRV (coro_current);	2136
1995	AV *av = newAV ();	2137	if (coro->status)
		2138	{
		2139	av = coro->status;
		2140	av_clear (av);
		2141	}
		2142	else
		2143	av = coro->status = newAV ();
1996		2144
1997	/* items are actually not so common, so optimise for this case */	2145	/* items are actually not so common, so optimise for this case */
1998	if (items)	2146	if (items)
1999	{	2147	{
		2148	int i;
		2149
2000	av_extend (av, items - 1);	2150	av_extend (av, items - 1);
2001		2151
2002	for (i = 0; i < items; ++i)	2152	for (i = 0; i < items; ++i)
2003	av_push (av, SvREFCNT_inc_NN (arg [i]));	2153	av_push (av, SvREFCNT_inc_NN (arg [i]));
2004	}	2154	}
		2155	}
2005		2156
2006	hv_store (hv, "_status", sizeof ("_status") - 1, newRV_noinc ((SV *)av), 0);	2157	static void
2007		2158	slf_init_terminate_cancel_common (pTHX_ struct CoroSLF *frame, HV *coro_hv)
		2159	{
2008	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 */
2009	api_ready (aTHX_ sv_manager);	2161	api_ready (aTHX_ sv_manager);
2010		2162
2011	frame->prepare = prepare_schedule;	2163	frame->prepare = prepare_schedule;
2012	frame->check = slf_check_repeat;	2164	frame->check = slf_check_repeat;
2013		2165
2014	/* as a minor optimisation, we could unwind all stacks here */	2166	/* as a minor optimisation, we could unwind all stacks here */
2015	/* 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 */
2016	/*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;
2017	}	2272	}
2018		2273
2019	/*****************************************************************************/	2274	/*****************************************************************************/
2020	/* async pool handler */	2275	/* async pool handler */
2021		2276
…		…
2052	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)
2053	{	2308	{
2054	HV *hv = (HV *)SvRV (coro_current);	2309	HV *hv = (HV *)SvRV (coro_current);
2055	struct coro *coro = SvSTATE_hv ((SV *)hv);	2310	struct coro *coro = SvSTATE_hv ((SV *)hv);
2056		2311
2057	if (expect_true (coro->saved_deffh))	2312	if (ecb_expect_true (coro->saved_deffh))
2058	{	2313	{
2059	/* subsequent iteration */	2314	/* subsequent iteration */
2060	SvREFCNT_dec ((SV *)PL_defoutgv); PL_defoutgv = (GV *)coro->saved_deffh;	2315	SvREFCNT_dec ((SV *)PL_defoutgv); PL_defoutgv = (GV *)coro->saved_deffh;
2061	coro->saved_deffh = 0;	2316	coro->saved_deffh = 0;
2062		2317
2063	if (coro_rss (aTHX_ coro) > SvUV (sv_pool_rss)	2318	if (coro_rss (aTHX_ coro) > SvUV (sv_pool_rss)
2064	|| av_len (av_async_pool) + 1 >= SvIV (sv_pool_size))	2319	|| av_len (av_async_pool) + 1 >= SvIV (sv_pool_size))
2065	{	2320	{
2066	coro->invoke_cb = SvREFCNT_inc_NN ((SV *)cv_coro_terminate);	2321	slf_init_terminate_cancel_common (aTHX_ frame, hv);
2067	coro->invoke_av = newAV ();	2322	return;
2068
2069	frame->prepare = prepare_nop;
2070	}	2323	}
2071	else	2324	else
2072	{	2325	{
2073	av_clear (GvAV (PL_defgv));	2326	av_clear (GvAV (PL_defgv));
2074	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);
…		…
2297	static void	2550	static void
2298	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)
2299	{	2552	{
2300	frame->prepare = prepare_cede_notself;	2553	frame->prepare = prepare_cede_notself;
2301	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;
2302	}	2572	}
2303		2573
2304	/*	2574	/*
2305	* these not obviously related functions are all rolled into one	2575	* these not obviously related functions are all rolled into one
2306	* 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
…		…
2313	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 */
2314		2584
2315	/* 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 */
2316	/* the latter happens when a new coro has been started */	2586	/* the latter happens when a new coro has been started */
2317	/* or when a new cctx was attached to an existing coroutine */	2587	/* or when a new cctx was attached to an existing coroutine */
2318	if (expect_true (!slf_frame.prepare))	2588	if (ecb_expect_true (!slf_frame.prepare))
2319	{	2589	{
2320	/* first iteration */	2590	/* first iteration */
2321	dSP;	2591	dSP;
2322	SV **arg = PL_stack_base + TOPMARK + 1;	2592	SV **arg = PL_stack_base + TOPMARK + 1;
2323	int items = SP - arg; /* args without function object */	2593	int items = SP - arg; /* args without function object */
…		…
2364	while (slf_frame.check (aTHX_ &slf_frame));	2634	while (slf_frame.check (aTHX_ &slf_frame));
2365		2635
2366	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 */
2367		2637
2368	/* exception handling */	2638	/* exception handling */
2369	if (expect_false (CORO_THROW))	2639	if (ecb_expect_false (CORO_THROW))
2370	{	2640	{
2371	SV *exception = sv_2mortal (CORO_THROW);	2641	SV *exception = sv_2mortal (CORO_THROW);
2372		2642
2373	CORO_THROW = 0;	2643	CORO_THROW = 0;
2374	sv_setsv (ERRSV, exception);	2644	sv_setsv (ERRSV, exception);
2375	croak (0);	2645	croak (0);
2376	}	2646	}
2377		2647
2378	/* return value handling - mostly like entersub */	2648	/* return value handling - mostly like entersub */
2379	/* make sure we put something on the stack in scalar context */	2649	/* make sure we put something on the stack in scalar context */
2380	if (GIMME_V == G_SCALAR)	2650	if (GIMME_V == G_SCALAR
		2651	&& ecb_expect_false (PL_stack_sp != PL_stack_base + checkmark + 1))
2381	{	2652	{
2382	dSP;	2653	dSP;
2383	SV **bot = PL_stack_base + checkmark;	2654	SV **bot = PL_stack_base + checkmark;
2384		2655
2385	if (sp == bot) /* too few, push undef */	2656	if (sp == bot) /* too few, push undef */
2386	bot [1] = &PL_sv_undef;	2657	bot [1] = &PL_sv_undef;
2387	else if (sp != bot + 1) /* too many, take last one */	2658	else /* too many, take last one */
2388	bot [1] = *sp;	2659	bot [1] = *sp;
2389		2660
2390	SP = bot + 1;	2661	SP = bot + 1;
2391		2662
2392	PUTBACK;	2663	PUTBACK;
…		…
2499	{	2770	{
2500	PerlIOBuf base;	2771	PerlIOBuf base;
2501	NV next, every;	2772	NV next, every;
2502	} PerlIOCede;	2773	} PerlIOCede;
2503		2774
2504	static IV	2775	static IV ecb_cold
2505	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)
2506	{	2777	{
2507	PerlIOCede *self = PerlIOSelf (f, PerlIOCede);	2778	PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
2508		2779
2509	self->every = SvCUR (arg) ? SvNV (arg) : 0.01;	2780	self->every = SvCUR (arg) ? SvNV (arg) : 0.01;
2510	self->next = nvtime () + self->every;	2781	self->next = nvtime () + self->every;
2511		2782
2512	return PerlIOBuf_pushed (aTHX_ f, mode, Nullsv, tab);	2783	return PerlIOBuf_pushed (aTHX_ f, mode, Nullsv, tab);
2513	}	2784	}
2514		2785
2515	static SV *	2786	static SV * ecb_cold
2516	PerlIOCede_getarg (pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)	2787	PerlIOCede_getarg (pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)
2517	{	2788	{
2518	PerlIOCede *self = PerlIOSelf (f, PerlIOCede);	2789	PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
2519		2790
2520	return newSVnv (self->every);	2791	return newSVnv (self->every);
…		…
2632	SvREFCNT_dec (cb);	2903	SvREFCNT_dec (cb);
2633	}	2904	}
2634	}	2905	}
2635		2906
2636	static void	2907	static void
2637	coro_semaphore_on_destroy (pTHX_ struct coro *coro)	2908	coro_semaphore_destroy (pTHX_ struct CoroSLF *frame)
2638	{	2909	{
2639	/* call $sem->adjust (0) to possibly wake up some other waiters */	2910	/* call $sem->adjust (0) to possibly wake up some other waiters */
2640	coro_semaphore_adjust (aTHX_ (AV *)coro->slf_frame.data, 0);	2911	coro_semaphore_adjust (aTHX_ (AV *)frame->data, 0);
2641	}	2912	}
2642		2913
2643	static int	2914	static int
2644	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)
2645	{	2916	{
2646	AV *av = (AV *)frame->data;	2917	AV *av = (AV *)frame->data;
2647	SV *count_sv = AvARRAY (av)[0];	2918	SV *count_sv = AvARRAY (av)[0];
		2919	SV *coro_hv = SvRV (coro_current);
2648		2920
2649	/* 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 */
2650	if (CORO_THROW)	2922	if (CORO_THROW)
2651	return 0;	2923	return 0;
2652	else if (SvIVX (count_sv) > 0)	2924	else if (SvIVX (count_sv) > 0)
2653	{	2925	{
2654	SvSTATE_current->on_destroy = 0;	2926	frame->destroy = 0;
2655		2927
2656	if (acquire)	2928	if (acquire)
2657	SvIVX (count_sv) = SvIVX (count_sv) - 1;	2929	SvIVX (count_sv) = SvIVX (count_sv) - 1;
2658	else	2930	else
2659	coro_semaphore_adjust (aTHX_ av, 0);	2931	coro_semaphore_adjust (aTHX_ av, 0);
…		…
2664	{	2936	{
2665	int i;	2937	int i;
2666	/* 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 */
2667	/* 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 */
2668	/* this avoids some degenerate memory usage cases */	2940	/* this avoids some degenerate memory usage cases */
2669		2941	for (i = AvFILLp (av); i > 0; --i) // i > 0 is not an off-by-one bug
2670	for (i = 1; i <= AvFILLp (av); ++i)
2671	if (AvARRAY (av)[i] == SvRV (coro_current))	2942	if (AvARRAY (av)[i] == coro_hv)
2672	return 1;	2943	return 1;
2673		2944
2674	av_push (av, SvREFCNT_inc (SvRV (coro_current)));	2945	av_push (av, SvREFCNT_inc (coro_hv));
2675	return 1;	2946	return 1;
2676	}	2947	}
2677	}	2948	}
2678		2949
2679	static int	2950	static int
…		…
2702	{	2973	{
2703	av_push (av, SvREFCNT_inc (SvRV (coro_current)));	2974	av_push (av, SvREFCNT_inc (SvRV (coro_current)));
2704		2975
2705	frame->data = (void *)sv_2mortal (SvREFCNT_inc ((SV *)av));	2976	frame->data = (void *)sv_2mortal (SvREFCNT_inc ((SV *)av));
2706	frame->prepare = prepare_schedule;	2977	frame->prepare = prepare_schedule;
2707
2708	/* to avoid race conditions when a woken-up coro gets terminated */	2978	/* to avoid race conditions when a woken-up coro gets terminated */
2709	/* we arrange for a temporary on_destroy that calls adjust (0) */	2979	/* we arrange for a temporary on_destroy that calls adjust (0) */
2710	SvSTATE_current->on_destroy = coro_semaphore_on_destroy;	2980	frame->destroy = coro_semaphore_destroy;
2711	}	2981	}
2712	}	2982	}
2713		2983
2714	static void	2984	static void
2715	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)
…		…
2933	dSP;	3203	dSP;
2934		3204
2935	static SV *prio_cv;	3205	static SV *prio_cv;
2936	static SV *prio_sv;	3206	static SV *prio_sv;
2937		3207
2938	if (expect_false (!prio_cv))	3208	if (ecb_expect_false (!prio_cv))
2939	{	3209	{
2940	prio_cv = (SV *)get_cv ("IO::AIO::aioreq_pri", 0);	3210	prio_cv = (SV *)get_cv ("IO::AIO::aioreq_pri", 0);
2941	prio_sv = newSViv (0);	3211	prio_sv = newSViv (0);
2942	}	3212	}
2943		3213
…		…
3049	}	3319	}
3050		3320
3051	return coro_sv;	3321	return coro_sv;
3052	}	3322	}
3053		3323
		3324	#ifndef __cplusplus
		3325	ecb_cold XS(boot_Coro__State);
		3326	#endif
		3327
3054	MODULE = Coro::State PACKAGE = Coro::State PREFIX = api_	3328	MODULE = Coro::State PACKAGE = Coro::State PREFIX = api_
3055		3329
3056	PROTOTYPES: DISABLE	3330	PROTOTYPES: DISABLE
3057		3331
3058	BOOT:	3332	BOOT:
…		…
3110	coroapi.prepare_nop = prepare_nop;	3384	coroapi.prepare_nop = prepare_nop;
3111	coroapi.prepare_schedule = prepare_schedule;	3385	coroapi.prepare_schedule = prepare_schedule;
3112	coroapi.prepare_cede = prepare_cede;	3386	coroapi.prepare_cede = prepare_cede;
3113	coroapi.prepare_cede_notself = prepare_cede_notself;	3387	coroapi.prepare_cede_notself = prepare_cede_notself;
3114		3388
3115	{	3389	time_init (aTHX);
3116	SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
3117
3118	if (!svp) croak ("Time::HiRes is required");
3119	if (!SvIOK (*svp)) croak ("Time::NVtime isn't a function pointer");
3120
3121	nvtime = INT2PTR (double (*)(), SvIV (*svp));
3122
3123	svp = hv_fetch (PL_modglobal, "Time::U2time", 12, 0);
3124	u2time = INT2PTR (void (*)(pTHX_ UV ret[2]), SvIV (*svp));
3125	}
3126		3390
3127	assert (("PRIO_NORMAL must be 0", !CORO_PRIO_NORMAL));	3391	assert (("PRIO_NORMAL must be 0", !CORO_PRIO_NORMAL));
3128	}	3392	}
3129		3393
3130	SV *	3394	SV *
…		…
3139	void	3403	void
3140	transfer (...)	3404	transfer (...)
3141	PROTOTYPE: $$	3405	PROTOTYPE: $$
3142	CODE:	3406	CODE:
3143	CORO_EXECUTE_SLF_XS (slf_init_transfer);	3407	CORO_EXECUTE_SLF_XS (slf_init_transfer);
3144
3145	bool
3146	_destroy (SV *coro_sv)
3147	CODE:
3148	RETVAL = coro_state_destroy (aTHX_ SvSTATE (coro_sv));
3149	OUTPUT:
3150	RETVAL
3151		3408
3152	void	3409	void
3153	_exit (int code)	3410	_exit (int code)
3154	PROTOTYPE: $	3411	PROTOTYPE: $
3155	CODE:	3412	CODE:
…		…
3231	CODE:	3488	CODE:
3232	{	3489	{
3233	if (coro->mainstack && ((coro->flags & CF_RUNNING) || coro->slot))	3490	if (coro->mainstack && ((coro->flags & CF_RUNNING) || coro->slot))
3234	{	3491	{
3235	struct coro *current = SvSTATE_current;	3492	struct coro *current = SvSTATE_current;
		3493	struct CoroSLF slf_save;
3236		3494
3237	if (current != coro)	3495	if (current != coro)
3238	{	3496	{
3239	PUTBACK;	3497	PUTBACK;
3240	save_perl (aTHX_ current);	3498	save_perl (aTHX_ current);
3241	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;
3242	SPAGAIN;	3509	SPAGAIN;
3243	}	3510	}
3244		3511
3245	PUSHSTACK;	3512	PUSHSTACK;
3246		3513
…		…
3256	SPAGAIN;	3523	SPAGAIN;
3257		3524
3258	if (current != coro)	3525	if (current != coro)
3259	{	3526	{
3260	PUTBACK;	3527	PUTBACK;
		3528	slf_frame = slf_save;
3261	save_perl (aTHX_ coro);	3529	save_perl (aTHX_ coro);
3262	load_perl (aTHX_ current);	3530	load_perl (aTHX_ current);
3263	SPAGAIN;	3531	SPAGAIN;
3264	}	3532	}
3265	}	3533	}
…		…
3270	PROTOTYPE: $	3538	PROTOTYPE: $
3271	ALIAS:	3539	ALIAS:
3272	is_ready = CF_READY	3540	is_ready = CF_READY
3273	is_running = CF_RUNNING	3541	is_running = CF_RUNNING
3274	is_new = CF_NEW	3542	is_new = CF_NEW
3275	is_destroyed = CF_DESTROYED	3543	is_destroyed = CF_ZOMBIE
		3544	is_zombie = CF_ZOMBIE
3276	is_suspended = CF_SUSPENDED	3545	is_suspended = CF_SUSPENDED
3277	CODE:	3546	CODE:
3278	RETVAL = boolSV (coro->flags & ix);	3547	RETVAL = boolSV (coro->flags & ix);
3279	OUTPUT:	3548	OUTPUT:
3280	RETVAL	3549	RETVAL
…		…
3351		3620
3352	void	3621	void
3353	cancel (Coro::State self)	3622	cancel (Coro::State self)
3354	CODE:	3623	CODE:
3355	coro_state_destroy (aTHX_ self);	3624	coro_state_destroy (aTHX_ self);
3356	coro_call_on_destroy (aTHX_ self); /* actually only for Coro objects */
3357
3358		3625
3359	SV *	3626	SV *
3360	enable_times (int enabled = enable_times)	3627	enable_times (int enabled = enable_times)
3361	CODE:	3628	CODE:
3362	{	3629	{
…		…
3377	times (Coro::State self)	3644	times (Coro::State self)
3378	PPCODE:	3645	PPCODE:
3379	{	3646	{
3380	struct coro *current = SvSTATE (coro_current);	3647	struct coro *current = SvSTATE (coro_current);
3381		3648
3382	if (expect_false (current == self))	3649	if (ecb_expect_false (current == self))
3383	{	3650	{
3384	coro_times_update ();	3651	coro_times_update ();
3385	coro_times_add (SvSTATE (coro_current));	3652	coro_times_add (SvSTATE (coro_current));
3386	}	3653	}
3387		3654
3388	EXTEND (SP, 2);	3655	EXTEND (SP, 2);
3389	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)));
3390	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)));
3391		3658
3392	if (expect_false (current == self))	3659	if (ecb_expect_false (current == self))
3393	coro_times_sub (SvSTATE (coro_current));	3660	coro_times_sub (SvSTATE (coro_current));
3394	}	3661	}
3395		3662
3396	void	3663	void
3397	swap_sv (Coro::State coro, SV *sv, SV *swapsv)	3664	swap_sv (Coro::State coro, SV *sv, SV *swapsv)
…		…
3418	BOOT:	3685	BOOT:
3419	{	3686	{
3420	sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE);	3687	sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE);
3421	sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE);	3688	sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE);
3422	cv_coro_run = get_cv ( "Coro::_coro_run" , GV_ADD);	3689	cv_coro_run = get_cv ( "Coro::_coro_run" , GV_ADD);
3423	cv_coro_terminate = get_cv ( "Coro::terminate" , GV_ADD);
3424	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);
3425	av_async_pool = coro_get_av (aTHX_ "Coro::async_pool", TRUE);	3691	av_async_pool = coro_get_av (aTHX_ "Coro::async_pool", TRUE);
3426	av_destroy = coro_get_av (aTHX_ "Coro::destroy" , TRUE);	3692	av_destroy = coro_get_av (aTHX_ "Coro::destroy" , TRUE);
3427	sv_manager = coro_get_sv (aTHX_ "Coro::manager" , TRUE);	3693	sv_manager = coro_get_sv (aTHX_ "Coro::manager" , TRUE);
3428	sv_idle = coro_get_sv (aTHX_ "Coro::idle" , TRUE);	3694	sv_idle = coro_get_sv (aTHX_ "Coro::idle" , TRUE);
…		…
3467	api_ready (aTHX_ RETVAL);	3733	api_ready (aTHX_ RETVAL);
3468	OUTPUT:	3734	OUTPUT:
3469	RETVAL	3735	RETVAL
3470		3736
3471	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
3472	terminate (...)	3754	terminate (...)
3473	CODE:	3755	CODE:
3474	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
3475		3766
3476	void	3767	void
3477	schedule (...)	3768	schedule (...)
3478	CODE:	3769	CODE:
3479	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