[ViewVC] Diff of: cvs/Coro/Coro/State.xs

Comparing Coro/Coro/State.xs (file contents):
Revision 1.30 by root, Sat Aug 25 22:19:05 2001 UTC vs.
Revision 1.42 by root, Mon Dec 31 20:41:45 2001 UTC

…		…
7	#include <signal.h>	7	#include <signal.h>
8		8
9	#ifdef HAVE_MMAP	9	#ifdef HAVE_MMAP
10	# include <unistd.h>	10	# include <unistd.h>
11	# include <sys/mman.h>	11	# include <sys/mman.h>
12	# ifndef MAP_ANON
13	# ifdef MAP_ANONYMOUS	12	# ifndef MAP_ANONYMOUS
14	# define MAP_ANON MAP_ANONYMOUS	13	# ifdef MAP_ANON
		14	# define MAP_ANONYMOUS MAP_ANON
15	# else	15	# else
16	# undef HAVE_MMAP	16	# undef HAVE_MMAP
17	# endif	17	# endif
18	# endif	18	# endif
19	#endif	19	#endif
…		…
25		25
26	/* The next macro should declare a variable stacklevel that contains and approximation	26	/* The next macro should declare a variable stacklevel that contains and approximation
27	* to the current C stack pointer. Its property is that it changes with each call	27	* to the current C stack pointer. Its property is that it changes with each call
28	* and should be unique. */	28	* and should be unique. */
29	#define dSTACKLEVEL void *stacklevel = &stacklevel	29	#define dSTACKLEVEL void *stacklevel = &stacklevel
		30
		31	#define IN_DESTRUCT (PL_main_cv == Nullcv)
30		32
31	#define labs(l) ((l) >= 0 ? (l) : -(l))	33	#define labs(l) ((l) >= 0 ? (l) : -(l))
32		34
33	#include "CoroAPI.h"	35	#include "CoroAPI.h"
34		36
…		…
99	static AV main_mainstack; / used to differentiate between $main and others */	101	static AV main_mainstack; / used to differentiate between $main and others */
100	static HV *coro_state_stash;	102	static HV *coro_state_stash;
101	static SV *ucoro_state_sv;	103	static SV *ucoro_state_sv;
102	static U32 ucoro_state_hash;	104	static U32 ucoro_state_hash;
103	static HV *padlist_cache;	105	static HV *padlist_cache;
		106	static SV coro_mortal; / will be freed after next transfer */
