ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/Coro/Coro/State.xs

Comparing Coro/Coro/State.xs (file contents):
Revision 1.393 by root, Fri Apr 29 17:38:56 2011 UTC vs.
Revision 1.409 by root, Sun Jun 12 04:29:15 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
…		…
86	# define STACKLEVEL ((void *)&stacklevel)	88	# define STACKLEVEL ((void *)&stacklevel)
87	#endif	89	#endif
88		90
89	#define IN_DESTRUCT PL_dirty	91	#define IN_DESTRUCT PL_dirty
90		92
91	#if __GNUC__ >= 3
92	# define attribute(x) __attribute__(x)
93	# define expect(expr,value) __builtin_expect ((expr), (value))
94	# define INLINE static inline
95	#else
96	# define attribute(x)
97	# define expect(expr,value) (expr)
98	# define INLINE static
99	#endif
100
101	#define expect_false(expr) expect ((expr) != 0, 0)
102	#define expect_true(expr) expect ((expr) != 0, 1)
103
104	#define NOINLINE attribute ((noinline))
105
106	#include "CoroAPI.h"	93	#include "CoroAPI.h"
107	#define GCoroAPI (&coroapi) /* very sneaky */	94	#define GCoroAPI (&coroapi) /* very sneaky */
108		95
109	#ifdef USE_ITHREADS	96	#ifdef USE_ITHREADS
110	# if CORO_PTHREAD	97	# if CORO_PTHREAD
111	static void *coro_thx;	98	static void *coro_thx;
112	# endif	99	# endif
113	#endif	100	#endif
		101
		102	/* used in state.h */
		103	#define VAR(name,type) VARx(name, PL_ ## name, type)
114		104
115	#ifdef __linux	105	#ifdef __linux
116	# include <time.h> /* for timespec */	106	# include <time.h> /* for timespec */
117	# include <syscall.h> /* for SYS_* */	107	# include <syscall.h> /* for SYS_* */
118	# ifdef SYS_clock_gettime	108	# ifdef SYS_clock_gettime
…		…
126	static void (*u2time)(pTHX_ UV ret[2]);	116	static void (*u2time)(pTHX_ UV ret[2]);
127		117
128	/* we hijack an hopefully unused CV flag for our purposes */	118	/* we hijack an hopefully unused CV flag for our purposes */
129	#define CVf_SLF 0x4000	119	#define CVf_SLF 0x4000
130	static OP *pp_slf (pTHX);	120	static OP *pp_slf (pTHX);
		121	static void slf_destroy (pTHX_ struct coro *coro);
