[p5sagit/p5-mst-13.2.git] / ext / threads / threads.xs

#include "threads.h"

/*
 *	Starts executing the thread. Needs to clean up memory a tad better.
 */

#ifdef WIN32
THREAD_RET_TYPE Perl_thread_run(LPVOID arg) {
#else
void* Perl_thread_run(void * arg) {
#endif
	ithread* thread = (ithread*) arg;
	SV* thread_tid_ptr;
	SV* thread_ptr;
	dTHXa(thread->interp);
	PERL_SET_CONTEXT(thread->interp);

#ifdef WIN32
	thread->thr = GetCurrentThreadId();
#else
	thread->thr = pthread_self();
#endif

	SHAREDSvLOCK(threads);
	SHAREDSvEDIT(threads);
	thread_tid_ptr = Perl_newSVuv(PL_sharedsv_space, PTR2UV(thread->thr));
	thread_ptr = Perl_newSVuv(PL_sharedsv_space, PTR2UV(thread));
	hv_store_ent((HV*)SHAREDSvGET(threads), thread_tid_ptr, thread_ptr,0);
   	SvREFCNT_dec(thread_tid_ptr);
	SHAREDSvRELEASE(threads);
	SHAREDSvUNLOCK(threads);
	PL_perl_destruct_level = 2;

	{

		AV* params;
		I32 len;
		int i;
		dSP;
		params = (AV*) SvRV(thread->params);
		len = av_len(params);
		ENTER;
		SAVETMPS;
		PUSHMARK(SP);
		if(len > -1) {
			for(i = 0; i < len + 1; i++) {
				XPUSHs(av_shift(params));
			}	
		}
		PUTBACK;
	 	call_sv(thread->init_function, G_DISCARD);
		FREETMPS;
		LEAVE;


	}

	MUTEX_LOCK(&thread->mutex);
	PerlIO_flush((PerlIO*)NULL);
 	perl_destruct(thread->interp);	
	perl_free(thread->interp);
	if(thread->detached == 1) {
		MUTEX_UNLOCK(&thread->mutex);
		Perl_thread_destruct(thread);
	} else {
	  	MUTEX_UNLOCK(&thread->mutex);
   	}
#ifdef WIN32
	return (DWORD)0;
#else
	return 0;
#endif

}

/*
 * iThread->create();
 */

SV* Perl_thread_create(char* class, SV* init_function, SV* params) {
	ithread* thread = malloc(sizeof(ithread));
  	SV*      obj_ref;
  	SV*      obj;
	SV*		temp_store;
	PerlInterpreter *current_perl;

	MUTEX_LOCK(&create_mutex);  
	obj_ref = newSViv(0);
	obj = newSVrv(obj_ref, class);
	sv_setiv(obj, (IV)thread);
	SvREADONLY_on(obj);

	current_perl = PERL_GET_CONTEXT;	

	/*
	 * here we put the values of params and function to call onto
	 * namespace, this is so perl will properly clone them when we
	 * call perl_clone.
	 */

	temp_store = Perl_get_sv(current_perl, "threads::paramtempstore",
				 TRUE | GV_ADDMULTI);
	Perl_sv_setsv(current_perl, temp_store,params);
	params = NULL;
	temp_store = NULL;

	temp_store = Perl_get_sv(current_perl, "threads::calltempstore",
				 TRUE | GV_ADDMULTI);
	Perl_sv_setsv(current_perl,temp_store, init_function);
	init_function = NULL;
	temp_store = NULL;

#ifdef WIN32
	thread->interp = perl_clone(current_perl, 4);
#else
	thread->interp = perl_clone(current_perl, 0);
#endif

	thread->init_function = newSVsv(Perl_get_sv(thread->interp,
						    "threads::calltempstore",FALSE));
	thread->params = newSVsv(Perl_get_sv(thread->interp,
					     "threads::paramtempstore",FALSE));

	/*
	 * And here we make sure we clean up the data we put in the
	 * namespace of iThread, both in the new and the calling
	 * inteprreter */

	temp_store = Perl_get_sv(thread->interp, "threads::paramtempstore",FALSE);
	Perl_sv_setsv(thread->interp,temp_store, &PL_sv_undef);

	temp_store = Perl_get_sv(thread->interp,"threads::calltempstore",FALSE);
	Perl_sv_setsv(thread->interp,temp_store, &PL_sv_undef);

	PERL_SET_CONTEXT(current_perl);

	temp_store = Perl_get_sv(current_perl,"threads::paramtempstore",FALSE);
	Perl_sv_setsv(current_perl, temp_store, &PL_sv_undef);

	temp_store = Perl_get_sv(current_perl,"threads::calltempstore",FALSE);
	Perl_sv_setsv(current_perl, temp_store, &PL_sv_undef);

	/* let's init the thread */

	MUTEX_INIT(&thread->mutex);
	thread->tid = tid_counter++;
	thread->detached = 0;
	thread->count = 1;

#ifdef WIN32

	thread->handle = CreateThread(NULL, 0, Perl_thread_run,
			(LPVOID)thread, 0, &thread->thr);

#else
	pthread_create( &thread->thr, (pthread_attr_t*)NULL, Perl_thread_run, thread);
#endif
	MUTEX_UNLOCK(&create_mutex);	

	return obj_ref;
}

/*
 * returns the id of the thread
 */
I32 Perl_thread_tid (SV* obj) {
	ithread* thread;
	if(!SvROK(obj)) {
		obj = Perl_thread_self(SvPV_nolen(obj));
		thread = (ithread*)SvIV(SvRV(obj));	
		SvREFCNT_dec(obj);
	} else {
		thread = (ithread*)SvIV(SvRV(obj));	
	}
	return thread->tid;
}

SV* Perl_thread_self (char* class) {
	dTHX;
	SV*      obj_ref;
	SV*      obj;
	SV*	thread_tid_ptr;
	SV*	thread_ptr;
	HE*	thread_entry;
	
	SHAREDSvLOCK(threads);
	SHAREDSvEDIT(threads);
#ifdef WIN32
	thread_tid_ptr = Perl_newSVuv(PL_sharedsv_space,
				      (UV) GetCurrentThreadId());
#else
	thread_tid_ptr = Perl_newSVuv(PL_sharedsv_space,
				      PTR2UV(pthread_self()));
#endif
	thread_entry = Perl_hv_fetch_ent(PL_sharedsv_space,
					 (HV*) SHAREDSvGET(threads),
					 thread_tid_ptr, 0,0);
	thread_ptr = HeVAL(thread_entry);
	SvREFCNT_dec(thread_tid_ptr);	
	SHAREDSvRELEASE(threads);
	SHAREDSvUNLOCK(threads);

	obj_ref = newSViv(0);
	obj = newSVrv(obj_ref, class);
   	sv_setsv(obj, thread_ptr);
   	SvREADONLY_on(obj);
	return obj_ref;
}

/*
 * joins the thread this code needs to take the returnvalue from the
 * call_sv and send it back */

void Perl_thread_join(SV* obj) {
	ithread* thread = (ithread*)SvIV(SvRV(obj));
#ifdef WIN32
	DWORD waitcode;
	waitcode = WaitForSingleObject(thread->handle, INFINITE);
#else
	void *retval;
	pthread_join(thread->thr,&retval);
#endif
}

/* detaches a thread
 * needs to better clean up memory */

void Perl_thread_detach(SV* obj) {
	ithread* thread = (ithread*)SvIV(SvRV(obj));
	MUTEX_LOCK(&thread->mutex);
	thread->detached = 1;
#if !defined(WIN32)
	pthread_detach(thread->thr);
#endif
	MUTEX_UNLOCK(&thread->mutex);
}

void Perl_thread_DESTROY (SV* obj) {
	ithread* thread = (ithread*)SvIV(SvRV(obj));
	
	MUTEX_LOCK(&thread->mutex);
	thread->count--;
	MUTEX_UNLOCK(&thread->mutex);
	Perl_thread_destruct(thread);
}

void Perl_thread_destruct (ithread* thread) {
	return;
	MUTEX_LOCK(&thread->mutex);
	if(thread->count != 0) {
		MUTEX_UNLOCK(&thread->mutex);
		return;	
	}
	MUTEX_UNLOCK(&thread->mutex);
	/* it is safe noone is holding a ref to this */
	/*printf("proper destruction!\n");*/
}

MODULE = threads		PACKAGE = threads		
BOOT:
	Perl_sharedsv_init(aTHX);
	PL_perl_destruct_level = 2;
	threads = Perl_sharedsv_new(aTHX);
	SHAREDSvEDIT(threads);
	SHAREDSvGET(threads) = (SV *)newHV();
	SHAREDSvRELEASE(threads);
	{
	    
	
	    SV* temp = get_sv("threads::sharedsv_space", TRUE | GV_ADDMULTI);
	    SV* temp2 = newSViv((IV)PL_sharedsv_space );
	    sv_setsv( temp , temp2 );
	}
	{
		ithread* thread = malloc(sizeof(ithread));
		SV* thread_tid_ptr;
		SV* thread_ptr;
		MUTEX_INIT(&thread->mutex);
		thread->tid = 0;
#ifdef WIN32
		thread->thr = GetCurrentThreadId();
#else
		thread->thr = pthread_self();
#endif
		SHAREDSvEDIT(threads);
		thread_tid_ptr = Perl_newSVuv(PL_sharedsv_space, PTR2UV(thread->thr));
		thread_ptr = Perl_newSVuv(PL_sharedsv_space, PTR2UV(thread));
		hv_store_ent((HV*) SHAREDSvGET(threads), thread_tid_ptr, thread_ptr,0);
	   	SvREFCNT_dec(thread_tid_ptr);
		SHAREDSvRELEASE(threads);
	}
	MUTEX_INIT(&create_mutex);

PROTOTYPES: DISABLE

SV *
create (class, function_to_call, ...)
        char *  class
        SV *    function_to_call
		CODE:
			AV* params = newAV();
			if(items > 2) {
				int i;
				for(i = 2; i < items ; i++) {
					av_push(params, ST(i));
				}
			}
			RETVAL = Perl_thread_create(class, function_to_call, newRV_noinc((SV*) params));
			OUTPUT:
			RETVAL

SV *
self (class)
		char* class
	CODE:
		RETVAL = Perl_thread_self(class);
	OUTPUT:
		RETVAL

int
tid (obj)	
		SV *	obj;
	CODE:
		RETVAL = Perl_thread_tid(obj);
	OUTPUT:
	RETVAL

void
join (obj)
        SV *    obj
        PREINIT:
        I32* temp;
        PPCODE:
        temp = PL_markstack_ptr++;
        Perl_thread_join(obj);
        if (PL_markstack_ptr != temp) {
          /* truly void, because dXSARGS not invoked */
          PL_markstack_ptr = temp;
          XSRETURN_EMPTY; /* return empty stack */
        }
        /* must have used dXSARGS; list context implied */
        return; /* assume stack size is correct */

void
detach (obj)
        SV *    obj
        PREINIT:
        I32* temp;
        PPCODE:
        temp = PL_markstack_ptr++;
        Perl_thread_detach(obj);
        if (PL_markstack_ptr != temp) {
          /* truly void, because dXSARGS not invoked */
          PL_markstack_ptr = temp;
          XSRETURN_EMPTY; /* return empty stack */
        }
        /* must have used dXSARGS; list context implied */
        return; /* assume stack size is correct */

void
DESTROY (obj)
        SV *    obj
        PREINIT:
        I32* temp;
        PPCODE:
        temp = PL_markstack_ptr++;
        Perl_thread_DESTROY(obj);
        if (PL_markstack_ptr != temp) {
          /* truly void, because dXSARGS not invoked */
          PL_markstack_ptr = temp;
          XSRETURN_EMPTY; /* return empty stack */
        }
        /* must have used dXSARGS; list context implied */
        return; /* assume stack size is correct */
Commit	Line	Data
47ba8780	1	#include "threads.h"
47ba8780	2
47ba8780	3	/*
b1edfb69	4	* Starts executing the thread. Needs to clean up memory a tad better.
b1edfb69	5	*/
47ba8780	6
47ba8780	7	#ifdef WIN32
e6e315b9	8	THREAD_RET_TYPE Perl_thread_run(LPVOID arg) {
47ba8780	9	#else
e8f2bb9a	10	void* Perl_thread_run(void * arg) {
47ba8780	11	#endif
5b414d21	12	ithread* thread = (ithread*) arg;
47ba8780	13	SV* thread_tid_ptr;
	14	SV* thread_ptr;
	15	dTHXa(thread->interp);
47ba8780	16	PERL_SET_CONTEXT(thread->interp);
	17
	18	#ifdef WIN32
	19	thread->thr = GetCurrentThreadId();
	20	#else
	21	thread->thr = pthread_self();
	22	#endif
	23
4f896ddc	24	SHAREDSvLOCK(threads);
47ba8780	25	SHAREDSvEDIT(threads);
b1edfb69	26	thread_tid_ptr = Perl_newSVuv(PL_sharedsv_space, PTR2UV(thread->thr));
b1edfb69	27	thread_ptr = Perl_newSVuv(PL_sharedsv_space, PTR2UV(thread));
47ba8780	28	hv_store_ent((HV*)SHAREDSvGET(threads), thread_tid_ptr, thread_ptr,0);
	29	SvREFCNT_dec(thread_tid_ptr);
	30	SHAREDSvRELEASE(threads);
4f896ddc	31	SHAREDSvUNLOCK(threads);
47ba8780	32	PL_perl_destruct_level = 2;
4f896ddc	33
47ba8780	34	{
	35
	36	AV* params;
	37	I32 len;
	38	int i;
	39	dSP;
	40	params = (AV*) SvRV(thread->params);
	41	len = av_len(params);
	42	ENTER;
	43	SAVETMPS;
	44	PUSHMARK(SP);
	45	if(len > -1) {
	46	for(i = 0; i < len + 1; i++) {
	47	XPUSHs(av_shift(params));
	48	}
	49	}
	50	PUTBACK;
4f896ddc	51	call_sv(thread->init_function, G_DISCARD);
47ba8780	52	FREETMPS;
	53	LEAVE;
	54
	55
	56	}
	57
47ba8780	58	MUTEX_LOCK(&thread->mutex);
fd58862f	59	PerlIO_flush((PerlIO*)NULL);
47ba8780	60	perl_destruct(thread->interp);
	61	perl_free(thread->interp);
	62	if(thread->detached == 1) {
	63	MUTEX_UNLOCK(&thread->mutex);
e6e315b9	64	Perl_thread_destruct(thread);
47ba8780	65	} else {
	66	MUTEX_UNLOCK(&thread->mutex);
	67	}
	68	#ifdef WIN32
	69	return (DWORD)0;
e8f2bb9a	70	#else
e8f2bb9a	71	return 0;
47ba8780	72	#endif
	73
	74	}
	75
47ba8780	76	/*
b1edfb69	77	* iThread->create();
b1edfb69	78	*/
47ba8780	79
e6e315b9	80	SV* Perl_thread_create(char* class, SV* init_function, SV* params) {
47ba8780	81	ithread* thread = malloc(sizeof(ithread));
	82	SV* obj_ref;
	83	SV* obj;
	84	SV* temp_store;
47ba8780	85	PerlInterpreter *current_perl;
	86
	87	MUTEX_LOCK(&create_mutex);
	88	obj_ref = newSViv(0);
	89	obj = newSVrv(obj_ref, class);
b1edfb69	90	sv_setiv(obj, (IV)thread);
b1edfb69	91	SvREADONLY_on(obj);
47ba8780	92
b1edfb69	93	current_perl = PERL_GET_CONTEXT;
47ba8780	94
47ba8780	95	/*
b1edfb69	96	* here we put the values of params and function to call onto
	97	* namespace, this is so perl will properly clone them when we
	98	* call perl_clone.
	99	*/
4f896ddc	100
b1edfb69	101	temp_store = Perl_get_sv(current_perl, "threads::paramtempstore",
b1edfb69	102	TRUE \| GV_ADDMULTI);
47ba8780	103	Perl_sv_setsv(current_perl, temp_store,params);
	104	params = NULL;
	105	temp_store = NULL;
	106
b1edfb69	107	temp_store = Perl_get_sv(current_perl, "threads::calltempstore",
b1edfb69	108	TRUE \| GV_ADDMULTI);
47ba8780	109	Perl_sv_setsv(current_perl,temp_store, init_function);
4f896ddc	110	init_function = NULL;
4f896ddc	111	temp_store = NULL;
47ba8780	112
47ba8780	113	#ifdef WIN32
b1edfb69	114	thread->interp = perl_clone(current_perl, 4);
47ba8780	115	#else
b1edfb69	116	thread->interp = perl_clone(current_perl, 0);
47ba8780	117	#endif
47ba8780	118
b1edfb69	119	thread->init_function = newSVsv(Perl_get_sv(thread->interp,
	120	"threads::calltempstore",FALSE));
	121	thread->params = newSVsv(Perl_get_sv(thread->interp,
	122	"threads::paramtempstore",FALSE));
47ba8780	123
47ba8780	124	/*
b1edfb69	125	* And here we make sure we clean up the data we put in the
	126	* namespace of iThread, both in the new and the calling
	127	* inteprreter */
47ba8780	128
b1edfb69	129	temp_store = Perl_get_sv(thread->interp, "threads::paramtempstore",FALSE);
47ba8780	130	Perl_sv_setsv(thread->interp,temp_store, &PL_sv_undef);
	131
	132	temp_store = Perl_get_sv(thread->interp,"threads::calltempstore",FALSE);
	133	Perl_sv_setsv(thread->interp,temp_store, &PL_sv_undef);
	134
	135	PERL_SET_CONTEXT(current_perl);
	136
	137	temp_store = Perl_get_sv(current_perl,"threads::paramtempstore",FALSE);
	138	Perl_sv_setsv(current_perl, temp_store, &PL_sv_undef);
	139
	140	temp_store = Perl_get_sv(current_perl,"threads::calltempstore",FALSE);
	141	Perl_sv_setsv(current_perl, temp_store, &PL_sv_undef);
	142
b1edfb69	143	/* let's init the thread */
47ba8780	144
	145	MUTEX_INIT(&thread->mutex);
	146	thread->tid = tid_counter++;
	147	thread->detached = 0;
	148	thread->count = 1;
	149
	150	#ifdef WIN32
	151
e6e315b9	152	thread->handle = CreateThread(NULL, 0, Perl_thread_run,
47ba8780	153	(LPVOID)thread, 0, &thread->thr);
	154
	155	#else
b1edfb69	156	pthread_create( &thread->thr, (pthread_attr_t*)NULL, Perl_thread_run, thread);
47ba8780	157	#endif
	158	MUTEX_UNLOCK(&create_mutex);
	159
b1edfb69	160	return obj_ref;
47ba8780	161	}
	162
	163	/*
b1edfb69	164	* returns the id of the thread
b1edfb69	165	*/
e6e315b9	166	I32 Perl_thread_tid (SV* obj) {
47ba8780	167	ithread* thread;
47ba8780	168	if(!SvROK(obj)) {
e6e315b9	169	obj = Perl_thread_self(SvPV_nolen(obj));
47ba8780	170	thread = (ithread*)SvIV(SvRV(obj));
	171	SvREFCNT_dec(obj);
	172	} else {
	173	thread = (ithread*)SvIV(SvRV(obj));
	174	}
	175	return thread->tid;
	176	}
	177
e6e315b9	178	SV* Perl_thread_self (char* class) {
47ba8780	179	dTHX;
	180	SV* obj_ref;
	181	SV* obj;
b1edfb69	182	SV* thread_tid_ptr;
	183	SV* thread_ptr;
	184	HE* thread_entry;
47ba8780	185
4f896ddc	186	SHAREDSvLOCK(threads);
47ba8780	187	SHAREDSvEDIT(threads);
47ba8780	188	#ifdef WIN32
b1edfb69	189	thread_tid_ptr = Perl_newSVuv(PL_sharedsv_space,
b1edfb69	190	(UV) GetCurrentThreadId());
47ba8780	191	#else
b1edfb69	192	thread_tid_ptr = Perl_newSVuv(PL_sharedsv_space,
b1edfb69	193	PTR2UV(pthread_self()));
47ba8780	194	#endif
b1edfb69	195	thread_entry = Perl_hv_fetch_ent(PL_sharedsv_space,
	196	(HV*) SHAREDSvGET(threads),
	197	thread_tid_ptr, 0,0);
47ba8780	198	thread_ptr = HeVAL(thread_entry);
47ba8780	199	SvREFCNT_dec(thread_tid_ptr);
47ba8780	200	SHAREDSvRELEASE(threads);
4f896ddc	201	SHAREDSvUNLOCK(threads);
47ba8780	202
	203	obj_ref = newSViv(0);
	204	obj = newSVrv(obj_ref, class);
4f896ddc	205	sv_setsv(obj, thread_ptr);
47ba8780	206	SvREADONLY_on(obj);
	207	return obj_ref;
	208	}
	209
	210	/*
b1edfb69	211	* joins the thread this code needs to take the returnvalue from the
b1edfb69	212	* call_sv and send it back */
47ba8780	213
e6e315b9	214	void Perl_thread_join(SV* obj) {
47ba8780	215	ithread* thread = (ithread*)SvIV(SvRV(obj));
	216	#ifdef WIN32
	217	DWORD waitcode;
	218	waitcode = WaitForSingleObject(thread->handle, INFINITE);
	219	#else
	220	void *retval;
	221	pthread_join(thread->thr,&retval);
	222	#endif
	223	}
	224
b1edfb69	225	/* detaches a thread
b1edfb69	226	* needs to better clean up memory */
47ba8780	227
e6e315b9	228	void Perl_thread_detach(SV* obj) {
47ba8780	229	ithread* thread = (ithread*)SvIV(SvRV(obj));
	230	MUTEX_LOCK(&thread->mutex);
	231	thread->detached = 1;
	232	#if !defined(WIN32)
	233	pthread_detach(thread->thr);
	234	#endif
	235	MUTEX_UNLOCK(&thread->mutex);
	236	}
	237
e6e315b9	238	void Perl_thread_DESTROY (SV* obj) {
47ba8780	239	ithread* thread = (ithread*)SvIV(SvRV(obj));
	240
	241	MUTEX_LOCK(&thread->mutex);
	242	thread->count--;
	243	MUTEX_UNLOCK(&thread->mutex);
e6e315b9	244	Perl_thread_destruct(thread);
47ba8780	245	}
47ba8780	246
e6e315b9	247	void Perl_thread_destruct (ithread* thread) {
47ba8780	248	return;
	249	MUTEX_LOCK(&thread->mutex);
	250	if(thread->count != 0) {
	251	MUTEX_UNLOCK(&thread->mutex);
	252	return;
	253	}
	254	MUTEX_UNLOCK(&thread->mutex);
	255	/* it is safe noone is holding a ref to this */
	256	/printf("proper destruction!\n");/
	257	}
	258
47ba8780	259	MODULE = threads PACKAGE = threads
	260	BOOT:
	261	Perl_sharedsv_init(aTHX);
	262	PL_perl_destruct_level = 2;
	263	threads = Perl_sharedsv_new(aTHX);
	264	SHAREDSvEDIT(threads);
e8f2bb9a	265	SHAREDSvGET(threads) = (SV *)newHV();
47ba8780	266	SHAREDSvRELEASE(threads);
	267	{
	268
	269
	270	SV* temp = get_sv("threads::sharedsv_space", TRUE \| GV_ADDMULTI);
4f896ddc	271	SV* temp2 = newSViv((IV)PL_sharedsv_space );
47ba8780	272	sv_setsv( temp , temp2 );
	273	}
	274	{
	275	ithread* thread = malloc(sizeof(ithread));
	276	SV* thread_tid_ptr;
	277	SV* thread_ptr;
	278	MUTEX_INIT(&thread->mutex);
	279	thread->tid = 0;
	280	#ifdef WIN32
	281	thread->thr = GetCurrentThreadId();
	282	#else
	283	thread->thr = pthread_self();
	284	#endif
d5ecd109	285	SHAREDSvEDIT(threads);
b1edfb69	286	thread_tid_ptr = Perl_newSVuv(PL_sharedsv_space, PTR2UV(thread->thr));
b1edfb69	287	thread_ptr = Perl_newSVuv(PL_sharedsv_space, PTR2UV(thread));
47ba8780	288	hv_store_ent((HV*) SHAREDSvGET(threads), thread_tid_ptr, thread_ptr,0);
4f896ddc	289	SvREFCNT_dec(thread_tid_ptr);
d5ecd109	290	SHAREDSvRELEASE(threads);
47ba8780	291	}
	292	MUTEX_INIT(&create_mutex);
	293
47ba8780	294	PROTOTYPES: DISABLE
	295
	296	SV *
	297	create (class, function_to_call, ...)
	298	char * class
	299	SV * function_to_call
	300	CODE:
	301	AV* params = newAV();
	302	if(items > 2) {
	303	int i;
	304	for(i = 2; i < items ; i++) {
	305	av_push(params, ST(i));
	306	}
	307	}
e6e315b9	308	RETVAL = Perl_thread_create(class, function_to_call, newRV_noinc((SV*) params));
47ba8780	309	OUTPUT:
	310	RETVAL
	311
	312	SV *
	313	self (class)
	314	char* class
	315	CODE:
e6e315b9	316	RETVAL = Perl_thread_self(class);
47ba8780	317	OUTPUT:
	318	RETVAL
	319
	320	int
	321	tid (obj)
	322	SV * obj;
	323	CODE:
e6e315b9	324	RETVAL = Perl_thread_tid(obj);
47ba8780	325	OUTPUT:
	326	RETVAL
	327
	328	void
	329	join (obj)
	330	SV * obj
	331	PREINIT:
	332	I32* temp;
	333	PPCODE:
	334	temp = PL_markstack_ptr++;
e6e315b9	335	Perl_thread_join(obj);
47ba8780	336	if (PL_markstack_ptr != temp) {
	337	/* truly void, because dXSARGS not invoked */
	338	PL_markstack_ptr = temp;
	339	XSRETURN_EMPTY; /* return empty stack */
	340	}
	341	/* must have used dXSARGS; list context implied */
	342	return; /* assume stack size is correct */
	343
	344	void
	345	detach (obj)
	346	SV * obj
	347	PREINIT:
	348	I32* temp;
	349	PPCODE:
	350	temp = PL_markstack_ptr++;
e6e315b9	351	Perl_thread_detach(obj);
47ba8780	352	if (PL_markstack_ptr != temp) {
	353	/* truly void, because dXSARGS not invoked */
	354	PL_markstack_ptr = temp;
	355	XSRETURN_EMPTY; /* return empty stack */
	356	}
	357	/* must have used dXSARGS; list context implied */
	358	return; /* assume stack size is correct */
	359
47ba8780	360	void
	361	DESTROY (obj)
	362	SV * obj
	363	PREINIT:
	364	I32* temp;
	365	PPCODE:
	366	temp = PL_markstack_ptr++;
e6e315b9	367	Perl_thread_DESTROY(obj);
47ba8780	368	if (PL_markstack_ptr != temp) {
	369	/* truly void, because dXSARGS not invoked */
	370	PL_markstack_ptr = temp;
	371	XSRETURN_EMPTY; /* return empty stack */
	372	}
	373	/* must have used dXSARGS; list context implied */
	374	return; /* assume stack size is correct */
	375