104		107
105	/* mostly copied from op.c:cv_clone2 */	108	/* mostly copied from op.c:cv_clone2 */
106	STATIC AV *	109	STATIC AV *
107	clone_padlist (AV *protopadlist)	110	clone_padlist (AV *protopadlist)
108	{	111	{
…		…
487	* still there is a memleak of 128 bytes...	490	* still there is a memleak of 128 bytes...
488	*/	491	*/
489	STATIC void	492	STATIC void
490	destroy_stacks(pTHX)	493	destroy_stacks(pTHX)
491	{	494	{
		495	if (!IN_DESTRUCT)
		496	{
492	/* is this ugly, I ask? */	497	/* is this ugly, I ask? */
493	while (PL_scopestack_ix)	498	while (PL_scopestack_ix)
494	LEAVE;	499	LEAVE;
495		500
496	/* sure it is, but more important: is it correct?? :/ */	501	/* sure it is, but more important: is it correct?? :/ */
497	while (PL_tmps_ix > PL_tmps_floor) /* should only ever be one iteration */	502	while (PL_tmps_ix > PL_tmps_floor) /* should only ever be one iteration */
498	FREETMPS;	503	FREETMPS;
		504	}
499		505
500	while (PL_curstackinfo->si_next)	506	while (PL_curstackinfo->si_next)
501	PL_curstackinfo = PL_curstackinfo->si_next;	507	PL_curstackinfo = PL_curstackinfo->si_next;
502		508
503	while (PL_curstackinfo)	509	while (PL_curstackinfo)
…		…
508	dSP;	514	dSP;
509	SWITCHSTACK (PL_curstack, PL_curstackinfo->si_stack);	515	SWITCHSTACK (PL_curstack, PL_curstackinfo->si_stack);
510	PUTBACK; /* possibly superfluous */	516	PUTBACK; /* possibly superfluous */
511	}	517	}
512		518
513	if (PL_main_cv != Nullcv) /* don't during destruction. hack? */	519	if (!IN_DESTRUCT)
		520	{
514	dounwind(-1);	521	dounwind(-1);
515
516	SvREFCNT_dec(PL_curstackinfo->si_stack);	522	SvREFCNT_dec(PL_curstackinfo->si_stack);
		523	}
		524
517	Safefree(PL_curstackinfo->si_cxstack);	525	Safefree(PL_curstackinfo->si_cxstack);
518	Safefree(PL_curstackinfo);	526	Safefree(PL_curstackinfo);
519	PL_curstackinfo = p;	527	PL_curstackinfo = p;
520	}	528	}
521		529
…		…
536	stack->refcnt = 1;	544	stack->refcnt = 1;
537	stack->usecnt = 1;	545	stack->usecnt = 1;
538	stack->gencnt = ctx->gencnt = 0;	546	stack->gencnt = ctx->gencnt = 0;
539	if (alloc)	547	if (alloc)
540	{	548	{
541	#ifdef HAVE_MMAP	549	#if HAVE_MMAP
542	stack->ssize = 128 * 1024 * sizeof (long); /* mmap should do allocate-on-write for us */	550	stack->ssize = 128 * 1024 * sizeof (long); /* mmap should do allocate-on-write for us */
543	stack->sptr = mmap (0, stack->ssize, PROT_EXEC\|PROT_READ\|PROT_WRITE, MAP_PRIVATE\|MAP_ANON, 0, 0);	551	stack->sptr = mmap (0, stack->ssize, PROT_EXEC\|PROT_READ\|PROT_WRITE, MAP_PRIVATE\|MAP_ANONYMOUS, 0, 0);
544	if (stack->sptr == (void *)-1)	552	if (stack->sptr == (void *)-1)
545	#endif	553	#endif
546	{	554	{
547	/FIXME//D//* reasonable stack size! */	555	/FIXME//D//* reasonable stack size! */
548	stack->ssize = -4096 * sizeof (long);	556	stack->ssize = -4096 * sizeof (long);
…		…
629	* that doesn't matter, though, since it is only	637	* that doesn't matter, though, since it is only
630	* pp_nextstate and we never return...	638	* pp_nextstate and we never return...
631	* ah yes, and I don't care anyways ;)	639	* ah yes, and I don't care anyways ;)
632	*/	640	*/
633	PUTBACK;	641	PUTBACK;
634	PL_op = pp_entersub();	642	PL_op = PL_ppaddr[OP_ENTERSUB]();
635	SPAGAIN;	643	SPAGAIN;
636		644
637	ENTER; /* necessary e.g. for dounwind */	645	ENTER; /* necessary e.g. for dounwind */
638	}	646	}
639	}	647	}
…		…
643	{	651	{
644	/*	652	/*
645	* this is a _very_ stripped down perl interpreter ;)	653	* this is a _very_ stripped down perl interpreter ;)
646	*/	654	*/
647	Coro__State ctx = (Coro__State)arg;	655	Coro__State ctx = (Coro__State)arg;
		656	JMPENV coro_start_env;
648		657
649	/FIXME//* must set up top_env here */	658	/* same as JMPENV_BOOTSTRAP */
		659	Zero(&coro_start_env, 1, JMPENV);
		660	coro_start_env.je_ret = -1;
		661	coro_start_env.je_mustcatch = TRUE;
		662	PL_top_env = &coro_start_env;
		663
650	ctx->cursp = 0;	664	ctx->cursp = 0;
651	PL_op = PL_op->op_next;	665	PL_op = PL_op->op_next;
652	CALLRUNOPS(aTHX);	666	CALLRUNOPS(aTHX);
653		667
654	abort ();	668	abort ();
…		…
731	}	745	}
732	}	746	}
733	else	747	else
734	setup_coro (next);	748	setup_coro (next);
735	}	749	}
736	}
737		750
738	/*	751	/*
739	* xnext is now either prev or next, depending on wether	752	* xnext is now either prev or next, depending on wether
740	* we switched the c stack or not. that's why i use a global	753	* we switched the c stack or not. that's why I use a global
741	* variable, that should become thread-specific at one point.	754	* variable, that should become thread-specific at one point.
742	*/	755	*/
743	xnext->cursp = stacklevel;	756	xnext->cursp = stacklevel;
744	}
745
746	static struct coro *
747	sv_to_coro (SV arg, const char funcname, const char *varname)
748	{
749	if (SvROK(arg) && SvTYPE(SvRV(arg)) == SVt_PVHV)
750	{	757	}
		758
		759	if (coro_mortal)
		760	{
		761	SvREFCNT_dec (coro_mortal);
		762	coro_mortal = 0;
		763	}
		764	}
		765
		766	#define SV_CORO(sv,func) \
		767	do { \
		768	if (SvROK (sv)) \
		769	sv = SvRV (sv); \
		770	\
		771	if (SvTYPE(sv) == SVt_PVHV) \
		772	{ \
751	HE he = hv_fetch_ent((HV )SvRV(arg), ucoro_state_sv, 0, ucoro_state_hash);	773	HE he = hv_fetch_ent((HV )sv, ucoro_state_sv, 0, ucoro_state_hash); \
752		774	\
753	if (!he)	775	if (!he) \
754	croak ("%s() -- %s is a hashref but lacks the " UCORO_STATE " key", funcname, varname);	776	croak ("%s() -- %s is a hashref but lacks the " UCORO_STATE " key", func, # sv); \
755		777	\
756	arg = HeVAL(he);	778	(sv) = SvRV (HeVAL(he)); \
757	}	779	} \
758		780	\
759	/* must also be changed inside Coro::Cont::yield */	781	/* must also be changed inside Coro::Cont::yield */ \
760	if (SvROK(arg) && SvSTASH(SvRV(arg)) == coro_state_stash)	782	if (!SvOBJECT(sv) \|\| SvSTASH(sv) != coro_state_stash) \
761	return (struct coro ) SvIV((SV)SvRV(arg));
762
763	croak ("%s() -- %s is not (and contains not) a Coro::State object", funcname, varname);	783	croak ("%s() -- %s is not (and contains not) a Coro::State object", func, # sv); \
764	/NORETURN/	784	\
765	}	785	} while(0)
		786
		787	#define SvSTATE(sv) (struct coro *)SvIV (sv)