131		122
132	static U32 cctx_gen;	123	static U32 cctx_gen;
133	static size_t cctx_stacksize = CORO_STACKSIZE;	124	static size_t cctx_stacksize = CORO_STACKSIZE;
134	static struct CoroAPI coroapi;	125	static struct CoroAPI coroapi;
135	static AV *main_mainstack; /* used to differentiate between $main and others */	126	static AV *main_mainstack; /* used to differentiate between $main and others */
…		…
165	static char times_valid;	156	static char times_valid;
166		157
167	static struct coro_cctx *cctx_first;	158	static struct coro_cctx *cctx_first;
168	static int cctx_count, cctx_idle;	159	static int cctx_count, cctx_idle;
169		160
170	enum {	161	enum
		162	{
171	CC_MAPPED = 0x01,	163	CC_MAPPED = 0x01,
172	CC_NOREUSE = 0x02, /* throw this away after tracing */	164	CC_NOREUSE = 0x02, /* throw this away after tracing */
173	CC_TRACE = 0x04,	165	CC_TRACE = 0x04,
174	CC_TRACE_SUB = 0x08, /* trace sub calls */	166	CC_TRACE_SUB = 0x08, /* trace sub calls */
175	CC_TRACE_LINE = 0x10, /* trace each statement */	167	CC_TRACE_LINE = 0x10, /* trace each statement */
…		…
200		192
201	static coro_cctx *cctx_current; /* the currently running cctx */	193	static coro_cctx *cctx_current; /* the currently running cctx */
202		194
203	/*****************************************************************************/	195	/*****************************************************************************/
204		196
		197	static MGVTBL coro_state_vtbl;
		198
205	enum {	199	enum
		200	{
206	CF_RUNNING = 0x0001, /* coroutine is running */	201	CF_RUNNING = 0x0001, /* coroutine is running */
207	CF_READY = 0x0002, /* coroutine is ready */	202	CF_READY = 0x0002, /* coroutine is ready */
208	CF_NEW = 0x0004, /* has never been switched to */	203	CF_NEW = 0x0004, /* has never been switched to */
209	CF_DESTROYED = 0x0008, /* coroutine data has been freed */	204	CF_ZOMBIE = 0x0008, /* coroutine data has been freed */
210	CF_SUSPENDED = 0x0010, /* coroutine can't be scheduled */	205	CF_SUSPENDED = 0x0010, /* coroutine can't be scheduled */
211	CF_NOCANCEL = 0x0020, /* cannot cancel, set slf_frame.data to 1 (hackish) */	206	CF_NOCANCEL = 0x0020, /* cannot cancel, set slf_frame.data to 1 (hackish) */
212	};	207	};
213		208
214	/* the structure where most of the perl state is stored, overlaid on the cxstack */	209	/* the structure where most of the perl state is stored, overlaid on the cxstack */
215	typedef struct	210	typedef struct
216	{	211	{
217	SV *defsv;
218	AV *defav;
219	SV *errsv;
220	SV *irsgv;
221	HV *hinthv;
222	#define VAR(name,type) type name;	212	#define VARx(name,expr,type) type name;
223	# include "state.h"	213	# include "state.h"
224	#undef VAR	214	#undef VARx
225	} perl_slots;	215	} perl_slots;
226		216
		217	// how many context stack entries do we need for perl_slots
227	#define SLOT_COUNT ((sizeof (perl_slots) + sizeof (PERL_CONTEXT) - 1) / sizeof (PERL_CONTEXT))	218	#define SLOT_COUNT ((sizeof (perl_slots) + sizeof (PERL_CONTEXT) - 1) / sizeof (PERL_CONTEXT))
228		219
229	/* this is a structure representing a perl-level coroutine */	220	/* this is a structure representing a perl-level coroutine */
230	struct coro {	221	struct coro
		222	{
231	/* the C coroutine allocated to this perl coroutine, if any */	223	/* the C coroutine allocated to this perl coroutine, if any */
232	coro_cctx *cctx;	224	coro_cctx *cctx;
233		225
234	/* ready queue */	226	/* ready queue */
235	struct coro *next_ready;	227	struct coro *next_ready;
…		…
237	/* state data */	229	/* state data */
238	struct CoroSLF slf_frame; /* saved slf frame */	230	struct CoroSLF slf_frame; /* saved slf frame */
239	AV *mainstack;	231	AV *mainstack;
240	perl_slots *slot; /* basically the saved sp */	232	perl_slots *slot; /* basically the saved sp */
241		233
242	CV *startcv; /* the CV to execute */	234	CV *startcv; /* the CV to execute */
243	AV *args; /* data associated with this coroutine (initial args) */	235	AV *args; /* data associated with this coroutine (initial args) */
244	int refcnt; /* coroutines are refcounted, yes */
245	int flags; /* CF_ flags */	236	int flags; /* CF_ flags */
246	HV *hv; /* the perl hash associated with this coro, if any */	237	HV *hv; /* the perl hash associated with this coro, if any */
247	void (*on_destroy)(pTHX_ struct coro *coro); /* for temporary use by xs in critical sections */
248		238
249	/* statistics */	239	/* statistics */
250	int usecount; /* number of transfers to this coro */	240	int usecount; /* number of transfers to this coro */
251		241
252	/* coro process data */	242	/* coro process data */
253	int prio;	243	int prio;
254	SV *except; /* exception to be thrown */	244	SV *except; /* exception to be thrown */
255	SV *rouse_cb;	245	SV *rouse_cb; /* last rouse callback */
		246	AV *on_destroy; /* callbacks or coros to notify on destroy */
		247	AV *status; /* the exit status list */
256		248
257	/* async_pool */	249	/* async_pool */
258	SV *saved_deffh;	250	SV *saved_deffh;
259	SV *invoke_cb;	251	SV *invoke_cb;
260	AV *invoke_av;	252	AV *invoke_av;
…		…
292		284
293	/* for Coro.pm */	285	/* for Coro.pm */
294	static SV *coro_current;	286	static SV *coro_current;
295	static SV *coro_readyhook;	287	static SV *coro_readyhook;
296	static struct coro *coro_ready [CORO_PRIO_MAX - CORO_PRIO_MIN + 1][2]; /* head|tail */	288	static struct coro *coro_ready [CORO_PRIO_MAX - CORO_PRIO_MIN + 1][2]; /* head|tail */
297	static CV *cv_coro_run, *cv_coro_terminate;	289	static CV *cv_coro_run;
298	static struct coro *coro_first;	290	static struct coro *coro_first;
299	#define coro_nready coroapi.nready	291	#define coro_nready coroapi.nready
		292
		293	/** JIT *********************************************************************/
		294
		295	#if CORO_JIT
		296	#ifndef CORO_JIT_TYPE
		297	#if __x86_64 && (__linux || __FreeBSD__ || __OpenBSD__ || __NetBSD__ || __solaris)
		298	#define CORO_JIT_TYPE "amd64-unix"
		299	typedef void (*load_save_perl_slots_type)(perl_slots *);
		300	#elif __i386 && (__linux || __FreeBSD__ || __OpenBSD__ || __NetBSD__ || __solaris)
		301	#define CORO_JIT_TYPE "x86-unix"
		302	typedef void (*load_save_perl_slots_type)(perl_slots *);
		303	#else
		304	x x x x
		305	#undef CORO_JIT
		306	#endif
		307	#endif
		308	#endif
		309
		310	#if CORO_JIT
		311	static load_save_perl_slots_type load_perl_slots, save_perl_slots;
		312	#endif
300		313
301	/** Coro::Select ************************************************************/	314	/** Coro::Select ************************************************************/
302		315
303	static OP *(*coro_old_pp_sselect) (pTHX);	316	static OP *(*coro_old_pp_sselect) (pTHX);
304	static SV *coro_select_select;	317	static SV *coro_select_select;
…		…
320		333
321	/** time stuff **************************************************************/	334	/** time stuff **************************************************************/
322		335
323	#ifdef HAS_GETTIMEOFDAY	336	#ifdef HAS_GETTIMEOFDAY
324		337
325	static void	338	ECB_INLINE void
326	coro_u2time (pTHX_ UV ret[2])	339	coro_u2time (pTHX_ UV ret[2])
327	{	340	{
328	struct timeval tv;	341	struct timeval tv;
329	gettimeofday (&tv, 0);	342	gettimeofday (&tv, 0);
330		343
331	ret [0] = tv.tv_sec;	344	ret [0] = tv.tv_sec;
332	ret [1] = tv.tv_usec;	345	ret [1] = tv.tv_usec;
333	}	346	}
334		347
335	static double	348	ECB_INLINE double
336	coro_nvtime ()	349	coro_nvtime ()
337	{	350	{
338	struct timeval tv;	351	struct timeval tv;
339	gettimeofday (&tv, 0);	352	gettimeofday (&tv, 0);
340		353
341	return tv.tv_sec + tv.tv_usec * 1e-6;	354	return tv.tv_sec + tv.tv_usec * 1e-6;
342	}	355	}
343		356
344	static void	357	ECB_INLINE void
345	time_init (pTHX)	358	time_init (pTHX)
346	{	359	{
347	nvtime = coro_nvtime;	360	nvtime = coro_nvtime;
348	u2time = coro_u2time;	361	u2time = coro_u2time;
349	}	362	}
350		363
351	#else	364	#else
352		365
353	static void	366	ECB_INLINE void
354	time_init (pTHX)	367	time_init (pTHX)
355	{	368	{
356	SV **svp;	369	SV **svp;
357		370
358	require_pv ("Time/HiRes.pm");	371	require_pv ("Time/HiRes.pm");
…		…
370		383
371	#endif	384	#endif
372		385
373	/** lowlevel stuff **********************************************************/	386	/** lowlevel stuff **********************************************************/
374		387
375	static SV *	388	static SV * ecb_noinline
376	coro_get_sv (pTHX_ const char *name, int create)	389	coro_get_sv (pTHX_ const char *name, int create)
377	{	390	{
378	#if PERL_VERSION_ATLEAST (5,10,0)	391	#if PERL_VERSION_ATLEAST (5,10,0)
379	/* silence stupid and wrong 5.10 warning that I am unable to switch off */	392	/* silence stupid and wrong 5.10 warning that I am unable to switch off */
380	get_sv (name, create);	393	get_sv (name, create);
381	#endif	394	#endif
382	return get_sv (name, create);	395	return get_sv (name, create);
383	}	396	}
384		397
385	static AV *	398	static AV * ecb_noinline
386	coro_get_av (pTHX_ const char *name, int create)	399	coro_get_av (pTHX_ const char *name, int create)
387	{	400	{
388	#if PERL_VERSION_ATLEAST (5,10,0)	401	#if PERL_VERSION_ATLEAST (5,10,0)
389	/* silence stupid and wrong 5.10 warning that I am unable to switch off */	402	/* silence stupid and wrong 5.10 warning that I am unable to switch off */
390	get_av (name, create);	403	get_av (name, create);
391	#endif	404	#endif
392	return get_av (name, create);	405	return get_av (name, create);
393	}	406	}
394		407
395	static HV *	408	static HV * ecb_noinline
396	coro_get_hv (pTHX_ const char *name, int create)	409	coro_get_hv (pTHX_ const char *name, int create)
397	{	410	{
398	#if PERL_VERSION_ATLEAST (5,10,0)	411	#if PERL_VERSION_ATLEAST (5,10,0)
399	/* silence stupid and wrong 5.10 warning that I am unable to switch off */	412	/* silence stupid and wrong 5.10 warning that I am unable to switch off */
400	get_hv (name, create);	413	get_hv (name, create);
401	#endif	414	#endif
402	return get_hv (name, create);	415	return get_hv (name, create);
403	}	416	}
404		417
405	INLINE void	418	ECB_INLINE void
406	coro_times_update ()	419	coro_times_update ()
407	{	420	{
408	#ifdef coro_clock_gettime	421	#ifdef coro_clock_gettime
409	struct timespec ts;	422	struct timespec ts;
410		423
…		…
423	time_real [0] = tv [0];	436	time_real [0] = tv [0];
424	time_real [1] = tv [1] * 1000;	437	time_real [1] = tv [1] * 1000;
425	#endif	438	#endif
426	}	439	}
427		440
428	INLINE void	441	ECB_INLINE void
429	coro_times_add (struct coro *c)	442	coro_times_add (struct coro *c)
430	{	443	{
431	c->t_real [1] += time_real [1];	444	c->t_real [1] += time_real [1];
432	if (c->t_real [1] > 1000000000) { c->t_real [1] -= 1000000000; ++c->t_real [0]; }	445	if (c->t_real [1] > 1000000000) { c->t_real [1] -= 1000000000; ++c->t_real [0]; }
433	c->t_real [0] += time_real [0];	446	c->t_real [0] += time_real [0];
…		…
435	c->t_cpu [1] += time_cpu [1];	448	c->t_cpu [1] += time_cpu [1];
436	if (c->t_cpu [1] > 1000000000) { c->t_cpu [1] -= 1000000000; ++c->t_cpu [0]; }	449	if (c->t_cpu [1] > 1000000000) { c->t_cpu [1] -= 1000000000; ++c->t_cpu [0]; }
437	c->t_cpu [0] += time_cpu [0];	450	c->t_cpu [0] += time_cpu [0];
438	}	451	}
439		452
440	INLINE void	453	ECB_INLINE void
441	coro_times_sub (struct coro *c)	454	coro_times_sub (struct coro *c)
442	{	455	{
443	if (c->t_real [1] < time_real [1]) { c->t_real [1] += 1000000000; --c->t_real [0]; }	456	if (c->t_real [1] < time_real [1]) { c->t_real [1] += 1000000000; --c->t_real [0]; }
444	c->t_real [1] -= time_real [1];	457	c->t_real [1] -= time_real [1];
445	c->t_real [0] -= time_real [0];	458	c->t_real [0] -= time_real [0];
…		…
453	/* magic glue */	466	/* magic glue */
454		467
455	#define CORO_MAGIC_type_cv 26	468	#define CORO_MAGIC_type_cv 26
456	#define CORO_MAGIC_type_state PERL_MAGIC_ext	469	#define CORO_MAGIC_type_state PERL_MAGIC_ext
457		470
458	#define CORO_MAGIC_NN(sv, type) \	471	#define CORO_MAGIC_NN(sv, type) \
459	(expect_true (SvMAGIC (sv)->mg_type == type) \	472	(ecb_expect_true (SvMAGIC (sv)->mg_type == type) \
460	? SvMAGIC (sv) \	473	? SvMAGIC (sv) \
461	: mg_find (sv, type))	474	: mg_find (sv, type))
462		475
463	#define CORO_MAGIC(sv, type) \	476	#define CORO_MAGIC(sv, type) \
464	(expect_true (SvMAGIC (sv)) \	477	(ecb_expect_true (SvMAGIC (sv)) \
465	? CORO_MAGIC_NN (sv, type) \	478	? CORO_MAGIC_NN (sv, type) \
466	: 0)	479	: 0)
467		480
468	#define CORO_MAGIC_cv(cv) CORO_MAGIC (((SV *)(cv)), CORO_MAGIC_type_cv)	481	#define CORO_MAGIC_cv(cv) CORO_MAGIC (((SV *)(cv)), CORO_MAGIC_type_cv)
469	#define CORO_MAGIC_state(sv) CORO_MAGIC_NN (((SV *)(sv)), CORO_MAGIC_type_state)	482	#define CORO_MAGIC_state(sv) CORO_MAGIC_NN (((SV *)(sv)), CORO_MAGIC_type_state)
470		483
		484	ECB_INLINE MAGIC *
		485	SvSTATEhv_p (pTHX_ SV *coro)
		486	{
		487	MAGIC *mg;
		488
		489	if (ecb_expect_true (
		490	SvTYPE (coro) == SVt_PVHV
		491	&& (mg = CORO_MAGIC_state (coro))
		492	&& mg->mg_virtual == &coro_state_vtbl
		493	))
		494	return mg;
		495
		496	return 0;
		497	}
		498
471	INLINE struct coro *	499	ECB_INLINE struct coro *
472	SvSTATE_ (pTHX_ SV *coro)	500	SvSTATE_ (pTHX_ SV *coro)
473	{	501	{
474	HV *stash;
475	MAGIC *mg;	502	MAGIC *mg;
476		503
477	if (SvROK (coro))	504	if (SvROK (coro))
478	coro = SvRV (coro);	505	coro = SvRV (coro);
479		506
480	if (expect_false (SvTYPE (coro) != SVt_PVHV))	507	mg = SvSTATEhv_p (aTHX_ coro);
		508	if (!mg)
481	croak ("Coro::State object required");	509	croak ("Coro::State object required");
482		510
483	stash = SvSTASH (coro);
484	if (expect_false (stash != coro_stash && stash != coro_state_stash))
485	{
486	/* very slow, but rare, check */
487	if (!sv_derived_from (sv_2mortal (newRV_inc (coro)), "Coro::State"))
488	croak ("Coro::State object required");
489	}
490
491	mg = CORO_MAGIC_state (coro);
492	return (struct coro *)mg->mg_ptr;	511	return (struct coro *)mg->mg_ptr;
493	}	512	}
494		513
495	#define SvSTATE(sv) SvSTATE_ (aTHX_ (sv))	514	#define SvSTATE(sv) SvSTATE_ (aTHX_ (sv))
496		515
…		…
499	#define SvSTATE_current SvSTATE_hv (SvRV (coro_current))	518	#define SvSTATE_current SvSTATE_hv (SvRV (coro_current))
500		519
501	/*****************************************************************************/	520	/*****************************************************************************/
502	/* padlist management and caching */	521	/* padlist management and caching */
503		522
504	static AV *	523	ECB_INLINE AV *
505	coro_derive_padlist (pTHX_ CV *cv)	524	coro_derive_padlist (pTHX_ CV *cv)
506	{	525	{
507	AV *padlist = CvPADLIST (cv);	526	AV *padlist = CvPADLIST (cv);
508	AV *newpadlist, *newpad;	527	AV *newpadlist, *newpad;
509		528
…		…
521	av_store (newpadlist, 1, (SV *)newpad);	540	av_store (newpadlist, 1, (SV *)newpad);
522		541
523	return newpadlist;	542	return newpadlist;
524	}	543	}
525		544
526	static void	545	ECB_INLINE void
527	free_padlist (pTHX_ AV *padlist)	546	free_padlist (pTHX_ AV *padlist)
528	{	547	{
529	/* may be during global destruction */	548	/* may be during global destruction */
530	if (!IN_DESTRUCT)	549	if (!IN_DESTRUCT)
531	{	550	{
…		…
574	0, 0, 0, 0,	593	0, 0, 0, 0,
575	coro_cv_free	594	coro_cv_free
576	};	595	};
577		596
578	/* the next two functions merely cache the padlists */	597	/* the next two functions merely cache the padlists */
579	static void	598	ECB_INLINE void
580	get_padlist (pTHX_ CV *cv)	599	get_padlist (pTHX_ CV *cv)
581	{	600	{
582	MAGIC *mg = CORO_MAGIC_cv (cv);	601	MAGIC *mg = CORO_MAGIC_cv (cv);
583	AV *av;	602	AV *av;
584		603
585	if (expect_true (mg && AvFILLp ((av = (AV *)mg->mg_obj)) >= 0))	604	if (ecb_expect_true (mg && AvFILLp ((av = (AV *)mg->mg_obj)) >= 0))
586	CvPADLIST (cv) = (AV *)AvARRAY (av)[AvFILLp (av)--];	605	CvPADLIST (cv) = (AV *)AvARRAY (av)[AvFILLp (av)--];
587	else	606	else
588	{	607	{
589	#if CORO_PREFER_PERL_FUNCTIONS	608	#if CORO_PREFER_PERL_FUNCTIONS
590	/* this is probably cleaner? but also slower! */	609	/* this is probably cleaner? but also slower! */
…		…
597	CvPADLIST (cv) = coro_derive_padlist (aTHX_ cv);	616	CvPADLIST (cv) = coro_derive_padlist (aTHX_ cv);
598	#endif	617	#endif
599	}	618	}
600	}	619	}
601		620
602	static void	621	ECB_INLINE void
603	put_padlist (pTHX_ CV *cv)	622	put_padlist (pTHX_ CV *cv)
604	{	623	{
605	MAGIC *mg = CORO_MAGIC_cv (cv);	624	MAGIC *mg = CORO_MAGIC_cv (cv);
606	AV *av;	625	AV *av;
607		626
608	if (expect_false (!mg))	627	if (ecb_expect_false (!mg))
609	mg = sv_magicext ((SV *)cv, (SV *)newAV (), CORO_MAGIC_type_cv, &coro_cv_vtbl, 0, 0);	628	mg = sv_magicext ((SV *)cv, (SV *)newAV (), CORO_MAGIC_type_cv, &coro_cv_vtbl, 0, 0);
610		629
611	av = (AV *)mg->mg_obj;	630	av = (AV *)mg->mg_obj;
612		631
613	if (expect_false (AvFILLp (av) >= AvMAX (av)))	632	if (ecb_expect_false (AvFILLp (av) >= AvMAX (av)))
614	av_extend (av, AvFILLp (av) + 1);	633	av_extend (av, AvFILLp (av) + 1);
615		634
616	AvARRAY (av)[++AvFILLp (av)] = (SV *)CvPADLIST (cv);	635	AvARRAY (av)[++AvFILLp (av)] = (SV *)CvPADLIST (cv);
617	}	636	}
618		637
…		…
663	}	682	}
664	#endif	683	#endif
665	}	684	}
666	}	685	}
667		686
668	#define SWAP_SVS(coro) \	687	#define SWAP_SVS(coro) \
669	if (expect_false ((coro)->swap_sv)) \	688	if (ecb_expect_false ((coro)->swap_sv)) \
670	swap_svs (aTHX_ (coro))	689	swap_svs (aTHX_ (coro))
671		690
672	static void	691	static void
673	on_enterleave_call (pTHX_ SV *cb);	692	on_enterleave_call (pTHX_ SV *cb);
674		693
…		…
678	perl_slots *slot = c->slot;	697	perl_slots *slot = c->slot;
679	c->slot = 0;	698	c->slot = 0;
680		699
681	PL_mainstack = c->mainstack;	700	PL_mainstack = c->mainstack;
682		701
683	GvSV (PL_defgv) = slot->defsv;	702	#if CORO_JIT
684	GvAV (PL_defgv) = slot->defav;	703	load_perl_slots (slot);
685	GvSV (PL_errgv) = slot->errsv;	704	#else
686	GvSV (irsgv) = slot->irsgv;
687	GvHV (PL_hintgv) = slot->hinthv;
688
689	#define VAR(name,type) PL_ ## name = slot->name;	705	#define VARx(name,expr,type) expr = slot->name;
690	# include "state.h"	706	# include "state.h"
691	#undef VAR	707	#undef VARx
		708	#endif
692		709
693	{	710	{
694	dSP;	711	dSP;
695		712
696	CV *cv;	713	CV *cv;
697		714
698	/* now do the ugly restore mess */	715	/* now do the ugly restore mess */
699	while (expect_true (cv = (CV *)POPs))	716	while (ecb_expect_true (cv = (CV *)POPs))
700	{	717	{
701	put_padlist (aTHX_ cv); /* mark this padlist as available */	718	put_padlist (aTHX_ cv); /* mark this padlist as available */
702	CvDEPTH (cv) = PTR2IV (POPs);	719	CvDEPTH (cv) = PTR2IV (POPs);
703	CvPADLIST (cv) = (AV *)POPs;	720	CvPADLIST (cv) = (AV *)POPs;
704	}	721	}
…		…
707	}	724	}
708		725
709	slf_frame = c->slf_frame;	726	slf_frame = c->slf_frame;
710	CORO_THROW = c->except;	727	CORO_THROW = c->except;
711		728
712	if (expect_false (enable_times))	729	if (ecb_expect_false (enable_times))
713	{	730	{
714	if (expect_false (!times_valid))	731	if (ecb_expect_false (!times_valid))
715	coro_times_update ();	732	coro_times_update ();
716		733
717	coro_times_sub (c);	734	coro_times_sub (c);
718	}	735	}
719		736
720	if (expect_false (c->on_enter))	737	if (ecb_expect_false (c->on_enter))
721	{	738	{
722	int i;	739	int i;
723		740
724	for (i = 0; i <= AvFILLp (c->on_enter); ++i)	741	for (i = 0; i <= AvFILLp (c->on_enter); ++i)
725	on_enterleave_call (aTHX_ AvARRAY (c->on_enter)[i]);	742	on_enterleave_call (aTHX_ AvARRAY (c->on_enter)[i]);
…		…
731	static void	748	static void
732	save_perl (pTHX_ Coro__State c)	749	save_perl (pTHX_ Coro__State c)
733	{	750	{
734	SWAP_SVS (c);	751	SWAP_SVS (c);
735		752
736	if (expect_false (c->on_leave))	753	if (ecb_expect_false (c->on_leave))
737	{	754	{
738	int i;	755	int i;
739		756
740	for (i = AvFILLp (c->on_leave); i >= 0; --i)	757	for (i = AvFILLp (c->on_leave); i >= 0; --i)
741	on_enterleave_call (aTHX_ AvARRAY (c->on_leave)[i]);	758	on_enterleave_call (aTHX_ AvARRAY (c->on_leave)[i]);
742	}	759	}
743		760
744	times_valid = 0;	761	times_valid = 0;
745		762
746	if (expect_false (enable_times))	763	if (ecb_expect_false (enable_times))
747	{	764	{
748	coro_times_update (); times_valid = 1;	765	coro_times_update (); times_valid = 1;
749	coro_times_add (c);	766	coro_times_add (c);
750	}	767	}
751		768
…		…
765		782
766	XPUSHs (Nullsv);	783	XPUSHs (Nullsv);
767	/* this loop was inspired by pp_caller */	784	/* this loop was inspired by pp_caller */
768	for (;;)	785	for (;;)
769	{	786	{
770	while (expect_true (cxix >= 0))	787	while (ecb_expect_true (cxix >= 0))
771	{	788	{
772	PERL_CONTEXT *cx = &ccstk[cxix--];	789	PERL_CONTEXT *cx = &ccstk[cxix--];
773		790
774	if (expect_true (CxTYPE (cx) == CXt_SUB) || expect_false (CxTYPE (cx) == CXt_FORMAT))	791	if (ecb_expect_true (CxTYPE (cx) == CXt_SUB) || ecb_expect_false (CxTYPE (cx) == CXt_FORMAT))
775	{	792	{
776	CV *cv = cx->blk_sub.cv;	793	CV *cv = cx->blk_sub.cv;
777		794
778	if (expect_true (CvDEPTH (cv)))	795	if (ecb_expect_true (CvDEPTH (cv)))
779	{	796	{
780	EXTEND (SP, 3);	797	EXTEND (SP, 3);
781	PUSHs ((SV *)CvPADLIST (cv));	798	PUSHs ((SV *)CvPADLIST (cv));
782	PUSHs (INT2PTR (SV *, (IV)CvDEPTH (cv)));	799	PUSHs (INT2PTR (SV *, (IV)CvDEPTH (cv)));
783	PUSHs ((SV *)cv);	800	PUSHs ((SV *)cv);
…		…
786	get_padlist (aTHX_ cv);	803	get_padlist (aTHX_ cv);
787	}	804	}
788	}	805	}
789	}	806	}
790		807
791	if (expect_true (top_si->si_type == PERLSI_MAIN))	808	if (ecb_expect_true (top_si->si_type == PERLSI_MAIN))
792	break;	809	break;
793		810
794	top_si = top_si->si_prev;	811	top_si = top_si->si_prev;
795	ccstk = top_si->si_cxstack;	812	ccstk = top_si->si_cxstack;
796	cxix = top_si->si_cxix;	813	cxix = top_si->si_cxix;
…		…
798		815
799	PUTBACK;	816	PUTBACK;
800	}	817	}
801		818
802	/* allocate some space on the context stack for our purposes */	819	/* allocate some space on the context stack for our purposes */
803	/* we manually unroll here, as usually 2 slots is enough */	820	if (ecb_expect_false (cxstack_ix + SLOT_COUNT >= cxstack_max))
804	if (SLOT_COUNT >= 1) CXINC;
805	if (SLOT_COUNT >= 2) CXINC;
806	if (SLOT_COUNT >= 3) CXINC;
807	{	821	{
808	unsigned int i;	822	unsigned int i;
		823
809	for (i = 3; i < SLOT_COUNT; ++i)	824	for (i = 0; i < SLOT_COUNT; ++i)
810	CXINC;	825	CXINC;
811	}	826
812	cxstack_ix -= SLOT_COUNT; /* undo allocation */	827	cxstack_ix -= SLOT_COUNT; /* undo allocation */
		828	}
813		829
814	c->mainstack = PL_mainstack;	830	c->mainstack = PL_mainstack;
815		831
816	{	832	{
817	perl_slots *slot = c->slot = (perl_slots *)(cxstack + cxstack_ix + 1);	833	perl_slots *slot = c->slot = (perl_slots *)(cxstack + cxstack_ix + 1);
818		834
819	slot->defav = GvAV (PL_defgv);	835	#if CORO_JIT
820	slot->defsv = DEFSV;	836	save_perl_slots (slot);
821	slot->errsv = ERRSV;	837	#else
822	slot->irsgv = GvSV (irsgv);
823	slot->hinthv = GvHV (PL_hintgv);
824
825	#define VAR(name,type) slot->name = PL_ ## name;	838	#define VARx(name,expr,type) slot->name = expr;
826	# include "state.h"	839	# include "state.h"
827	#undef VAR	840	#undef VARx
		841	#endif
828	}	842	}
829	}	843	}
830		844
831	/*	845	/*
832	* allocate various perl stacks. This is almost an exact copy	846	* allocate various perl stacks. This is almost an exact copy
…		…
838	# define coro_init_stacks(thx) init_stacks ()	852	# define coro_init_stacks(thx) init_stacks ()
839	#else	853	#else
840	static void	854	static void
841	coro_init_stacks (pTHX)	855	coro_init_stacks (pTHX)
842	{	856	{
843	PL_curstackinfo = new_stackinfo(32, 8);	857	PL_curstackinfo = new_stackinfo(32, 4 + SLOT_COUNT); /* 3 is minimum due to perl rounding down in scope.c:GROW() */
844	PL_curstackinfo->si_type = PERLSI_MAIN;	858	PL_curstackinfo->si_type = PERLSI_MAIN;
845	PL_curstack = PL_curstackinfo->si_stack;	859	PL_curstack = PL_curstackinfo->si_stack;
846	PL_mainstack = PL_curstack; /* remember in case we switch stacks */	860	PL_mainstack = PL_curstack; /* remember in case we switch stacks */
847		861
848	PL_stack_base = AvARRAY(PL_curstack);	862	PL_stack_base = AvARRAY(PL_curstack);
…		…
955	#endif	969	#endif
956		970
957	/*	971	/*
958	* This overrides the default magic get method of %SIG elements.	972	* This overrides the default magic get method of %SIG elements.
959	* The original one doesn't provide for reading back of PL_diehook/PL_warnhook	973	* The original one doesn't provide for reading back of PL_diehook/PL_warnhook
960	* and instead of trying to save and restore the hash elements, we just provide	974	* and instead of trying to save and restore the hash elements (extremely slow),
961	* readback here.	975	* we just provide our own readback here.
962	*/	976	*/
963	static int	977	static int ecb_cold
964	coro_sigelem_get (pTHX_ SV *sv, MAGIC *mg)	978	coro_sigelem_get (pTHX_ SV *sv, MAGIC *mg)
965	{	979	{
966	const char *s = MgPV_nolen_const (mg);	980	const char *s = MgPV_nolen_const (mg);
967		981
968	if (*s == '_')	982	if (*s == '_')
…		…
980	}	994	}
981		995
982	return orig_sigelem_get ? orig_sigelem_get (aTHX_ sv, mg) : 0;	996	return orig_sigelem_get ? orig_sigelem_get (aTHX_ sv, mg) : 0;
983	}	997	}
984		998
985	static int	999	static int ecb_cold
986	coro_sigelem_clr (pTHX_ SV *sv, MAGIC *mg)	1000	coro_sigelem_clr (pTHX_ SV *sv, MAGIC *mg)
987	{	1001	{
988	const char *s = MgPV_nolen_const (mg);	1002	const char *s = MgPV_nolen_const (mg);
989		1003
990	if (*s == '_')	1004	if (*s == '_')
…		…
1004	}	1018	}
1005		1019
1006	return orig_sigelem_clr ? orig_sigelem_clr (aTHX_ sv, mg) : 0;	1020	return orig_sigelem_clr ? orig_sigelem_clr (aTHX_ sv, mg) : 0;
1007	}	1021	}
1008		1022
1009	static int	1023	static int ecb_cold
1010	coro_sigelem_set (pTHX_ SV *sv, MAGIC *mg)	1024	coro_sigelem_set (pTHX_ SV *sv, MAGIC *mg)
1011	{	1025	{
1012	const char *s = MgPV_nolen_const (mg);	1026	const char *s = MgPV_nolen_const (mg);
1013		1027
1014	if (*s == '_')	1028	if (*s == '_')
…		…
1049	return 1;	1063	return 1;
1050	}	1064	}
1051		1065
1052	static UNOP init_perl_op;	1066	static UNOP init_perl_op;
1053		1067
1054	static void NOINLINE /* noinline to keep it out of the transfer fast path */	1068	ecb_noinline static void /* noinline to keep it out of the transfer fast path */
1055	init_perl (pTHX_ struct coro *coro)	1069	init_perl (pTHX_ struct coro *coro)
1056	{	1070	{
1057	/*	1071	/*
1058	* emulate part of the perl startup here.	1072	* emulate part of the perl startup here.
1059	*/	1073	*/
…		…
1074	PL_parser = 0;	1088	PL_parser = 0;
1075	#endif	1089	#endif
1076	PL_hints = 0;	1090	PL_hints = 0;
1077		1091
1078	/* recreate the die/warn hooks */	1092	/* recreate the die/warn hooks */
1079	PL_diehook = 0; SvSetMagicSV (*hv_fetch (hv_sig, "__DIE__" , sizeof ("__DIE__" ) - 1, 1), rv_diehook );	1093	PL_diehook = SvREFCNT_inc (rv_diehook);
1080	PL_warnhook = 0; SvSetMagicSV (*hv_fetch (hv_sig, "__WARN__", sizeof ("__WARN__") - 1, 1), rv_warnhook);	1094	PL_warnhook = SvREFCNT_inc (rv_warnhook);
1081		1095
1082	GvSV (PL_defgv) = newSV (0);	1096	GvSV (PL_defgv) = newSV (0);
1083	GvAV (PL_defgv) = coro->args; coro->args = 0;	1097	GvAV (PL_defgv) = coro->args; coro->args = 0;
1084	GvSV (PL_errgv) = newSV (0);	1098	GvSV (PL_errgv) = newSV (0);
1085	GvSV (irsgv) = newSVpvn ("\n", 1); sv_magic (GvSV (irsgv), (SV *)irsgv, PERL_MAGIC_sv, "/", 0);	1099	GvSV (irsgv) = newSVpvn ("\n", 1); sv_magic (GvSV (irsgv), (SV *)irsgv, PERL_MAGIC_sv, "/", 0);
…		…
1106	/* this newly created coroutine might be run on an existing cctx which most	1120	/* this newly created coroutine might be run on an existing cctx which most
1107	* likely was suspended in pp_slf, so we have to emulate entering pp_slf here.	1121	* likely was suspended in pp_slf, so we have to emulate entering pp_slf here.
1108	*/	1122	*/
1109	slf_frame.prepare = prepare_nop; /* provide a nop function for an eventual pp_slf */	1123	slf_frame.prepare = prepare_nop; /* provide a nop function for an eventual pp_slf */
1110	slf_frame.check = slf_check_nop; /* signal pp_slf to not repeat */	1124	slf_frame.check = slf_check_nop; /* signal pp_slf to not repeat */
		1125	slf_frame.destroy = 0;
1111		1126
1112	/* and we have to provide the pp_slf op in any case, so pp_slf can skip it */	1127	/* and we have to provide the pp_slf op in any case, so pp_slf can skip it */
1113	init_perl_op.op_next = PL_op;	1128	init_perl_op.op_next = PL_op;
1114	init_perl_op.op_type = OP_ENTERSUB;	1129	init_perl_op.op_type = OP_ENTERSUB;
1115	init_perl_op.op_ppaddr = pp_slf;	1130	init_perl_op.op_ppaddr = pp_slf;
…		…
1120	/* copy throw, in case it was set before init_perl */	1135	/* copy throw, in case it was set before init_perl */
1121	CORO_THROW = coro->except;	1136	CORO_THROW = coro->except;
1122		1137
1123	SWAP_SVS (coro);	1138	SWAP_SVS (coro);
1124		1139
1125	if (expect_false (enable_times))	1140	if (ecb_expect_false (enable_times))
1126	{	1141	{
1127	coro_times_update ();	1142	coro_times_update ();
1128	coro_times_sub (coro);	1143	coro_times_sub (coro);
1129	}	1144	}
1130	}	1145	}
…		…
1154	destroy_perl (pTHX_ struct coro *coro)	1169	destroy_perl (pTHX_ struct coro *coro)
1155	{	1170	{
1156	SV *svf [9];	1171	SV *svf [9];
1157		1172
1158	{	1173	{
		1174	SV *old_current = SvRV (coro_current);
1159	struct coro *current = SvSTATE_current;	1175	struct coro *current = SvSTATE (old_current);
1160		1176
1161	assert (("FATAL: tried to destroy currently running coroutine", coro->mainstack != PL_mainstack));	1177	assert (("FATAL: tried to destroy currently running coroutine", coro->mainstack != PL_mainstack));
1162		1178
1163	save_perl (aTHX_ current);	1179	save_perl (aTHX_ current);
		1180
		1181	/* this will cause transfer_check to croak on block*/
		1182	SvRV_set (coro_current, (SV *)coro->hv);
		1183
1164	load_perl (aTHX_ coro);	1184	load_perl (aTHX_ coro);
1165		1185
1166	coro_unwind_stacks (aTHX);	1186	coro_unwind_stacks (aTHX);
1167	coro_destruct_stacks (aTHX);
1168		1187
1169	/* restore swapped sv's */	1188	/* restore swapped sv's */
1170	SWAP_SVS (coro);	1189	SWAP_SVS (coro);
		1190
		1191	coro_destruct_stacks (aTHX);
1171		1192
1172	// now save some sv's to be free'd later	1193	// now save some sv's to be free'd later
1173	svf [0] = GvSV (PL_defgv);	1194	svf [0] = GvSV (PL_defgv);
1174	svf [1] = (SV *)GvAV (PL_defgv);	1195	svf [1] = (SV *)GvAV (PL_defgv);
1175	svf [2] = GvSV (PL_errgv);	1196	svf [2] = GvSV (PL_errgv);
…		…
1179	svf [6] = (SV *)GvHV (PL_hintgv);	1200	svf [6] = (SV *)GvHV (PL_hintgv);
1180	svf [7] = PL_diehook;	1201	svf [7] = PL_diehook;
1181	svf [8] = PL_warnhook;	1202	svf [8] = PL_warnhook;
1182	assert (9 == sizeof (svf) / sizeof (*svf));	1203	assert (9 == sizeof (svf) / sizeof (*svf));
1183		1204
		1205	SvRV_set (coro_current, old_current);
		1206
1184	load_perl (aTHX_ current);	1207	load_perl (aTHX_ current);
1185	}	1208	}
1186		1209
1187	{	1210	{
1188	unsigned int i;	1211	unsigned int i;
…		…
1195	SvREFCNT_dec (coro->invoke_cb);	1218	SvREFCNT_dec (coro->invoke_cb);
1196	SvREFCNT_dec (coro->invoke_av);	1219	SvREFCNT_dec (coro->invoke_av);
1197	}	1220	}
1198	}	1221	}
1199		1222
1200	INLINE void	1223	ECB_INLINE void
1201	free_coro_mortal (pTHX)	1224	free_coro_mortal (pTHX)
1202	{	1225	{
1203	if (expect_true (coro_mortal))	1226	if (ecb_expect_true (coro_mortal))
1204	{	1227	{
1205	SvREFCNT_dec (coro_mortal);	1228	SvREFCNT_dec ((SV *)coro_mortal);
1206	coro_mortal = 0;	1229	coro_mortal = 0;
1207	}	1230	}
1208	}	1231	}
1209		1232
1210	static int	1233	static int
…		…
1343		1366
1344	return frame->check (aTHX_ frame); /* execute the restored frame - there must be one */	1367	return frame->check (aTHX_ frame); /* execute the restored frame - there must be one */
1345	}	1368	}
1346		1369
1347	/* initialises PL_top_env and injects a pseudo-slf-call to set the stacklevel */	1370	/* initialises PL_top_env and injects a pseudo-slf-call to set the stacklevel */
1348	static void NOINLINE	1371	static void ecb_noinline
1349	cctx_prepare (pTHX)	1372	cctx_prepare (pTHX)
1350	{	1373	{
1351	PL_top_env = &PL_start_env;	1374	PL_top_env = &PL_start_env;
1352		1375
1353	if (cctx_current->flags & CC_TRACE)	1376	if (cctx_current->flags & CC_TRACE)
…		…
1364	slf_frame.prepare = slf_prepare_set_stacklevel;	1387	slf_frame.prepare = slf_prepare_set_stacklevel;
1365	slf_frame.check = slf_check_set_stacklevel;	1388	slf_frame.check = slf_check_set_stacklevel;
1366	}	1389	}
1367		1390
1368	/* the tail of transfer: execute stuff we can only do after a transfer */	1391	/* the tail of transfer: execute stuff we can only do after a transfer */
1369	INLINE void	1392	ECB_INLINE void
1370	transfer_tail (pTHX)	1393	transfer_tail (pTHX)
1371	{	1394	{
1372	free_coro_mortal (aTHX);	1395	free_coro_mortal (aTHX);
1373	}	1396	}
1374		1397
…		…
1526	#define CCTX_EXPIRED(cctx) ((cctx)->gen != cctx_gen || ((cctx)->flags & CC_NOREUSE))	1549	#define CCTX_EXPIRED(cctx) ((cctx)->gen != cctx_gen || ((cctx)->flags & CC_NOREUSE))
1527		1550
1528	static coro_cctx *	1551	static coro_cctx *
1529	cctx_get (pTHX)	1552	cctx_get (pTHX)
1530	{	1553	{
1531	while (expect_true (cctx_first))	1554	while (ecb_expect_true (cctx_first))
1532	{	1555	{
1533	coro_cctx *cctx = cctx_first;	1556	coro_cctx *cctx = cctx_first;
1534	cctx_first = cctx->next;	1557	cctx_first = cctx->next;
1535	--cctx_idle;	1558	--cctx_idle;
1536		1559
1537	if (expect_true (!CCTX_EXPIRED (cctx)))	1560	if (ecb_expect_true (!CCTX_EXPIRED (cctx)))
1538	return cctx;	1561	return cctx;
1539		1562
1540	cctx_destroy (cctx);	1563	cctx_destroy (cctx);
1541	}	1564	}
1542		1565
…		…
1547	cctx_put (coro_cctx *cctx)	1570	cctx_put (coro_cctx *cctx)
1548	{	1571	{
1549	assert (("FATAL: cctx_put called on non-initialised cctx in Coro (please report)", cctx->sptr));	1572	assert (("FATAL: cctx_put called on non-initialised cctx in Coro (please report)", cctx->sptr));
1550		1573
1551	/* free another cctx if overlimit */	1574	/* free another cctx if overlimit */
1552	if (expect_false (cctx_idle >= cctx_max_idle))	1575	if (ecb_expect_false (cctx_idle >= cctx_max_idle))
1553	{	1576	{
1554	coro_cctx *first = cctx_first;	1577	coro_cctx *first = cctx_first;
1555	cctx_first = first->next;	1578	cctx_first = first->next;
1556	--cctx_idle;	1579	--cctx_idle;
1557		1580
…		…
1568	static void	1591	static void
1569	transfer_check (pTHX_ struct coro *prev, struct coro *next)	1592	transfer_check (pTHX_ struct coro *prev, struct coro *next)
1570	{	1593	{
1571	/* TODO: throwing up here is considered harmful */	1594	/* TODO: throwing up here is considered harmful */
1572		1595
1573	if (expect_true (prev != next))	1596	if (ecb_expect_true (prev != next))
1574	{	1597	{
1575	if (expect_false (!(prev->flags & (CF_RUNNING | CF_NEW))))	1598	if (ecb_expect_false (!(prev->flags & (CF_RUNNING | CF_NEW))))
1576	croak ("Coro::State::transfer called with a blocked prev Coro::State, but can only transfer from running or new states,");	1599	croak ("Coro::State::transfer called with a blocked prev Coro::State, but can only transfer from running or new states,");
1577		1600
1578	if (expect_false (next->flags & (CF_RUNNING | CF_DESTROYED | CF_SUSPENDED)))	1601	if (ecb_expect_false (next->flags & (CF_RUNNING | CF_ZOMBIE | CF_SUSPENDED)))
1579	croak ("Coro::State::transfer called with running, destroyed or suspended next Coro::State, but can only transfer to inactive states,");	1602	croak ("Coro::State::transfer called with running, destroyed or suspended next Coro::State, but can only transfer to inactive states,");
1580		1603
1581	#if !PERL_VERSION_ATLEAST (5,10,0)	1604	#if !PERL_VERSION_ATLEAST (5,10,0)
1582	if (expect_false (PL_lex_state != LEX_NOTPARSING))	1605	if (ecb_expect_false (PL_lex_state != LEX_NOTPARSING))
1583	croak ("Coro::State::transfer called while parsing, but this is not supported in your perl version,");	1606	croak ("Coro::State::transfer called while parsing, but this is not supported in your perl version,");
1584	#endif	1607	#endif
1585	}	1608	}
1586	}	1609	}
1587		1610
1588	/* always use the TRANSFER macro */	1611	/* always use the TRANSFER macro */
1589	static void NOINLINE /* noinline so we have a fixed stackframe */	1612	static void ecb_noinline /* noinline so we have a fixed stackframe */
1590	transfer (pTHX_ struct coro *prev, struct coro *next, int force_cctx)	1613	transfer (pTHX_ struct coro *prev, struct coro *next, int force_cctx)
1591	{	1614	{
1592	dSTACKLEVEL;	1615	dSTACKLEVEL;
1593		1616
1594	/* sometimes transfer is only called to set idle_sp */	1617	/* sometimes transfer is only called to set idle_sp */
1595	if (expect_false (!prev))	1618	if (ecb_expect_false (!prev))
1596	{	1619	{
1597	cctx_current->idle_sp = STACKLEVEL;	1620	cctx_current->idle_sp = STACKLEVEL;
1598	assert (cctx_current->idle_te = PL_top_env); /* just for the side-effect when asserts are enabled */	1621	assert (cctx_current->idle_te = PL_top_env); /* just for the side-effect when asserts are enabled */
1599	}	1622	}
1600	else if (expect_true (prev != next))	1623	else if (ecb_expect_true (prev != next))
1601	{	1624	{
1602	coro_cctx *cctx_prev;	1625	coro_cctx *cctx_prev;
1603		1626
1604	if (expect_false (prev->flags & CF_NEW))	1627	if (ecb_expect_false (prev->flags & CF_NEW))
1605	{	1628	{
1606	/* create a new empty/source context */	1629	/* create a new empty/source context */
1607	prev->flags &= ~CF_NEW;	1630	prev->flags &= ~CF_NEW;
1608	prev->flags |= CF_RUNNING;	1631	prev->flags |= CF_RUNNING;
1609	}	1632	}
…		…
1612	next->flags |= CF_RUNNING;	1635	next->flags |= CF_RUNNING;
1613		1636
1614	/* first get rid of the old state */	1637	/* first get rid of the old state */
1615	save_perl (aTHX_ prev);	1638	save_perl (aTHX_ prev);
1616		1639
1617	if (expect_false (next->flags & CF_NEW))	1640	if (ecb_expect_false (next->flags & CF_NEW))
1618	{	1641	{
1619	/* need to start coroutine */	1642	/* need to start coroutine */
1620	next->flags &= ~CF_NEW;	1643	next->flags &= ~CF_NEW;
1621	/* setup coroutine call */	1644	/* setup coroutine call */
1622	init_perl (aTHX_ next);	1645	init_perl (aTHX_ next);
1623	}	1646	}
1624	else	1647	else
1625	load_perl (aTHX_ next);	1648	load_perl (aTHX_ next);
1626		1649
1627	/* possibly untie and reuse the cctx */	1650	/* possibly untie and reuse the cctx */
1628	if (expect_true (	1651	if (ecb_expect_true (
1629	cctx_current->idle_sp == STACKLEVEL	1652	cctx_current->idle_sp == STACKLEVEL
1630	&& !(cctx_current->flags & CC_TRACE)	1653	&& !(cctx_current->flags & CC_TRACE)
1631	&& !force_cctx	1654	&& !force_cctx
1632	))	1655	))
1633	{	1656	{
1634	/* I assume that stacklevel is a stronger indicator than PL_top_env changes */	1657	/* I assume that stacklevel is a stronger indicator than PL_top_env changes */
1635	assert (("FATAL: current top_env must equal previous top_env in Coro (please report)", PL_top_env == cctx_current->idle_te));	1658	assert (("FATAL: current top_env must equal previous top_env in Coro (please report)", PL_top_env == cctx_current->idle_te));
1636		1659
1637	/* if the cctx is about to be destroyed we need to make sure we won't see it in cctx_get. */	1660	/* if the cctx is about to be destroyed we need to make sure we won't see it in cctx_get. */
1638	/* without this the next cctx_get might destroy the running cctx while still in use */	1661	/* without this the next cctx_get might destroy the running cctx while still in use */
1639	if (expect_false (CCTX_EXPIRED (cctx_current)))	1662	if (ecb_expect_false (CCTX_EXPIRED (cctx_current)))
1640	if (expect_true (!next->cctx))	1663	if (ecb_expect_true (!next->cctx))
1641	next->cctx = cctx_get (aTHX);	1664	next->cctx = cctx_get (aTHX);
1642		1665
1643	cctx_put (cctx_current);	1666	cctx_put (cctx_current);
1644	}	1667	}
1645	else	1668	else
1646	prev->cctx = cctx_current;	1669	prev->cctx = cctx_current;
1647		1670
1648	++next->usecount;	1671	++next->usecount;
1649		1672
1650	cctx_prev = cctx_current;	1673	cctx_prev = cctx_current;
1651	cctx_current = expect_false (next->cctx) ? next->cctx : cctx_get (aTHX);	1674	cctx_current = ecb_expect_false (next->cctx) ? next->cctx : cctx_get (aTHX);
1652		1675
1653	next->cctx = 0;	1676	next->cctx = 0;
1654		1677
1655	if (expect_false (cctx_prev != cctx_current))	1678	if (ecb_expect_false (cctx_prev != cctx_current))
1656	{	1679	{
1657	cctx_prev->top_env = PL_top_env;	1680	cctx_prev->top_env = PL_top_env;
1658	PL_top_env = cctx_current->top_env;	1681	PL_top_env = cctx_current->top_env;
1659	coro_transfer (&cctx_prev->cctx, &cctx_current->cctx);	1682	coro_transfer (&cctx_prev->cctx, &cctx_current->cctx);
1660	}	1683	}
…		…
1666	#define TRANSFER(ta, force_cctx) transfer (aTHX_ (ta).prev, (ta).next, (force_cctx))	1689	#define TRANSFER(ta, force_cctx) transfer (aTHX_ (ta).prev, (ta).next, (force_cctx))
1667	#define TRANSFER_CHECK(ta) transfer_check (aTHX_ (ta).prev, (ta).next)	1690	#define TRANSFER_CHECK(ta) transfer_check (aTHX_ (ta).prev, (ta).next)
1668		1691
1669	/** high level stuff ********************************************************/	1692	/** high level stuff ********************************************************/
1670		1693
		1694	/* this function is actually Coro, not Coro::State, but we call it from here */
		1695	/* because it is convenient - but it hasn't been declared yet for that reason */
1671	static int	1696	static void
		1697	coro_call_on_destroy (pTHX_ struct coro *coro);
		1698
		1699	static void
1672	coro_state_destroy (pTHX_ struct coro *coro)	1700	coro_state_destroy (pTHX_ struct coro *coro)
1673	{	1701	{
1674	if (coro->flags & CF_DESTROYED)	1702	if (coro->flags & CF_ZOMBIE)
1675	return 0;	1703	return;
1676		1704
1677	if (coro->on_destroy && !PL_dirty)
1678	coro->on_destroy (aTHX_ coro);	1705	slf_destroy (aTHX_ coro);
1679		1706
1680	/*
1681	* The on_destroy above most likely is from an SLF call.
1682	* Since by definition the SLF call will not finish when we destroy
1683	* the coro, we will have to force-finish it here, otherwise
1684	* cleanup functions cannot call SLF functions.
1685	*/
1686	coro->slf_frame.prepare = 0;
1687
1688	coro->flags |= CF_DESTROYED;	1707	coro->flags |= CF_ZOMBIE;
1689		1708
1690	if (coro->flags & CF_READY)	1709	if (coro->flags & CF_READY)
1691	{	1710	{
1692	/* reduce nready, as destroying a ready coro effectively unreadies it */	1711	/* reduce nready, as destroying a ready coro effectively unreadies it */
1693	/* alternative: look through all ready queues and remove the coro */	1712	/* alternative: look through all ready queues and remove the coro */
1694	--coro_nready;	1713	--coro_nready;
1695	}	1714	}
1696	else	1715	else
1697	coro->flags |= CF_READY; /* make sure it is NOT put into the readyqueue */	1716	coro->flags |= CF_READY; /* make sure it is NOT put into the readyqueue */
		1717
		1718	if (coro->next) coro->next->prev = coro->prev;
		1719	if (coro->prev) coro->prev->next = coro->next;
		1720	if (coro == coro_first) coro_first = coro->next;
1698		1721
1699	if (coro->mainstack	1722	if (coro->mainstack
1700	&& coro->mainstack != main_mainstack	1723	&& coro->mainstack != main_mainstack
1701	&& coro->slot	1724	&& coro->slot
1702	&& !PL_dirty)	1725	&& !PL_dirty)
1703	destroy_perl (aTHX_ coro);	1726	destroy_perl (aTHX_ coro);
1704		1727
1705	if (coro->next) coro->next->prev = coro->prev;
1706	if (coro->prev) coro->prev->next = coro->next;
1707	if (coro == coro_first) coro_first = coro->next;
1708
1709	cctx_destroy (coro->cctx);	1728	cctx_destroy (coro->cctx);
1710	SvREFCNT_dec (coro->startcv);	1729	SvREFCNT_dec (coro->startcv);
1711	SvREFCNT_dec (coro->args);	1730	SvREFCNT_dec (coro->args);
1712	SvREFCNT_dec (coro->swap_sv);	1731	SvREFCNT_dec (coro->swap_sv);
1713	SvREFCNT_dec (CORO_THROW);	1732	SvREFCNT_dec (CORO_THROW);
1714		1733
1715	return 1;	1734	coro_call_on_destroy (aTHX_ coro);
		1735
		1736	/* more destruction mayhem in coro_state_free */
1716	}	1737	}
1717		1738
1718	static int	1739	static int
1719	coro_state_free (pTHX_ SV *sv, MAGIC *mg)	1740	coro_state_free (pTHX_ SV *sv, MAGIC *mg)
1720	{	1741	{
1721	struct coro *coro = (struct coro *)mg->mg_ptr;	1742	struct coro *coro = (struct coro *)mg->mg_ptr;
1722	mg->mg_ptr = 0;	1743	mg->mg_ptr = 0;
1723		1744
1724	coro->hv = 0;
1725
1726	if (--coro->refcnt < 0)
1727	{
1728	coro_state_destroy (aTHX_ coro);	1745	coro_state_destroy (aTHX_ coro);
		1746	SvREFCNT_dec (coro->on_destroy);
		1747	SvREFCNT_dec (coro->status);
		1748
1729	Safefree (coro);	1749	Safefree (coro);
1730	}
1731		1750
1732	return 0;	1751	return 0;
1733	}	1752	}
1734		1753
1735	static int	1754	static int ecb_cold
1736	coro_state_dup (pTHX_ MAGIC *mg, CLONE_PARAMS *params)	1755	coro_state_dup (pTHX_ MAGIC *mg, CLONE_PARAMS *params)
1737	{	1756	{
1738	struct coro *coro = (struct coro *)mg->mg_ptr;	1757	/* called when perl clones the current process the slow way (windows process emulation) */
1739		1758	/* WE SIMply nuke the pointers in the copy, causing perl to croak */
1740	++coro->refcnt;	1759	mg->mg_ptr = 0;
		1760	mg->mg_virtual = 0;
1741		1761
1742	return 0;	1762	return 0;
1743	}	1763	}
1744		1764
1745	static MGVTBL coro_state_vtbl = {	1765	static MGVTBL coro_state_vtbl = {
…		…
1770	TRANSFER (ta, 1);	1790	TRANSFER (ta, 1);
1771	}	1791	}
1772		1792
1773	/** Coro ********************************************************************/	1793	/** Coro ********************************************************************/
1774		1794
1775	INLINE void	1795	ECB_INLINE void
1776	coro_enq (pTHX_ struct coro *coro)	1796	coro_enq (pTHX_ struct coro *coro)
1777	{	1797	{
1778	struct coro **ready = coro_ready [coro->prio - CORO_PRIO_MIN];	1798	struct coro **ready = coro_ready [coro->prio - CORO_PRIO_MIN];
1779		1799
1780	SvREFCNT_inc_NN (coro->hv);	1800	SvREFCNT_inc_NN (coro->hv);
…		…
1782	coro->next_ready = 0;	1802	coro->next_ready = 0;
1783	*(ready [0] ? &ready [1]->next_ready : &ready [0]) = coro;	1803	*(ready [0] ? &ready [1]->next_ready : &ready [0]) = coro;
1784	ready [1] = coro;	1804	ready [1] = coro;
1785	}	1805	}
1786		1806
1787	INLINE struct coro *	1807	ECB_INLINE struct coro *
1788	coro_deq (pTHX)	1808	coro_deq (pTHX)
1789	{	1809	{
1790	int prio;	1810	int prio;
1791		1811
1792	for (prio = CORO_PRIO_MAX - CORO_PRIO_MIN + 1; --prio >= 0; )	1812	for (prio = CORO_PRIO_MAX - CORO_PRIO_MIN + 1; --prio >= 0; )
…		…
1845	{	1865	{
1846	return !!(SvSTATE (coro_sv)->flags & CF_READY);	1866	return !!(SvSTATE (coro_sv)->flags & CF_READY);
1847	}	1867	}
1848		1868
1849	/* expects to own a reference to next->hv */	1869	/* expects to own a reference to next->hv */
1850	INLINE void	1870	ECB_INLINE void
1851	prepare_schedule_to (pTHX_ struct coro_transfer_args *ta, struct coro *next)	1871	prepare_schedule_to (pTHX_ struct coro_transfer_args *ta, struct coro *next)
1852	{	1872	{
1853	SV *prev_sv = SvRV (coro_current);	1873	SV *prev_sv = SvRV (coro_current);
1854		1874
1855	ta->prev = SvSTATE_hv (prev_sv);	1875	ta->prev = SvSTATE_hv (prev_sv);
…		…
1868	{	1888	{
1869	for (;;)	1889	for (;;)
1870	{	1890	{
1871	struct coro *next = coro_deq (aTHX);	1891	struct coro *next = coro_deq (aTHX);
1872		1892
1873	if (expect_true (next))	1893	if (ecb_expect_true (next))
1874	{	1894	{
1875	/* cannot transfer to destroyed coros, skip and look for next */	1895	/* cannot transfer to destroyed coros, skip and look for next */
1876	if (expect_false (next->flags & (CF_DESTROYED | CF_SUSPENDED)))	1896	if (ecb_expect_false (next->flags & (CF_ZOMBIE | CF_SUSPENDED)))
1877	SvREFCNT_dec (next->hv); /* coro_nready has already been taken care of by destroy */	1897	SvREFCNT_dec (next->hv); /* coro_nready has already been taken care of by destroy */
1878	else	1898	else
1879	{	1899	{
1880	next->flags &= ~CF_READY;	1900	next->flags &= ~CF_READY;
1881	--coro_nready;	1901	--coro_nready;
…		…
1914	}	1934	}
1915	}	1935	}
1916	}	1936	}
1917	}	1937	}
1918		1938
1919	INLINE void	1939	ECB_INLINE void
1920	prepare_cede (pTHX_ struct coro_transfer_args *ta)	1940	prepare_cede (pTHX_ struct coro_transfer_args *ta)
1921	{	1941	{
1922	api_ready (aTHX_ coro_current);	1942	api_ready (aTHX_ coro_current);
1923	prepare_schedule (aTHX_ ta);	1943	prepare_schedule (aTHX_ ta);
1924	}	1944	}
1925		1945
1926	INLINE void	1946	ECB_INLINE void
1927	prepare_cede_notself (pTHX_ struct coro_transfer_args *ta)	1947	prepare_cede_notself (pTHX_ struct coro_transfer_args *ta)
1928	{	1948	{
1929	SV *prev = SvRV (coro_current);	1949	SV *prev = SvRV (coro_current);
1930		1950
1931	if (coro_nready)	1951	if (coro_nready)
…		…
1961	{	1981	{
1962	struct coro_transfer_args ta;	1982	struct coro_transfer_args ta;
1963		1983
1964	prepare_cede (aTHX_ &ta);	1984	prepare_cede (aTHX_ &ta);
1965		1985
1966	if (expect_true (ta.prev != ta.next))	1986	if (ecb_expect_true (ta.prev != ta.next))
1967	{	1987	{
1968	TRANSFER (ta, 1);	1988	TRANSFER (ta, 1);
1969	return 1;	1989	return 1;
1970	}	1990	}
1971	else	1991	else
…		…
2014	coro->slot->runops = RUNOPS_DEFAULT;	2034	coro->slot->runops = RUNOPS_DEFAULT;
2015	}	2035	}
2016	}	2036	}
2017		2037
2018	static void	2038	static void
		2039	coro_push_av (pTHX_ AV *av, I32 gimme_v)
		2040	{
		2041	if (AvFILLp (av) >= 0 && gimme_v != G_VOID)
		2042	{
		2043	dSP;
		2044
		2045	if (gimme_v == G_SCALAR)
		2046	XPUSHs (AvARRAY (av)[AvFILLp (av)]);
		2047	else
		2048	{
		2049	int i;
		2050	EXTEND (SP, AvFILLp (av) + 1);
		2051
		2052	for (i = 0; i <= AvFILLp (av); ++i)
		2053	PUSHs (AvARRAY (av)[i]);
		2054	}
		2055
		2056	PUTBACK;
		2057	}
		2058	}
		2059
		2060	static void
		2061	coro_push_on_destroy (pTHX_ struct coro *coro, SV *cb)
		2062	{
		2063	if (!coro->on_destroy)
		2064	coro->on_destroy = newAV ();
		2065
		2066	av_push (coro->on_destroy, cb);
		2067	}
		2068
		2069	static void
		2070	slf_destroy_join (pTHX_ struct CoroSLF *frame)
		2071	{
		2072	SvREFCNT_dec ((SV *)((struct coro *)frame->data)->hv);
		2073	}
		2074
		2075	static int
		2076	slf_check_join (pTHX_ struct CoroSLF *frame)
		2077	{
		2078	struct coro *coro = (struct coro *)frame->data;
		2079
		2080	if (!coro->status)
		2081	return 1;
		2082
		2083	frame->destroy = 0;
		2084
		2085	coro_push_av (aTHX_ coro->status, GIMME_V);
		2086
		2087	SvREFCNT_dec ((SV *)coro->hv);
		2088
		2089	return 0;
		2090	}
		2091
		2092	static void
		2093	slf_init_join (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
		2094	{
		2095	struct coro *coro = SvSTATE (items > 0 ? arg [0] : &PL_sv_undef);
		2096
		2097	if (items > 1)
		2098	croak ("join called with too many arguments");
		2099
		2100	if (coro->status)
		2101	frame->prepare = prepare_nop;
		2102	else
		2103	{
		2104	coro_push_on_destroy (aTHX_ coro, SvREFCNT_inc_NN (SvRV (coro_current)));
		2105	frame->prepare = prepare_schedule;
		2106	}
		2107
		2108	frame->check = slf_check_join;
		2109	frame->destroy = slf_destroy_join;
		2110	frame->data = (void *)coro;
		2111	SvREFCNT_inc (coro->hv);
		2112	}
		2113
		2114	static void
2019	coro_call_on_destroy (pTHX_ struct coro *coro)	2115	coro_call_on_destroy (pTHX_ struct coro *coro)
2020	{	2116	{
2021	SV **on_destroyp = hv_fetch (coro->hv, "_on_destroy", sizeof ("_on_destroy") - 1, 0);	2117	AV *od = coro->on_destroy;
2022		2118
2023	if (on_destroyp)	2119	if (!od)
2024	{	2120	return;
2025	SV **statusp = hv_fetch (coro->hv, "_status", sizeof ("_status") - 1, 0);
2026	AV *on_destroy = sv_2mortal (SvREFCNT_inc ((AV *)SvRV (*on_destroyp)));
2027	AV *status = statusp ? sv_2mortal (SvREFCNT_inc ((AV *)SvRV (*statusp))) : 0;
2028		2121
2029	while (AvFILLp (on_destroy) >= 0)	2122	while (AvFILLp (od) >= 0)
		2123	{
		2124	SV *cb = sv_2mortal (av_pop (od));
		2125
		2126	/* coro hv's (and only hv's at the moment) are supported as well */
		2127	if (SvSTATEhv_p (aTHX_ cb))
		2128	api_ready (aTHX_ cb);
		2129	else
2030	{	2130	{
2031	dSP; /* don't disturb outer sp */	2131	dSP; /* don't disturb outer sp */
2032	SV *cb = av_pop (on_destroy);
2033
2034	PUSHMARK (SP);	2132	PUSHMARK (SP);
2035		2133
2036	if (statusp)	2134	if (coro->status)
2037	{	2135	{
2038	int i;	2136	PUTBACK;
2039	EXTEND (SP, AvFILLp (status) + 1);	2137	coro_push_av (aTHX_ coro->status, G_ARRAY);
2040		2138	SPAGAIN;
2041	for (i = 0; i <= AvFILLp (status); ++i)
2042	PUSHs (AvARRAY (status)[i]);
2043	}	2139	}
2044		2140
2045	PUTBACK;	2141	PUTBACK;
2046	call_sv (sv_2mortal (cb), G_VOID | G_DISCARD);	2142	call_sv (cb, G_VOID | G_DISCARD);
2047	}	2143	}
2048	}	2144	}
2049	}	2145	}
2050		2146
2051	static void	2147	static void
2052	coro_set_status (HV *coro_hv, SV **arg, int items)	2148	coro_set_status (pTHX_ struct coro *coro, SV **arg, int items)
2053	{	2149	{
2054	AV *av = newAV ();	2150	AV *av;
		2151
		2152	if (coro->status)
		2153	{
		2154	av = coro->status;
		2155	av_clear (av);
		2156	}
		2157	else
		2158	av = coro->status = newAV ();
2055		2159
2056	/* items are actually not so common, so optimise for this case */	2160	/* items are actually not so common, so optimise for this case */
2057	if (items)	2161	if (items)
2058	{	2162	{
2059	int i;	2163	int i;
…		…
2061	av_extend (av, items - 1);	2165	av_extend (av, items - 1);
2062		2166
2063	for (i = 0; i < items; ++i)	2167	for (i = 0; i < items; ++i)
2064	av_push (av, SvREFCNT_inc_NN (arg [i]));	2168	av_push (av, SvREFCNT_inc_NN (arg [i]));
2065	}	2169	}
2066
2067	hv_store (coro_hv, "_status", sizeof ("_status") - 1, newRV_noinc ((SV *)av), 0);
2068	}	2170	}
2069		2171
2070	static void	2172	static void
2071	slf_init_terminate_cancel_common (pTHX_ struct CoroSLF *frame, HV *coro_hv)	2173	slf_init_terminate_cancel_common (pTHX_ struct CoroSLF *frame, HV *coro_hv)
2072	{	2174	{
…		…
2084	static void	2186	static void
2085	slf_init_terminate (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)	2187	slf_init_terminate (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2086	{	2188	{
2087	HV *coro_hv = (HV *)SvRV (coro_current);	2189	HV *coro_hv = (HV *)SvRV (coro_current);
2088		2190
2089	coro_set_status (coro_hv, arg, items);	2191	coro_set_status (aTHX_ SvSTATE ((SV *)coro_hv), arg, items);
2090	slf_init_terminate_cancel_common (frame, coro_hv);	2192	slf_init_terminate_cancel_common (aTHX_ frame, coro_hv);
2091	}	2193	}
2092		2194
2093	static void	2195	static void
2094	slf_init_cancel (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)	2196	slf_init_cancel (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2095	{	2197	{
…		…
2100	croak ("Coro::cancel called without coro object,");	2202	croak ("Coro::cancel called without coro object,");
2101		2203
2102	coro = SvSTATE (arg [0]);	2204	coro = SvSTATE (arg [0]);
2103	coro_hv = coro->hv;	2205	coro_hv = coro->hv;
2104		2206
2105	coro_set_status (coro_hv, arg + 1, items - 1);	2207	coro_set_status (aTHX_ coro, arg + 1, items - 1);
2106		2208
2107	if (expect_false (coro->flags & CF_NOCANCEL))	2209	if (ecb_expect_false (coro->flags & CF_NOCANCEL))
2108	{	2210	{
2109	/* coro currently busy cancelling something, so just notify it */	2211	/* coro currently busy cancelling something, so just notify it */
2110	coro->slf_frame.data = (void *)coro;	2212	coro->slf_frame.data = (void *)coro;
2111		2213
2112	frame->prepare = prepare_nop;	2214	frame->prepare = prepare_nop;
2113	frame->check = slf_check_nop;	2215	frame->check = slf_check_nop;
2114	}	2216	}
2115	else if (coro_hv == (HV *)SvRV (coro_current))	2217	else if (coro_hv == (HV *)SvRV (coro_current))
2116	{	2218	{
2117	/* cancelling the current coro is allowed, and equals terminate */	2219	/* cancelling the current coro is allowed, and equals terminate */
2118	slf_init_terminate_cancel_common (frame, coro_hv);	2220	slf_init_terminate_cancel_common (aTHX_ frame, coro_hv);
2119	}	2221	}
2120	else	2222	else
2121	{	2223	{
2122	struct coro *self = SvSTATE_current;	2224	struct coro *self = SvSTATE_current;
2123		2225
…		…
2127	* this is ugly, and hopefully fully worth the extra speed.	2229	* this is ugly, and hopefully fully worth the extra speed.
2128	* besides, I can't get the slow-but-safe version working...	2230	* besides, I can't get the slow-but-safe version working...
2129	*/	2231	*/
2130	slf_frame.data = 0;	2232	slf_frame.data = 0;
2131	self->flags |= CF_NOCANCEL;	2233	self->flags |= CF_NOCANCEL;
2132
2133	coro_state_destroy (aTHX_ coro);	2234	coro_state_destroy (aTHX_ coro);
2134	coro_call_on_destroy (aTHX_ coro);
2135
2136	self->flags &= ~CF_NOCANCEL;	2235	self->flags &= ~CF_NOCANCEL;
2137		2236
2138	if (slf_frame.data)	2237	if (slf_frame.data)
2139	{	2238	{
2140	/* while we were busy we have been cancelled, so terminate */	2239	/* while we were busy we have been cancelled, so terminate */
2141	slf_init_terminate_cancel_common (frame, self->hv);	2240	slf_init_terminate_cancel_common (aTHX_ frame, self->hv);
2142	}	2241	}
2143	else	2242	else
2144	{	2243	{
2145	frame->prepare = prepare_nop;	2244	frame->prepare = prepare_nop;
2146	frame->check = slf_check_nop;	2245	frame->check = slf_check_nop;
2147	}	2246	}
2148	}	2247	}
2149	}	2248	}
2150		2249
		2250	static int
		2251	slf_check_safe_cancel (pTHX_ struct CoroSLF *frame)
		2252	{
		2253	frame->prepare = 0;
		2254	coro_unwind_stacks (aTHX);
		2255
		2256	slf_init_terminate_cancel_common (aTHX_ frame, (HV *)SvRV (coro_current));
		2257
		2258	return 1;
		2259	}
		2260
		2261	static int
		2262	safe_cancel (pTHX_ struct coro *coro, SV **arg, int items)
		2263	{
		2264	if (coro->cctx)
		2265	croak ("coro inside C callback, unable to cancel at this time, caught");
		2266
		2267	if (coro->flags & CF_NEW)
		2268	{
		2269	coro_set_status (aTHX_ coro, arg, items);
		2270	coro_state_destroy (aTHX_ coro);
		2271	}
		2272	else
		2273	{
		2274	if (!coro->slf_frame.prepare)
		2275	croak ("coro outside an SLF function, unable to cancel at this time, caught");
		2276
		2277	slf_destroy (aTHX_ coro);
		2278
		2279	coro_set_status (aTHX_ coro, arg, items);
		2280	coro->slf_frame.prepare = prepare_nop;
		2281	coro->slf_frame.check = slf_check_safe_cancel;
		2282
		2283	api_ready (aTHX_ (SV *)coro->hv);
		2284	}
		2285
		2286	return 1;
		2287	}
		2288
2151	/*****************************************************************************/	2289	/*****************************************************************************/
2152	/* async pool handler */	2290	/* async pool handler */
2153		2291
2154	static int	2292	static int
2155	slf_check_pool_handler (pTHX_ struct CoroSLF *frame)	2293	slf_check_pool_handler (pTHX_ struct CoroSLF *frame)
…		…
2184	slf_init_pool_handler (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)	2322	slf_init_pool_handler (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2185	{	2323	{
2186	HV *hv = (HV *)SvRV (coro_current);	2324	HV *hv = (HV *)SvRV (coro_current);
2187	struct coro *coro = SvSTATE_hv ((SV *)hv);	2325	struct coro *coro = SvSTATE_hv ((SV *)hv);
2188		2326
2189	if (expect_true (coro->saved_deffh))	2327	if (ecb_expect_true (coro->saved_deffh))
2190	{	2328	{
2191	/* subsequent iteration */	2329	/* subsequent iteration */
2192	SvREFCNT_dec ((SV *)PL_defoutgv); PL_defoutgv = (GV *)coro->saved_deffh;	2330	SvREFCNT_dec ((SV *)PL_defoutgv); PL_defoutgv = (GV *)coro->saved_deffh;
2193	coro->saved_deffh = 0;	2331	coro->saved_deffh = 0;
2194		2332
2195	if (coro_rss (aTHX_ coro) > SvUV (sv_pool_rss)	2333	if (coro_rss (aTHX_ coro) > SvUV (sv_pool_rss)
2196	|| av_len (av_async_pool) + 1 >= SvIV (sv_pool_size))	2334	|| av_len (av_async_pool) + 1 >= SvIV (sv_pool_size))
2197	{	2335	{
2198	coro->invoke_cb = SvREFCNT_inc_NN ((SV *)cv_coro_terminate);	2336	slf_init_terminate_cancel_common (aTHX_ frame, hv);
2199	coro->invoke_av = newAV ();	2337	return;
2200
2201	frame->prepare = prepare_nop;
2202	}	2338	}
2203	else	2339	else
2204	{	2340	{
2205	av_clear (GvAV (PL_defgv));	2341	av_clear (GvAV (PL_defgv));
2206	hv_store (hv, "desc", sizeof ("desc") - 1, SvREFCNT_inc_NN (sv_async_pool_idle), 0);	2342	hv_store (hv, "desc", sizeof ("desc") - 1, SvREFCNT_inc_NN (sv_async_pool_idle), 0);
…		…
2429	static void	2565	static void
2430	slf_init_cede_notself (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)	2566	slf_init_cede_notself (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
2431	{	2567	{
2432	frame->prepare = prepare_cede_notself;	2568	frame->prepare = prepare_cede_notself;
2433	frame->check = slf_check_nop;	2569	frame->check = slf_check_nop;
		2570	}
		2571
		2572	/* "undo"/cancel a running slf call - used when cancelling a coro, mainly */
		2573	static void
		2574	slf_destroy (pTHX_ struct coro *coro)
		2575	{
		2576	/* this callback is reserved for slf functions needing to do cleanup */
		2577	if (coro->slf_frame.destroy && coro->slf_frame.prepare && !PL_dirty)
		2578	coro->slf_frame.destroy (aTHX_ &coro->slf_frame);
		2579
		2580	/*
		2581	* The on_destroy above most likely is from an SLF call.
		2582	* Since by definition the SLF call will not finish when we destroy
		2583	* the coro, we will have to force-finish it here, otherwise
		2584	* cleanup functions cannot call SLF functions.
		2585	*/
		2586	coro->slf_frame.prepare = 0;
2434	}	2587	}
2435		2588
2436	/*	2589	/*
2437	* these not obviously related functions are all rolled into one	2590	* these not obviously related functions are all rolled into one
2438	* function to increase chances that they all will call transfer with the same	2591	* function to increase chances that they all will call transfer with the same
…		…
2445	I32 checkmark; /* mark SP to see how many elements check has pushed */	2598	I32 checkmark; /* mark SP to see how many elements check has pushed */
2446		2599
2447	/* set up the slf frame, unless it has already been set-up */	2600	/* set up the slf frame, unless it has already been set-up */
2448	/* the latter happens when a new coro has been started */	2601	/* the latter happens when a new coro has been started */
2449	/* or when a new cctx was attached to an existing coroutine */	2602	/* or when a new cctx was attached to an existing coroutine */
2450	if (expect_true (!slf_frame.prepare))	2603	if (ecb_expect_true (!slf_frame.prepare))
2451	{	2604	{
2452	/* first iteration */	2605	/* first iteration */
2453	dSP;	2606	dSP;
2454	SV **arg = PL_stack_base + TOPMARK + 1;	2607	SV **arg = PL_stack_base + TOPMARK + 1;
2455	int items = SP - arg; /* args without function object */	2608	int items = SP - arg; /* args without function object */
…		…
2496	while (slf_frame.check (aTHX_ &slf_frame));	2649	while (slf_frame.check (aTHX_ &slf_frame));
2497		2650
2498	slf_frame.prepare = 0; /* invalidate the frame, we are done processing it */	2651	slf_frame.prepare = 0; /* invalidate the frame, we are done processing it */
2499		2652
2500	/* exception handling */	2653	/* exception handling */
2501	if (expect_false (CORO_THROW))	2654	if (ecb_expect_false (CORO_THROW))
2502	{	2655	{
2503	SV *exception = sv_2mortal (CORO_THROW);	2656	SV *exception = sv_2mortal (CORO_THROW);
2504		2657
2505	CORO_THROW = 0;	2658	CORO_THROW = 0;
2506	sv_setsv (ERRSV, exception);	2659	sv_setsv (ERRSV, exception);
2507	croak (0);	2660	croak (0);
2508	}	2661	}
2509		2662
2510	/* return value handling - mostly like entersub */	2663	/* return value handling - mostly like entersub */
2511	/* make sure we put something on the stack in scalar context */	2664	/* make sure we put something on the stack in scalar context */
2512	if (GIMME_V == G_SCALAR)	2665	if (GIMME_V == G_SCALAR
		2666	&& ecb_expect_false (PL_stack_sp != PL_stack_base + checkmark + 1))
2513	{	2667	{
2514	dSP;	2668	dSP;
2515	SV **bot = PL_stack_base + checkmark;	2669	SV **bot = PL_stack_base + checkmark;
2516		2670
2517	if (sp == bot) /* too few, push undef */	2671	if (sp == bot) /* too few, push undef */
2518	bot [1] = &PL_sv_undef;	2672	bot [1] = &PL_sv_undef;
2519	else if (sp != bot + 1) /* too many, take last one */	2673	else /* too many, take last one */
2520	bot [1] = *sp;	2674	bot [1] = *sp;
2521		2675
2522	SP = bot + 1;	2676	SP = bot + 1;
2523		2677
2524	PUTBACK;	2678	PUTBACK;
…		…
2631	{	2785	{
2632	PerlIOBuf base;	2786	PerlIOBuf base;
2633	NV next, every;	2787	NV next, every;
2634	} PerlIOCede;	2788	} PerlIOCede;
2635		2789
2636	static IV	2790	static IV ecb_cold
2637	PerlIOCede_pushed (pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)	2791	PerlIOCede_pushed (pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
2638	{	2792	{
2639	PerlIOCede *self = PerlIOSelf (f, PerlIOCede);	2793	PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
2640		2794
2641	self->every = SvCUR (arg) ? SvNV (arg) : 0.01;	2795	self->every = SvCUR (arg) ? SvNV (arg) : 0.01;
2642	self->next = nvtime () + self->every;	2796	self->next = nvtime () + self->every;
2643		2797
2644	return PerlIOBuf_pushed (aTHX_ f, mode, Nullsv, tab);	2798	return PerlIOBuf_pushed (aTHX_ f, mode, Nullsv, tab);
2645	}	2799	}
2646		2800
2647	static SV *	2801	static SV * ecb_cold
2648	PerlIOCede_getarg (pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)	2802	PerlIOCede_getarg (pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)
2649	{	2803	{
2650	PerlIOCede *self = PerlIOSelf (f, PerlIOCede);	2804	PerlIOCede *self = PerlIOSelf (f, PerlIOCede);
2651		2805
2652	return newSVnv (self->every);	2806	return newSVnv (self->every);
…		…
2764	SvREFCNT_dec (cb);	2918	SvREFCNT_dec (cb);
2765	}	2919	}
2766	}	2920	}
2767		2921
2768	static void	2922	static void
2769	coro_semaphore_on_destroy (pTHX_ struct coro *coro)	2923	coro_semaphore_destroy (pTHX_ struct CoroSLF *frame)
2770	{	2924	{
2771	/* call $sem->adjust (0) to possibly wake up some other waiters */	2925	/* call $sem->adjust (0) to possibly wake up some other waiters */
2772	coro_semaphore_adjust (aTHX_ (AV *)coro->slf_frame.data, 0);	2926	coro_semaphore_adjust (aTHX_ (AV *)frame->data, 0);
2773	}	2927	}
2774		2928
2775	static int	2929	static int
2776	slf_check_semaphore_down_or_wait (pTHX_ struct CoroSLF *frame, int acquire)	2930	slf_check_semaphore_down_or_wait (pTHX_ struct CoroSLF *frame, int acquire)
2777	{	2931	{
2778	AV *av = (AV *)frame->data;	2932	AV *av = (AV *)frame->data;
2779	SV *count_sv = AvARRAY (av)[0];	2933	SV *count_sv = AvARRAY (av)[0];
		2934	SV *coro_hv = SvRV (coro_current);
2780		2935
2781	/* if we are about to throw, don't actually acquire the lock, just throw */	2936	/* if we are about to throw, don't actually acquire the lock, just throw */
2782	if (CORO_THROW)	2937	if (CORO_THROW)
2783	return 0;	2938	return 0;
2784	else if (SvIVX (count_sv) > 0)	2939	else if (SvIVX (count_sv) > 0)
2785	{	2940	{
2786	SvSTATE_current->on_destroy = 0;	2941	frame->destroy = 0;
2787		2942
2788	if (acquire)	2943	if (acquire)
2789	SvIVX (count_sv) = SvIVX (count_sv) - 1;	2944	SvIVX (count_sv) = SvIVX (count_sv) - 1;
2790	else	2945	else
2791	coro_semaphore_adjust (aTHX_ av, 0);	2946	coro_semaphore_adjust (aTHX_ av, 0);
…		…
2796	{	2951	{
2797	int i;	2952	int i;
2798	/* if we were woken up but can't down, we look through the whole */	2953	/* if we were woken up but can't down, we look through the whole */
2799	/* waiters list and only add us if we aren't in there already */	2954	/* waiters list and only add us if we aren't in there already */
2800	/* this avoids some degenerate memory usage cases */	2955	/* this avoids some degenerate memory usage cases */
2801		2956	for (i = AvFILLp (av); i > 0; --i) // i > 0 is not an off-by-one bug
2802	for (i = 1; i <= AvFILLp (av); ++i)
2803	if (AvARRAY (av)[i] == SvRV (coro_current))	2957	if (AvARRAY (av)[i] == coro_hv)
2804	return 1;	2958	return 1;
2805		2959
2806	av_push (av, SvREFCNT_inc (SvRV (coro_current)));	2960	av_push (av, SvREFCNT_inc (coro_hv));
2807	return 1;	2961	return 1;
2808	}	2962	}
2809	}	2963	}
2810		2964
2811	static int	2965	static int
…		…
2834	{	2988	{
2835	av_push (av, SvREFCNT_inc (SvRV (coro_current)));	2989	av_push (av, SvREFCNT_inc (SvRV (coro_current)));
2836		2990
2837	frame->data = (void *)sv_2mortal (SvREFCNT_inc ((SV *)av));	2991	frame->data = (void *)sv_2mortal (SvREFCNT_inc ((SV *)av));
2838	frame->prepare = prepare_schedule;	2992	frame->prepare = prepare_schedule;
2839
2840	/* to avoid race conditions when a woken-up coro gets terminated */	2993	/* to avoid race conditions when a woken-up coro gets terminated */
2841	/* we arrange for a temporary on_destroy that calls adjust (0) */	2994	/* we arrange for a temporary on_destroy that calls adjust (0) */
2842	SvSTATE_current->on_destroy = coro_semaphore_on_destroy;	2995	frame->destroy = coro_semaphore_destroy;
2843	}	2996	}
2844	}	2997	}
2845		2998
2846	static void	2999	static void
2847	slf_init_semaphore_down (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)	3000	slf_init_semaphore_down (pTHX_ struct CoroSLF *frame, CV *cv, SV **arg, int items)
…		…
3065	dSP;	3218	dSP;
3066		3219
3067	static SV *prio_cv;	3220	static SV *prio_cv;
3068	static SV *prio_sv;	3221	static SV *prio_sv;
3069		3222
3070	if (expect_false (!prio_cv))	3223	if (ecb_expect_false (!prio_cv))
3071	{	3224	{
3072	prio_cv = (SV *)get_cv ("IO::AIO::aioreq_pri", 0);	3225	prio_cv = (SV *)get_cv ("IO::AIO::aioreq_pri", 0);
3073	prio_sv = newSViv (0);	3226	prio_sv = newSViv (0);
3074	}	3227	}
3075		3228
…		…
3181	}	3334	}
3182		3335
3183	return coro_sv;	3336	return coro_sv;
3184	}	3337	}
3185		3338
		3339	#ifndef __cplusplus
		3340	ecb_cold XS(boot_Coro__State);
		3341	#endif
		3342
		3343	#if CORO_JIT
		3344
		3345	static void ecb_noinline ecb_cold
		3346	pushav_3uv (pTHX_ UV a, UV b, UV c)
		3347	{
		3348	dSP;
		3349	AV *av = newAV ();
		3350
		3351	av_store (av, 2, newSVuv (c));
		3352	av_store (av, 1, newSVuv (b));
		3353	av_store (av, 0, newSVuv (a));
		3354
		3355	XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
		3356
		3357	PUTBACK;
		3358	}
		3359
		3360	static void ecb_noinline ecb_cold
		3361	jit_init (pTHX)
		3362	{
		3363	dSP;
		3364	SV *load, *save;
		3365	char *map_base;
		3366	char *load_ptr, *save_ptr;
		3367	STRLEN load_len, save_len;
		3368	int count;
		3369
		3370	eval_pv ("require 'Coro/jit-" CORO_JIT_TYPE ".pl'", 1);
		3371
		3372	PUSHMARK (SP);
		3373	#define VARx(name,expr,type) pushav_3uv (aTHX_ (UV)&(expr), offsetof (perl_slots, name), sizeof (type));
		3374	# include "state.h"
		3375	#undef VARx
		3376	count = call_pv ("Coro::State::_jit", G_ARRAY);
		3377	SPAGAIN;
		3378
		3379	save = POPs; save_ptr = SvPVbyte (save, save_len);
		3380	load = POPs; load_ptr = SvPVbyte (load, load_len);
		3381
		3382	map_base = mmap (0, load_len + save_len + 16, PROT_EXEC | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
		3383
		3384	assert (("Coro: unable to mmap jit code page, cannot continue.", map_base != (char *)MAP_FAILED));
		3385
		3386	load_perl_slots = (load_save_perl_slots_type)map_base;
		3387	memcpy (map_base, load_ptr, load_len);
		3388
		3389	map_base += (load_len + 15) & ~15;
		3390
		3391	save_perl_slots = (load_save_perl_slots_type)map_base;
		3392	memcpy (map_base, save_ptr, save_len);
		3393
		3394	PUTBACK;
		3395	eval_pv ("undef &Coro::State::_jit", 1);
		3396	}
		3397
		3398	#endif
		3399
3186	MODULE = Coro::State PACKAGE = Coro::State PREFIX = api_	3400	MODULE = Coro::State PACKAGE = Coro::State PREFIX = api_
3187		3401
3188	PROTOTYPES: DISABLE	3402	PROTOTYPES: DISABLE
3189		3403
3190	BOOT:	3404	BOOT:
…		…
3194	coro_thx = PERL_GET_CONTEXT;	3408	coro_thx = PERL_GET_CONTEXT;
3195	# endif	3409	# endif
3196	#endif	3410	#endif
3197	BOOT_PAGESIZE;	3411	BOOT_PAGESIZE;
3198		3412
		3413	/* perl defines these to check for existance first, but why it doesn't */
		3414	/* just create them one at init time is not clear to me, except for */
		3415	/* programs trying to delete them, but... */
		3416	/* anyway, we declare this as invalid and make sure they are initialised here */
		3417	DEFSV;
		3418	ERRSV;
		3419
3199	cctx_current = cctx_new_empty ();	3420	cctx_current = cctx_new_empty ();
3200		3421
3201	irsgv = gv_fetchpv ("/" , GV_ADD|GV_NOTQUAL, SVt_PV);	3422	irsgv = gv_fetchpv ("/" , GV_ADD|GV_NOTQUAL, SVt_PV);
3202	stdoutgv = gv_fetchpv ("STDOUT", GV_ADD|GV_NOTQUAL, SVt_PVIO);	3423	stdoutgv = gv_fetchpv ("STDOUT", GV_ADD|GV_NOTQUAL, SVt_PVIO);
3203		3424
…		…
3245	coroapi.prepare_cede_notself = prepare_cede_notself;	3466	coroapi.prepare_cede_notself = prepare_cede_notself;
3246		3467
3247	time_init (aTHX);	3468	time_init (aTHX);
3248		3469
3249	assert (("PRIO_NORMAL must be 0", !CORO_PRIO_NORMAL));	3470	assert (("PRIO_NORMAL must be 0", !CORO_PRIO_NORMAL));
		3471	#if CORO_JIT
		3472	PUTBACK;
		3473	jit_init (aTHX);
		3474	SPAGAIN;
		3475	#endif
3250	}	3476	}
3251		3477
3252	SV *	3478	SV *
3253	new (SV *klass, ...)	3479	new (SV *klass, ...)
3254	ALIAS:	3480	ALIAS:
…		…
3396	PROTOTYPE: $	3622	PROTOTYPE: $
3397	ALIAS:	3623	ALIAS:
3398	is_ready = CF_READY	3624	is_ready = CF_READY
3399	is_running = CF_RUNNING	3625	is_running = CF_RUNNING
3400	is_new = CF_NEW	3626	is_new = CF_NEW
3401	is_destroyed = CF_DESTROYED	3627	is_destroyed = CF_ZOMBIE
		3628	is_zombie = CF_ZOMBIE
3402	is_suspended = CF_SUSPENDED	3629	is_suspended = CF_SUSPENDED
3403	CODE:	3630	CODE:
3404	RETVAL = boolSV (coro->flags & ix);	3631	RETVAL = boolSV (coro->flags & ix);
3405	OUTPUT:	3632	OUTPUT:
3406	RETVAL	3633	RETVAL
…		…
3501	times (Coro::State self)	3728	times (Coro::State self)
3502	PPCODE:	3729	PPCODE:
3503	{	3730	{
3504	struct coro *current = SvSTATE (coro_current);	3731	struct coro *current = SvSTATE (coro_current);
3505		3732
3506	if (expect_false (current == self))	3733	if (ecb_expect_false (current == self))
3507	{	3734	{
3508	coro_times_update ();	3735	coro_times_update ();
3509	coro_times_add (SvSTATE (coro_current));	3736	coro_times_add (SvSTATE (coro_current));
3510	}	3737	}
3511		3738
3512	EXTEND (SP, 2);	3739	EXTEND (SP, 2);
3513	PUSHs (sv_2mortal (newSVnv (self->t_real [0] + self->t_real [1] * 1e-9)));	3740	PUSHs (sv_2mortal (newSVnv (self->t_real [0] + self->t_real [1] * 1e-9)));
3514	PUSHs (sv_2mortal (newSVnv (self->t_cpu [0] + self->t_cpu [1] * 1e-9)));	3741	PUSHs (sv_2mortal (newSVnv (self->t_cpu [0] + self->t_cpu [1] * 1e-9)));
3515		3742
3516	if (expect_false (current == self))	3743	if (ecb_expect_false (current == self))
3517	coro_times_sub (SvSTATE (coro_current));	3744	coro_times_sub (SvSTATE (coro_current));
3518	}	3745	}
3519		3746
3520	void	3747	void
3521	swap_sv (Coro::State coro, SV *sv, SV *swapsv)	3748	swap_sv (Coro::State coro, SV *sv, SV *swapsv)
…		…
3542	BOOT:	3769	BOOT:
3543	{	3770	{
3544	sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE);	3771	sv_pool_rss = coro_get_sv (aTHX_ "Coro::POOL_RSS" , TRUE);
3545	sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE);	3772	sv_pool_size = coro_get_sv (aTHX_ "Coro::POOL_SIZE" , TRUE);
3546	cv_coro_run = get_cv ( "Coro::_coro_run" , GV_ADD);	3773	cv_coro_run = get_cv ( "Coro::_coro_run" , GV_ADD);
3547	cv_coro_terminate = get_cv ( "Coro::terminate" , GV_ADD);
3548	coro_current = coro_get_sv (aTHX_ "Coro::current" , FALSE); SvREADONLY_on (coro_current);	3774	coro_current = coro_get_sv (aTHX_ "Coro::current" , FALSE); SvREADONLY_on (coro_current);
3549	av_async_pool = coro_get_av (aTHX_ "Coro::async_pool", TRUE);	3775	av_async_pool = coro_get_av (aTHX_ "Coro::async_pool", TRUE);
3550	av_destroy = coro_get_av (aTHX_ "Coro::destroy" , TRUE);	3776	av_destroy = coro_get_av (aTHX_ "Coro::destroy" , TRUE);
3551	sv_manager = coro_get_sv (aTHX_ "Coro::manager" , TRUE);	3777	sv_manager = coro_get_sv (aTHX_ "Coro::manager" , TRUE);
3552	sv_idle = coro_get_sv (aTHX_ "Coro::idle" , TRUE);	3778	sv_idle = coro_get_sv (aTHX_ "Coro::idle" , TRUE);
…		…
3595	void	3821	void
3596	_destroy (Coro::State coro)	3822	_destroy (Coro::State coro)
3597	CODE:	3823	CODE:
3598	/* used by the manager thread */	3824	/* used by the manager thread */
3599	coro_state_destroy (aTHX_ coro);	3825	coro_state_destroy (aTHX_ coro);
		3826
		3827	void
		3828	on_destroy (Coro::State coro, SV *cb)
		3829	CODE:
3600	coro_call_on_destroy (aTHX_ coro);	3830	coro_push_on_destroy (aTHX_ coro, newSVsv (cb));
		3831
		3832	void
		3833	join (...)
		3834	CODE:
		3835	CORO_EXECUTE_SLF_XS (slf_init_join);
3601		3836
3602	void	3837	void
3603	terminate (...)	3838	terminate (...)
3604	CODE:	3839	CODE:
3605	CORO_EXECUTE_SLF_XS (slf_init_terminate);	3840	CORO_EXECUTE_SLF_XS (slf_init_terminate);
3606		3841
3607	void	3842	void
3608	cancel (...)	3843	cancel (...)
3609	CODE:	3844	CODE:
3610	CORO_EXECUTE_SLF_XS (slf_init_cancel);	3845	CORO_EXECUTE_SLF_XS (slf_init_cancel);
		3846
		3847	int
		3848	safe_cancel (Coro::State self, ...)
		3849	C_ARGS: aTHX_ self, &ST (1), items - 1
3611		3850
3612	void	3851	void
3613	schedule (...)	3852	schedule (...)
3614	CODE:	3853	CODE:
3615	CORO_EXECUTE_SLF_XS (slf_init_schedule);	3854	CORO_EXECUTE_SLF_XS (slf_init_schedule);

Diff Legend

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