ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/Coro/Coro/State.xs

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

Diff Legend

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