766		788
767	static void	789	static void
768	api_transfer(pTHX_ SV prev, SV next, int flags)	790	api_transfer(pTHX_ SV prev, SV next, int flags)
769	{	791	{
770	transfer(aTHX_	792	SV_CORO (prev, "Coro::transfer");
771	sv_to_coro (prev, "Coro::transfer", "prev"),	793	SV_CORO (next, "Coro::transfer");
772	sv_to_coro (next, "Coro::transfer", "next"),	794
773	flags);	795	transfer(aTHX_ SvSTATE(prev), SvSTATE(next), flags);
774	}	796	}
775		797
776	/ Coro ******************************************************************/	798	/ Coro ******************************************************************/
777		799
778	#define PRIO_MAX 3	800	#define PRIO_MAX 3
…		…
788	static int coro_nready;	810	static int coro_nready;
789		811
790	static void	812	static void
791	coro_enq (SV *sv)	813	coro_enq (SV *sv)
792	{	814	{
793	if (SvROK (sv))
794	{
795	SV *hv = SvRV (sv);
796	if (SvTYPE (hv) == SVt_PVHV)	815	if (SvTYPE (sv) == SVt_PVHV)
797	{	816	{
798	SV *xprio = hv_fetch ((HV )hv, "prio", 4, 0);	817	SV *xprio = hv_fetch ((HV )sv, "prio", 4, 0);
799	int prio = xprio ? SvIV (*xprio) : PRIO_NORMAL;	818	int prio = xprio ? SvIV (*xprio) : PRIO_NORMAL;
800		819
801	prio = prio > PRIO_MAX ? PRIO_MAX	820	prio = prio > PRIO_MAX ? PRIO_MAX
802	: prio < PRIO_MIN ? PRIO_MIN	821	: prio < PRIO_MIN ? PRIO_MIN
803	: prio;	822	: prio;
804		823
805	av_push (coro_ready [prio - PRIO_MIN], sv);	824	av_push (coro_ready [prio - PRIO_MIN], sv);
806	coro_nready++;	825	coro_nready++;
807		826
808	return;	827	return;
809	}
810	}	828	}
811		829
812	croak ("Coro::ready tried to enqueue something that is not a coroutine");	830	croak ("Coro::ready tried to enqueue something that is not a coroutine");
813	}	831	}
814		832
…		…
832	}	850	}
833		851
834	static void	852	static void
835	api_ready (SV *coro)	853	api_ready (SV *coro)
836	{	854	{
		855	if (SvROK (coro))
		856	coro = SvRV (coro);
		857
837	coro_enq (SvREFCNT_inc (coro));	858	coro_enq (SvREFCNT_inc (coro));
838	}	859	}
839		860
840	static void	861	static void
841	api_schedule (int cede)	862	api_schedule (void)
842	{	863	{
843	SV prev, next;	864	SV prev, next;
844		865
845	prev = GvSV (coro_current);	866	prev = SvRV (GvSV (coro_current));
846
847	if (cede)
848	coro_enq (SvREFCNT_inc (prev));
849
850	next = coro_deq (PRIO_MIN);	867	next = coro_deq (PRIO_MIN);
851		868
852	if (!next)	869	if (!next)
853	next = SvREFCNT_inc (GvSV (coro_idle));	870	next = SvREFCNT_inc (SvRV (GvSV (coro_idle)));
854		871
855	GvSV (coro_current) = SvREFCNT_inc (next);	872	/* free this only after the transfer */
856	transfer (aTHX_	873	coro_mortal = prev;
857	sv_to_coro (prev, "Coro::schedule", "current coroutine"),	874	SV_CORO (prev, "Coro::schedule");
858	sv_to_coro (next, "Coro::schedule", "next coroutine"),	875
		876	SvRV (GvSV (coro_current)) = next;
		877
		878	SV_CORO (next, "Coro::schedule");
		879
		880	transfer (aTHX_ SvSTATE (prev), SvSTATE (next),
859	TRANSFER_SAVE_ALL \| TRANSFER_LAZY_STACK);	881	TRANSFER_SAVE_ALL \| TRANSFER_LAZY_STACK);
860	SvREFCNT_dec (next);	882	}
861	SvREFCNT_dec (prev);	883
		884	static void
		885	api_cede (void)
		886	{
		887	coro_enq (SvREFCNT_inc (SvRV (GvSV (coro_current))));
		888
		889	api_schedule ();
862	}	890	}
863		891
864	MODULE = Coro::State PACKAGE = Coro::State	892	MODULE = Coro::State PACKAGE = Coro::State
865		893
866	PROTOTYPES: ENABLE	894	PROTOTYPES: ENABLE
…		…
905	OUTPUT:	933	OUTPUT:
906	RETVAL	934	RETVAL
907		935
908	void	936	void
909	transfer(prev, next, flags)	937	transfer(prev, next, flags)
910	Coro::State_or_hashref prev	938	SV *prev
911	Coro::State_or_hashref next	939	SV *next
912	int flags	940	int flags
913	PROTOTYPE: @	941	PROTOTYPE: @
914	CODE:	942	CODE:
915	PUTBACK;	943	PUTBACK;
		944	SV_CORO (next, "Coro::transfer");
		945	SV_CORO (prev, "Coro::transfer");
916	transfer (aTHX_ prev, next, flags);	946	transfer (aTHX_ SvSTATE (prev), SvSTATE (next), flags);
917	SPAGAIN;	947	SPAGAIN;
918		948
919	void	949	void
920	DESTROY(coro)	950	DESTROY(coro)
921	Coro::State coro	951	Coro::State coro
…		…
1016		1046
1017	{	1047	{
1018	SV *sv = perl_get_sv("Coro::API", 1);	1048	SV *sv = perl_get_sv("Coro::API", 1);
1019		1049
1020	coroapi.schedule = api_schedule;	1050	coroapi.schedule = api_schedule;
		1051	coroapi.cede = api_cede;
1021	coroapi.ready = api_ready;	1052	coroapi.ready = api_ready;
1022	coroapi.nready = &coro_nready;	1053	coroapi.nready = &coro_nready;
1023	coroapi.current = coro_current;	1054	coroapi.current = coro_current;
1024		1055
1025	GCoroAPI = &coroapi;	1056	GCoroAPI = &coroapi;
…		…
1029	}	1060	}
1030		1061
1031	void	1062	void
1032	ready(self)	1063	ready(self)
1033	SV * self	1064	SV * self
		1065	PROTOTYPE: $
1034	CODE:	1066	CODE:
1035	api_ready (self);	1067	api_ready (self);
1036		1068
1037	int	1069	int
1038	nready(...)	1070	nready(...)
…		…
1043	RETVAL	1075	RETVAL
1044		1076
1045	void	1077	void
1046	schedule(...)	1078	schedule(...)
1047	PROTOTYPE:	1079	PROTOTYPE:
1048	ALIAS:
1049	cede = 1
1050	CODE:	1080	CODE:
1051	api_schedule (ix);	1081	api_schedule ();
1052		1082
		1083	void
		1084	cede(...)
		1085	PROTOTYPE:
		1086	CODE:
		1087	api_cede ();
		1088

Diff Legend

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

Comparing Coro/Coro/State.xs (file contents): Revision 1.30 by root, Sat Aug 25 22:19:05 2001 UTC vs. Revision 1.42 by root, Mon Dec 31 20:41:45 2001 UTC

Diff Legend

Comparing Coro/Coro/State.xs (file contents):
Revision 1.30 by root, Sat Aug 25 22:19:05 2001 UTC vs.
Revision 1.42 by root, Mon Dec 31 20:41:45 2001 UTC