07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | #include "global.h"
|
b86ef2 | 2000-11-06 | Henrik Grubbström (Grubba) | | RCSID("$Id: threads.c,v 1.119 2000/11/06 17:05:00 grubba Exp $");
|
a29e02 | 1996-10-15 | Fredrik Hübinette (Hubbe) | |
int num_threads = 1;
int threads_disabled = 0;
#ifdef _REENTRANT
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | #include "threads.h"
#include "array.h"
|
d86cd7 | 1998-08-24 | Marcus Comstedt | | #include "mapping.h"
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | #include "object.h"
|
bb55f8 | 1997-03-16 | Fredrik Hübinette (Hubbe) | | #include "pike_macros.h"
|
a29e02 | 1996-10-15 | Fredrik Hübinette (Hubbe) | | #include "callback.h"
|
9c6f7d | 1997-04-15 | Fredrik Hübinette (Hubbe) | | #include "builtin_functions.h"
#include "constants.h"
|
be478c | 1997-08-30 | Henrik Grubbström (Grubba) | | #include "program.h"
|
3f87be | 1999-12-14 | Martin Stjernholm | | #include "program_id.h"
|
c5b96b | 1997-11-11 | Henrik Grubbström (Grubba) | | #include "gc.h"
|
3c0c28 | 1998-01-26 | Fredrik Hübinette (Hubbe) | | #include "main.h"
|
a49ee6 | 1999-04-02 | Fredrik Hübinette (Hubbe) | | #include "module_support.h"
|
52e4c6 | 1999-12-13 | Martin Stjernholm | | #include "pike_types.h"
|
9a0d42 | 2000-02-06 | Martin Stjernholm | | #include "operators.h"
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | |
|
cd11fa | 1999-05-13 | Henrik Grubbström (Grubba) | | #include <errno.h>
|
ef1e93 | 1998-03-26 | Henrik Grubbström (Grubba) | | int live_threads = 0;
COND_T live_threads_change;
COND_T threads_disabled_change;
|
490887 | 1998-08-10 | Fredrik Hübinette (Hubbe) | | size_t thread_stack_size=1024 * 1204;
|
ef1e93 | 1998-03-26 | Henrik Grubbström (Grubba) | |
|
71ac9e | 1999-08-29 | Fredrik Hübinette (Hubbe) | | #ifndef HAVE_PTHREAD_ATFORK
#include "callback.h"
static struct callback_list atfork_prepare_callback;
static struct callback_list atfork_parent_callback;
static struct callback_list atfork_child_callback;
int th_atfork(void (*prepare)(void),void (*parent)(void),void (*child)(void))
{
if(prepare)
add_to_callback(&atfork_prepare_callback, (callback_func) prepare, 0, 0);
if(parent)
add_to_callback(&atfork_parent_callback, (callback_func) parent, 0, 0);
if(child)
add_to_callback(&atfork_child_callback, (callback_func) child, 0, 0);
return 0;
}
void th_atfork_prepare(void)
{
call_callback(& atfork_prepare_callback, 0);
}
void th_atfork_parent(void)
{
call_callback(& atfork_parent_callback, 0);
}
void th_atfork_child(void)
{
call_callback(& atfork_child_callback, 0);
}
#endif
|
dc7cc9 | 1998-01-14 | Fredrik Hübinette (Hubbe) | | #ifdef __NT__
|
cd67ac | 1999-05-11 | Fredrik Hübinette (Hubbe) | | int low_nt_create_thread(unsigned stack_size,
unsigned (TH_STDCALL *fun)(void *),
void *arg,
unsigned *id)
{
HANDLE h=_beginthreadex(NULL, stack_size, fun, arg, 0, id);
if(h)
{
CloseHandle(h);
return 0;
}
else
{
return 1;
}
}
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
dc7cc9 | 1998-01-14 | Fredrik Hübinette (Hubbe) | | static int IsValidHandle(HANDLE h)
{
__try {
HANDLE ret;
if(DuplicateHandle(GetCurrentProcess(),
h,
GetCurrentProcess(),
&ret,
|
b93e6e | 1999-06-19 | Fredrik Hübinette (Hubbe) | | 0,
|
dc7cc9 | 1998-01-14 | Fredrik Hübinette (Hubbe) | | 0,
DUPLICATE_SAME_ACCESS))
{
CloseHandle(ret);
}
}
__except (1) {
return 0;
}
return 1;
}
|
cd67ac | 1999-05-11 | Fredrik Hübinette (Hubbe) | | HANDLE CheckValidHandle(HANDLE h)
|
dc7cc9 | 1998-01-14 | Fredrik Hübinette (Hubbe) | | {
|
cd67ac | 1999-05-11 | Fredrik Hübinette (Hubbe) | | if(!IsValidHandle(h))
|
dc7cc9 | 1998-01-14 | Fredrik Hübinette (Hubbe) | | fatal("Invalid handle!\n");
|
cd67ac | 1999-05-11 | Fredrik Hübinette (Hubbe) | | return h;
|
dc7cc9 | 1998-01-14 | Fredrik Hübinette (Hubbe) | | }
#endif
#endif
|
e42eaf | 1998-01-02 | Fredrik Hübinette (Hubbe) | | #ifdef SIMULATE_COND_WITH_EVENT
int co_wait(COND_T *c, MUTEX_T *m)
{
struct cond_t_queue me;
event_init(&me.event);
|
dc7cc9 | 1998-01-14 | Fredrik Hübinette (Hubbe) | | me.next=0;
|
e42eaf | 1998-01-02 | Fredrik Hübinette (Hubbe) | | mt_lock(& c->lock);
|
dc7cc9 | 1998-01-14 | Fredrik Hübinette (Hubbe) | | if(c->tail)
{
c->tail->next=&me;
c->tail=&me;
}else{
c->head=c->tail=&me;
}
|
e42eaf | 1998-01-02 | Fredrik Hübinette (Hubbe) | |
mt_unlock(& c->lock);
mt_unlock(m);
event_wait(&me.event);
mt_lock(m);
event_destroy(& me.event);
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
dc7cc9 | 1998-01-14 | Fredrik Hübinette (Hubbe) | | if(me.next)
fatal("Wait on event return prematurely!!\n");
#endif
|
e42eaf | 1998-01-02 | Fredrik Hübinette (Hubbe) | | return 0;
}
int co_signal(COND_T *c)
{
struct cond_t_queue *t;
mt_lock(& c->lock);
|
dc7cc9 | 1998-01-14 | Fredrik Hübinette (Hubbe) | | if((t=c->head))
|
e42eaf | 1998-01-02 | Fredrik Hübinette (Hubbe) | | {
c->head=t->next;
t->next=0;
if(!c->head) c->tail=0;
}
mt_unlock(& c->lock);
if(t)
event_signal(& t->event);
return 0;
}
int co_broadcast(COND_T *c)
{
struct cond_t_queue *t,*n;
mt_lock(& c->lock);
n=c->head;
c->head=c->tail=0;
mt_unlock(& c->lock);
while((t=n))
{
n=t->next;
|
dc7cc9 | 1998-01-14 | Fredrik Hübinette (Hubbe) | | t->next=0;
|
e42eaf | 1998-01-02 | Fredrik Hübinette (Hubbe) | | event_signal(& t->event);
}
return 0;
}
int co_destroy(COND_T *c)
{
struct cond_t_queue *t;
mt_lock(& c->lock);
|
b1f4eb | 1998-01-13 | Fredrik Hübinette (Hubbe) | | t=c->head;
mt_unlock(& c->lock);
if(t) return -1;
mt_destroy(& c->lock);
|
e42eaf | 1998-01-02 | Fredrik Hübinette (Hubbe) | | return 0;
}
#endif
|
60d987 | 2000-03-23 | Fredrik Hübinette (Hubbe) | | #define THIS_THREAD ((struct thread_state *)CURRENT_STORAGE)
|
574088 | 1998-01-01 | Fredrik Hübinette (Hubbe) | |
|
c3b995 | 2000-02-15 | Henrik Grubbström (Grubba) | | struct object *thread_id = NULL;
|
a29e02 | 1996-10-15 | Fredrik Hübinette (Hubbe) | | static struct callback *threads_evaluator_callback=0;
|
574088 | 1998-01-01 | Fredrik Hübinette (Hubbe) | | int thread_id_result_variable;
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | |
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | MUTEX_T interpreter_lock, thread_table_lock, interleave_lock;
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | struct program *mutex_key = 0;
|
6d1a5e | 1996-10-07 | Fredrik Hübinette (Hubbe) | | struct program *thread_id_prog = 0;
|
d86cd7 | 1998-08-24 | Marcus Comstedt | | struct program *thread_local_prog = 0;
|
97ffe4 | 1997-01-26 | Per Hedbor | | #ifdef POSIX_THREADS
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | pthread_attr_t pattr;
|
864d3c | 1998-01-29 | Fredrik Hübinette (Hubbe) | | pthread_attr_t small_pattr;
|
97ffe4 | 1997-01-26 | Per Hedbor | | #endif
|
9b92d3 | 1999-01-31 | Fredrik Hübinette (Hubbe) | | int thread_storage_offset;
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | |
|
6d1a5e | 1996-10-07 | Fredrik Hübinette (Hubbe) | | struct thread_starter
{
struct object *id;
struct array *args;
};
|
d86cd7 | 1998-08-24 | Marcus Comstedt | | struct thread_local
{
INT32 id;
};
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | static volatile IMUTEX_T *interleave_list = NULL;
|
f328f1 | 1998-07-17 | Henrik Grubbström (Grubba) | | void low_init_threads_disable(void)
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | {
if (!threads_disabled) {
|
f328f1 | 1998-07-17 | Henrik Grubbström (Grubba) | | THREADS_FPRINTF(0,
(stderr, "low_init_threads_disable(): Locking IM's...\n"));
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | |
if (thread_id) {
|
2f748a | 1999-02-20 | Henrik Grubbström (Grubba) | |
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | IMUTEX_T *im;
THREADS_ALLOW();
mt_lock(&interleave_lock);
im = (IMUTEX_T *)interleave_list;
while(im) {
mt_lock(&(im->lock));
im = im->next;
}
THREADS_DISALLOW();
} else {
|
2f748a | 1999-02-20 | Henrik Grubbström (Grubba) | |
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | IMUTEX_T *im;
mt_lock(&interleave_lock);
im = (IMUTEX_T *)interleave_list;
while(im) {
mt_lock(&(im->lock));
im = im->next;
}
}
|
f328f1 | 1998-07-17 | Henrik Grubbström (Grubba) | | THREADS_FPRINTF(0, (stderr,
"low_init_threads_disable(): Disabling threads.\n"));
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | |
threads_disabled = 1;
} else {
threads_disabled++;
}
|
f328f1 | 1998-07-17 | Henrik Grubbström (Grubba) | | THREADS_FPRINTF(0,
(stderr, "low_init_threads_disable(): threads_disabled:%d\n",
threads_disabled));
}
|
16df70 | 1998-07-16 | Fredrik Hübinette (Hubbe) | |
|
f328f1 | 1998-07-17 | Henrik Grubbström (Grubba) | | void init_threads_disable(struct object *o)
{
low_init_threads_disable();
if(live_threads) {
SWAP_OUT_CURRENT_THREAD();
while (live_threads) {
THREADS_FPRINTF(0,
(stderr,
"_disable_threads(): Waiting for %d threads to finish\n",
live_threads));
co_wait(&live_threads_change, &interpreter_lock);
|
16df70 | 1998-07-16 | Fredrik Hübinette (Hubbe) | | }
|
f328f1 | 1998-07-17 | Henrik Grubbström (Grubba) | | SWAP_IN_CURRENT_THREAD();
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | }
}
|
de413f | 1998-03-26 | Per Hedbor | | void exit_threads_disable(struct object *o)
{
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | THREADS_FPRINTF(0, (stderr, "exit_threads_disable(): threads_disabled:%d\n",
threads_disabled));
|
40e949 | 1998-07-05 | Henrik Grubbström (Grubba) | | if(threads_disabled) {
if(!--threads_disabled) {
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | IMUTEX_T *im = (IMUTEX_T *)interleave_list;
while(im) {
THREADS_FPRINTF(0,
(stderr,
"exit_threads_disable(): Unlocking IM 0x%08p\n", im));
mt_unlock(&(im->lock));
im = im->next;
}
mt_unlock(&interleave_lock);
THREADS_FPRINTF(0, (stderr, "_exit_threads_disable(): Wake up!\n"));
|
2202fe | 1998-04-23 | Fredrik Hübinette (Hubbe) | | co_broadcast(&threads_disabled_change);
|
40e949 | 1998-07-05 | Henrik Grubbström (Grubba) | | }
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
40e949 | 1998-07-05 | Henrik Grubbström (Grubba) | | } else {
fatal("exit_threads_disable() called too many times!\n");
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #endif /* PIKE_DEBUG */
|
40e949 | 1998-07-05 | Henrik Grubbström (Grubba) | | }
|
de413f | 1998-03-26 | Per Hedbor | | }
|
063fe3 | 1998-03-10 | Per Hedbor | |
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | void init_interleave_mutex(IMUTEX_T *im)
|
063fe3 | 1998-03-10 | Per Hedbor | | {
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | mt_init(&(im->lock));
|
6e1db5 | 1998-07-09 | Henrik Grubbström (Grubba) | |
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | THREADS_FPRINTF(0, (stderr,
"init_interleave_mutex(): init_threads_disable()\n"));
|
6e1db5 | 1998-07-09 | Henrik Grubbström (Grubba) | |
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | init_threads_disable(NULL);
|
6e1db5 | 1998-07-09 | Henrik Grubbström (Grubba) | |
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | THREADS_FPRINTF(0, (stderr,
"init_interleave_mutex(): Locking IM 0x%08p\n", im));
|
6e1db5 | 1998-07-09 | Henrik Grubbström (Grubba) | |
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | |
mt_lock(&(im->lock));
im->next = (IMUTEX_T *)interleave_list;
if (interleave_list) {
interleave_list->prev = im;
|
6e1db5 | 1998-07-09 | Henrik Grubbström (Grubba) | | }
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | interleave_list = im;
im->prev = NULL;
|
6e1db5 | 1998-07-09 | Henrik Grubbström (Grubba) | |
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | THREADS_FPRINTF(0, (stderr,
"init_interleave_mutex(): exit_threads_disable()\n"));
exit_threads_disable(NULL);
}
void exit_interleave_mutex(IMUTEX_T *im)
{
init_threads_disable(NULL);
if (im->prev) {
im->prev->next = im->next;
} else {
interleave_list = im->next;
}
if (im->next) {
im->next->prev = im->prev;
|
ef1e93 | 1998-03-26 | Henrik Grubbström (Grubba) | | }
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | |
mt_unlock(&(im->lock));
exit_threads_disable(NULL);
|
063fe3 | 1998-03-10 | Per Hedbor | | }
|
eac209 | 1998-02-27 | Marcus Comstedt | |
#define THREAD_TABLE_SIZE 127 /* Totally arbitrary prime */
static struct thread_state *thread_table_chains[THREAD_TABLE_SIZE];
|
56ac10 | 2000-03-29 | Fredrik Hübinette (Hubbe) | | static int num_pike_threads=0;
|
eac209 | 1998-02-27 | Marcus Comstedt | |
|
22ca07 | 1998-04-08 | Fredrik Hübinette (Hubbe) | | void thread_table_init(void)
|
eac209 | 1998-02-27 | Marcus Comstedt | | {
INT32 x;
for(x=0; x<THREAD_TABLE_SIZE; x++)
thread_table_chains[x] = NULL;
}
unsigned INT32 thread_table_hash(THREAD_T *tid)
{
|
d21327 | 1998-02-28 | Fredrik Hübinette (Hubbe) | | return th_hash(*tid) % THREAD_TABLE_SIZE;
|
eac209 | 1998-02-27 | Marcus Comstedt | | }
|
26cd94 | 1999-05-07 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
static void dumpmem(char *desc, void *x, int size)
{
int e;
unsigned char *tmp=(unsigned char *)x;
fprintf(stderr,"%s: ",desc);
for(e=0;e<size;e++)
fprintf(stderr,"%02x",tmp[e]);
fprintf(stderr,"\n");
}
#endif
|
eac209 | 1998-02-27 | Marcus Comstedt | | void thread_table_insert(struct object *o)
{
|
9b92d3 | 1999-01-31 | Fredrik Hübinette (Hubbe) | | struct thread_state *s = OBJ2THREAD(o);
|
eac209 | 1998-02-27 | Marcus Comstedt | | unsigned INT32 h = thread_table_hash(&s->id);
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
939b18 | 1998-07-17 | Fredrik Hübinette (Hubbe) | | if(h>=THREAD_TABLE_SIZE)
fatal("thread_table_hash failed miserably!\n");
|
26cd94 | 1999-05-07 | Fredrik Hübinette (Hubbe) | | if(thread_state_for_id(s->id))
|
3be550 | 1999-06-08 | Fredrik Hübinette (Hubbe) | | {
if(thread_state_for_id(s->id) == s)
fatal("Registring thread twice!\n");
else
fatal("Forgot to unregister thread!\n");
}
|
26cd94 | 1999-05-07 | Fredrik Hübinette (Hubbe) | |
|
939b18 | 1998-07-17 | Fredrik Hübinette (Hubbe) | | #endif
|
eac209 | 1998-02-27 | Marcus Comstedt | | mt_lock( & thread_table_lock );
|
56ac10 | 2000-03-29 | Fredrik Hübinette (Hubbe) | | num_pike_threads++;
|
eac209 | 1998-02-27 | Marcus Comstedt | | if((s->hashlink = thread_table_chains[h]) != NULL)
s->hashlink->backlink = &s->hashlink;
thread_table_chains[h] = s;
s->backlink = &thread_table_chains[h];
mt_unlock( & thread_table_lock );
}
void thread_table_delete(struct object *o)
{
|
9b92d3 | 1999-01-31 | Fredrik Hübinette (Hubbe) | | struct thread_state *s = OBJ2THREAD(o);
|
26cd94 | 1999-05-07 | Fredrik Hübinette (Hubbe) | |
|
eac209 | 1998-02-27 | Marcus Comstedt | | mt_lock( & thread_table_lock );
|
56ac10 | 2000-03-29 | Fredrik Hübinette (Hubbe) | | num_pike_threads--;
|
eac209 | 1998-02-27 | Marcus Comstedt | | if(s->hashlink != NULL)
s->hashlink->backlink = s->backlink;
*(s->backlink) = s->hashlink;
mt_unlock( & thread_table_lock );
}
struct thread_state *thread_state_for_id(THREAD_T tid)
{
unsigned INT32 h = thread_table_hash(&tid);
struct thread_state *s = NULL;
|
26cd94 | 1999-05-07 | Fredrik Hübinette (Hubbe) | | #if 0
if(num_threads>1)
dumpmem("thread_state_for_id: ",&tid,sizeof(tid));
#endif
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
939b18 | 1998-07-17 | Fredrik Hübinette (Hubbe) | | if(h>=THREAD_TABLE_SIZE)
fatal("thread_table_hash failed miserably!\n");
#endif
|
eac209 | 1998-02-27 | Marcus Comstedt | | mt_lock( & thread_table_lock );
|
d21327 | 1998-02-28 | Fredrik Hübinette (Hubbe) | | if(thread_table_chains[h] == NULL)
{
|
eac209 | 1998-02-27 | Marcus Comstedt | |
|
d21327 | 1998-02-28 | Fredrik Hübinette (Hubbe) | | }
else if(th_equal((s=thread_table_chains[h])->id, tid))
{
|
eac209 | 1998-02-27 | Marcus Comstedt | |
|
d21327 | 1998-02-28 | Fredrik Hübinette (Hubbe) | | }
else
{
|
eac209 | 1998-02-27 | Marcus Comstedt | | while((s = s->hashlink) != NULL)
|
d21327 | 1998-02-28 | Fredrik Hübinette (Hubbe) | | if(th_equal(s->id, tid))
|
eac209 | 1998-02-27 | Marcus Comstedt | | break;
if(s != NULL) {
if(s->hashlink != NULL)
s->hashlink->backlink = s->backlink;
*(s->backlink) = s->hashlink;
if((s->hashlink = thread_table_chains[h]) != NULL)
s->hashlink->backlink = &s->hashlink;
thread_table_chains[h] = s;
s->backlink = &thread_table_chains[h];
}
}
mt_unlock( & thread_table_lock );
|
26cd94 | 1999-05-07 | Fredrik Hübinette (Hubbe) | | #if 0
if(num_threads>1 && s)
dumpmem("thread_state_for_id return value: ",&s->id,sizeof(tid));
#endif
|
eac209 | 1998-02-27 | Marcus Comstedt | | return s;
}
struct object *thread_for_id(THREAD_T tid)
{
struct thread_state *s = thread_state_for_id(tid);
|
26cd94 | 1999-05-07 | Fredrik Hübinette (Hubbe) | | return (s == NULL? NULL : THREADSTATE2OBJ(s));
|
eac209 | 1998-02-27 | Marcus Comstedt | |
}
void f_all_threads(INT32 args)
{
INT32 x;
struct svalue *oldsp;
struct thread_state *s;
pop_n_elems(args);
oldsp = sp;
mt_lock( & thread_table_lock );
for(x=0; x<THREAD_TABLE_SIZE; x++)
for(s=thread_table_chains[x]; s; s=s->hashlink) {
|
26cd94 | 1999-05-07 | Fredrik Hübinette (Hubbe) | | struct object *o = THREADSTATE2OBJ(s);
|
d6ac73 | 1998-04-20 | Henrik Grubbström (Grubba) | | ref_push_object(o);
|
eac209 | 1998-02-27 | Marcus Comstedt | | }
mt_unlock( & thread_table_lock );
f_aggregate(sp-oldsp);
}
|
56ac10 | 2000-03-29 | Fredrik Hübinette (Hubbe) | | int count_pike_threads(void)
{
return num_pike_threads;
}
|
eac209 | 1998-02-27 | Marcus Comstedt | |
|
9ef9a3 | 1996-11-16 | Fredrik Hübinette (Hubbe) | | static void check_threads(struct callback *cb, void *arg, void * arg2)
|
a29e02 | 1996-10-15 | Fredrik Hübinette (Hubbe) | | {
|
0a861b | 1997-09-17 | Fredrik Hübinette (Hubbe) | | static int div_;
if(div_++ & 255) return;
|
26cd94 | 1999-05-07 | Fredrik Hübinette (Hubbe) | | #ifdef DEBUG
if(thread_for_id(th_self()) != thread_id)
fatal("thread_for_id() (or thread_id) failed!\n")
#endif
|
de413f | 1998-03-26 | Per Hedbor | | THREADS_ALLOW();
THREADS_DISALLOW();
|
26cd94 | 1999-05-07 | Fredrik Hübinette (Hubbe) | |
#ifdef DEBUG
if(thread_for_id(th_self()) != thread_id)
fatal("thread_for_id() (or thread_id) failed!\n")
#endif
|
a29e02 | 1996-10-15 | Fredrik Hübinette (Hubbe) | | }
|
26cd94 | 1999-05-07 | Fredrik Hübinette (Hubbe) | | TH_RETURN_TYPE new_thread_func(void * data)
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | {
|
6d1a5e | 1996-10-07 | Fredrik Hübinette (Hubbe) | | struct thread_starter arg = *(struct thread_starter *)data;
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | JMP_BUF back;
|
725ba9 | 1996-10-12 | Fredrik Hübinette (Hubbe) | | INT32 tmp;
|
b1b51f | 1996-10-11 | Fredrik Hübinette (Hubbe) | |
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | THREADS_FPRINTF(0, (stderr,"THREADS_DISALLOW() Thread %08x created...\n",
(unsigned int)arg.id));
|
fe76ce | 1997-09-08 | Fredrik Hübinette (Hubbe) | |
|
9c6f7d | 1997-04-15 | Fredrik Hübinette (Hubbe) | | if((tmp=mt_lock( & interpreter_lock)))
|
cd67ac | 1999-05-11 | Fredrik Hübinette (Hubbe) | | fatal("Failed to lock interpreter, return value=%d, errno=%d\n",tmp,
#ifdef __NT__
GetLastError()
#else
errno
#endif
);
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | init_interpreter();
|
6d1a5e | 1996-10-07 | Fredrik Hübinette (Hubbe) | | thread_id=arg.id;
|
f0cd4c | 1999-03-21 | Henrik Grubbström (Grubba) | | stack_top=((char *)&data)+ (thread_stack_size-16384) * STACK_DIRECTION;
recoveries = NULL;
|
84cfce | 2000-01-15 | Fredrik Hübinette (Hubbe) | | SWAP_OUT_THREAD(OBJ2THREAD(thread_id));
OBJ2THREAD(thread_id)->swapped=0;
|
f0cd4c | 1999-03-21 | Henrik Grubbström (Grubba) | |
|
26cd94 | 1999-05-07 | Fredrik Hübinette (Hubbe) | | #if defined(PIKE_DEBUG)
if(d_flag)
{
|
f46983 | 1999-05-08 | Henrik Grubbström (Grubba) | | THREAD_T self = th_self();
if( thread_id && !th_equal( OBJ2THREAD(thread_id)->id, self) )
fatal("Current thread is wrong. %x %x\n",
OBJ2THREAD(thread_id)->id, self);
|
26cd94 | 1999-05-07 | Fredrik Hübinette (Hubbe) | |
if(thread_for_id(th_self()) != thread_id)
|
f46983 | 1999-05-08 | Henrik Grubbström (Grubba) | | fatal("thread_for_id() (or thread_id) failed in new_thread_func! "
"%p != %p\n", thread_for_id(self), thread_id);
}
|
26cd94 | 1999-05-07 | Fredrik Hübinette (Hubbe) | | #endif
|
78112c | 1998-04-13 | Henrik Grubbström (Grubba) | | #ifdef THREAD_TRACE
{
t_flag = default_t_flag;
}
#endif /* THREAD_TRACE */
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | |
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | THREADS_FPRINTF(0, (stderr,"THREAD %08x INITED\n",(unsigned int)thread_id));
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | if(SETJMP(back))
{
|
61e9a0 | 1998-01-25 | Fredrik Hübinette (Hubbe) | | if(throw_severity < THROW_EXIT)
{
ONERROR tmp;
|
9d322a | 2000-10-05 | Henrik Grubbström (Grubba) | | t_flag=0;
|
61e9a0 | 1998-01-25 | Fredrik Hübinette (Hubbe) | | SET_ONERROR(tmp,exit_on_error,"Error in handle_error in master object!");
assign_svalue_no_free(sp++, & throw_value);
APPLY_MASTER("handle_error", 1);
pop_stack();
UNSET_ONERROR(tmp);
}
if(throw_severity == THROW_EXIT)
{
|
d40e38 | 1999-10-14 | Henrik Grubbström (Grubba) | | free((char *) data);
|
b86ef2 | 2000-11-06 | Henrik Grubbström (Grubba) | | pike_do_exit(throw_value.u.integer);
|
61e9a0 | 1998-01-25 | Fredrik Hübinette (Hubbe) | | }
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | } else {
|
725ba9 | 1996-10-12 | Fredrik Hübinette (Hubbe) | | INT32 args=arg.args->size;
|
61e9a0 | 1998-01-25 | Fredrik Hübinette (Hubbe) | | back.severity=THROW_EXIT;
|
6d1a5e | 1996-10-07 | Fredrik Hübinette (Hubbe) | | push_array_items(arg.args);
arg.args=0;
|
97ffe4 | 1997-01-26 | Per Hedbor | | f_call_function(args);
|
574088 | 1998-01-01 | Fredrik Hübinette (Hubbe) | |
object_low_set_index(thread_id,
thread_id_result_variable,
sp-1);
pop_stack();
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | }
|
9b92d3 | 1999-01-31 | Fredrik Hübinette (Hubbe) | | if(OBJ2THREAD(thread_id)->thread_local != NULL) {
free_mapping(OBJ2THREAD(thread_id)->thread_local);
OBJ2THREAD(thread_id)->thread_local = NULL;
|
d86cd7 | 1998-08-24 | Marcus Comstedt | | }
|
9b92d3 | 1999-01-31 | Fredrik Hübinette (Hubbe) | | OBJ2THREAD(thread_id)->status=THREAD_EXITED;
co_broadcast(& OBJ2THREAD(thread_id)->status_change);
|
574088 | 1998-01-01 | Fredrik Hübinette (Hubbe) | |
|
4bdad0 | 1997-09-01 | Per Hedbor | | free((char *)data);
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | UNSETJMP(back);
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | THREADS_FPRINTF(0, (stderr,"THREADS_ALLOW() Thread %08x done\n",
(unsigned int)thread_id));
|
b1b51f | 1996-10-11 | Fredrik Hübinette (Hubbe) | |
|
60d987 | 2000-03-23 | Fredrik Hübinette (Hubbe) | | cleanup_interpret();
DO_IF_DMALLOC(
SWAP_OUT_THREAD(OBJ2THREAD(thread_id));
OBJ2THREAD(thread_id)->swapped=0;
)
|
eac209 | 1998-02-27 | Marcus Comstedt | | thread_table_delete(thread_id);
|
6d1a5e | 1996-10-07 | Fredrik Hübinette (Hubbe) | | free_object(thread_id);
thread_id=0;
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | num_threads--;
|
fe76ce | 1997-09-08 | Fredrik Hübinette (Hubbe) | | if(!num_threads && threads_evaluator_callback)
|
a29e02 | 1996-10-15 | Fredrik Hübinette (Hubbe) | | {
remove_callback(threads_evaluator_callback);
threads_evaluator_callback=0;
}
|
6d1a5e | 1996-10-07 | Fredrik Hübinette (Hubbe) | | mt_unlock(& interpreter_lock);
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | th_exit(0);
|
9c8b2d | 1997-04-20 | Henrik Grubbström (Grubba) | |
return(NULL);
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | }
|
97ffe4 | 1997-01-26 | Per Hedbor | | #ifdef UNIX_THREADS
int num_lwps = 1;
#endif
|
b1b51f | 1996-10-11 | Fredrik Hübinette (Hubbe) | |
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | void f_thread_create(INT32 args)
{
|
97ffe4 | 1997-01-26 | Per Hedbor | | THREAD_T dummy;
|
b1b51f | 1996-10-11 | Fredrik Hübinette (Hubbe) | | struct thread_starter *arg;
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | int tmp;
|
d40e38 | 1999-10-14 | Henrik Grubbström (Grubba) | | arg = ALLOC_STRUCT(thread_starter);
|
6d1a5e | 1996-10-07 | Fredrik Hübinette (Hubbe) | | arg->args=aggregate_array(args);
|
e70975 | 1997-03-12 | Fredrik Hübinette (Hubbe) | | arg->id=clone_object(thread_id_prog,0);
|
9b92d3 | 1999-01-31 | Fredrik Hübinette (Hubbe) | | OBJ2THREAD(arg->id)->status=THREAD_RUNNING;
|
b2a0fb | 1997-02-06 | Henrik Grubbström (Grubba) | |
|
4743f8 | 1999-06-02 | Fredrik Hübinette (Hubbe) | | do {
|
d40e38 | 1999-10-14 | Henrik Grubbström (Grubba) | | tmp = th_create(& OBJ2THREAD(arg->id)->id,
new_thread_func,
arg);
|
4743f8 | 1999-06-02 | Fredrik Hübinette (Hubbe) | | } while( tmp == EINTR );
|
b2a0fb | 1997-02-06 | Henrik Grubbström (Grubba) | |
|
6d1a5e | 1996-10-07 | Fredrik Hübinette (Hubbe) | | if(!tmp)
{
num_threads++;
|
eac209 | 1998-02-27 | Marcus Comstedt | | thread_table_insert(arg->id);
|
a29e02 | 1996-10-15 | Fredrik Hübinette (Hubbe) | |
|
fe76ce | 1997-09-08 | Fredrik Hübinette (Hubbe) | | if(!threads_evaluator_callback)
|
a29e02 | 1996-10-15 | Fredrik Hübinette (Hubbe) | | {
threads_evaluator_callback=add_to_callback(&evaluator_callbacks,
check_threads, 0,0);
|
424d9c | 1999-05-02 | Fredrik Hübinette (Hubbe) | | dmalloc_accept_leak(threads_evaluator_callback);
|
a29e02 | 1996-10-15 | Fredrik Hübinette (Hubbe) | | }
|
d6ac73 | 1998-04-20 | Henrik Grubbström (Grubba) | | ref_push_object(arg->id);
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | THREADS_FPRINTF(0, (stderr, "THREAD_CREATE -> t:%08x\n",
(unsigned int)arg->id));
|
6d1a5e | 1996-10-07 | Fredrik Hübinette (Hubbe) | | } else {
free_object(arg->id);
free_array(arg->args);
free((char *)arg);
|
70d5f8 | 1998-03-25 | Henrik Grubbström (Grubba) | | error("Failed to create thread (errno = %d).\n",tmp);
|
6d1a5e | 1996-10-07 | Fredrik Hübinette (Hubbe) | | }
}
|
1e4a64 | 1997-09-03 | Martin Stjernholm | | #ifdef UNIX_THREADS
|
97ffe4 | 1997-01-26 | Per Hedbor | | void f_thread_set_concurrency(INT32 args)
{
int c=1;
if(args) c=sp[-args].u.integer;
else error("No argument to thread_set_concurrency(int concurrency);\n");
pop_n_elems(args);
|
09dceb | 1997-09-01 | Per Hedbor | | num_lwps=c;
|
97ffe4 | 1997-01-26 | Per Hedbor | | th_setconcurrency(c);
}
|
1e4a64 | 1997-09-03 | Martin Stjernholm | | #endif
|
97ffe4 | 1997-01-26 | Per Hedbor | |
|
6d1a5e | 1996-10-07 | Fredrik Hübinette (Hubbe) | | void f_this_thread(INT32 args)
{
pop_n_elems(args);
|
d6ac73 | 1998-04-20 | Henrik Grubbström (Grubba) | | ref_push_object(thread_id);
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | }
|
60d987 | 2000-03-23 | Fredrik Hübinette (Hubbe) | | #define THIS_MUTEX ((struct mutex_storage *)(CURRENT_STORAGE))
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | |
struct mutex_storage
{
COND_T condition;
struct object *key;
};
struct key_storage
{
struct mutex_storage *mut;
|
09dceb | 1997-09-01 | Per Hedbor | | struct object *owner;
|
4bdad0 | 1997-09-01 | Per Hedbor | | int initialized;
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | };
#define OB2KEY(X) ((struct key_storage *)((X)->storage))
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | |
void f_mutex_lock(INT32 args)
{
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | struct mutex_storage *m;
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | struct object *o;
|
a49ee6 | 1999-04-02 | Fredrik Hübinette (Hubbe) | | INT_TYPE type;
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | |
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | m=THIS_MUTEX;
|
a49ee6 | 1999-04-02 | Fredrik Hübinette (Hubbe) | | if(!args)
type=0;
else
get_all_args("mutex->lock",args,"%i",&type);
switch(type)
{
default:
bad_arg_error("mutex->lock", sp-args, args, 2, "int(0..2)", sp+1-args,
"Unknown mutex locking style: %d\n",type);
case 0:
case 2:
if(m->key && OB2KEY(m->key)->owner == thread_id)
{
THREADS_FPRINTF(0,
(stderr, "Recursive LOCK k:%08x, m:%08x(%08x), t:%08x\n",
(unsigned int)OB2KEY(m->key),
(unsigned int)m,
(unsigned int)OB2KEY(m->key)->mut,
(unsigned int) thread_id));
if(type==0) error("Recursive mutex locks!\n");
pop_n_elems(args);
push_int(0);
|
c27369 | 2000-02-10 | Fredrik Hübinette (Hubbe) | | return;
|
a49ee6 | 1999-04-02 | Fredrik Hübinette (Hubbe) | | }
case 1:
break;
}
|
46d7bf | 1997-09-03 | Henrik Grubbström (Grubba) | |
|
65df5c | 1997-09-01 | Per Hedbor | | o=clone_object(mutex_key,0);
|
4bdad0 | 1997-09-01 | Per Hedbor | |
|
26cd94 | 1999-05-07 | Fredrik Hübinette (Hubbe) | | DO_IF_DEBUG( if(thread_for_id(th_self()) != thread_id)
fatal("thread_for_id() (or thread_id) failed! %p != %p\n",thread_for_id(th_self()),thread_id) ; )
|
0a861b | 1997-09-17 | Fredrik Hübinette (Hubbe) | | if(m->key)
|
fe76ce | 1997-09-08 | Fredrik Hübinette (Hubbe) | | {
|
adb19b | 1999-06-30 | Fredrik Hübinette (Hubbe) | | if(threads_disabled)
{
free_object(o);
error("Cannot wait for mutexes when threads are disabled!\n");
}
|
b504ed | 1997-09-21 | Fredrik Hübinette (Hubbe) | | SWAP_OUT_CURRENT_THREAD();
do
|
0a861b | 1997-09-17 | Fredrik Hübinette (Hubbe) | | {
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | THREADS_FPRINTF(1, (stderr,"WAITING TO LOCK m:%08x\n",(unsigned int)m));
|
b504ed | 1997-09-21 | Fredrik Hübinette (Hubbe) | | co_wait(& m->condition, & interpreter_lock);
}while(m->key);
SWAP_IN_CURRENT_THREAD();
|
fe76ce | 1997-09-08 | Fredrik Hübinette (Hubbe) | | }
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | m->key=o;
|
46d7bf | 1997-09-03 | Henrik Grubbström (Grubba) | | OB2KEY(o)->mut=m;
|
fe76ce | 1997-09-08 | Fredrik Hübinette (Hubbe) | |
|
26cd94 | 1999-05-07 | Fredrik Hübinette (Hubbe) | | DO_IF_DEBUG( if(thread_for_id(th_self()) != thread_id)
fatal("thread_for_id() (or thread_id) failed! %p != %p\n",thread_for_id(th_self()),thread_id) ; )
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | THREADS_FPRINTF(1, (stderr, "LOCK k:%08x, m:%08x(%08x), t:%08x\n",
(unsigned int)OB2KEY(o),
(unsigned int)m,
(unsigned int)OB2KEY(m->key)->mut,
(unsigned int)thread_id));
|
65d3c3 | 1997-09-08 | Fredrik Hübinette (Hubbe) | | pop_n_elems(args);
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | push_object(o);
}
void f_mutex_trylock(INT32 args)
{
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | struct mutex_storage *m;
struct object *o;
|
9d322a | 2000-10-05 | Henrik Grubbström (Grubba) | | INT_TYPE type;
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | int i=0;
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | |
|
46d7bf | 1997-09-03 | Henrik Grubbström (Grubba) | |
|
a49ee6 | 1999-04-02 | Fredrik Hübinette (Hubbe) | | m=THIS_MUTEX;
if(!args)
type=0;
else
get_all_args("mutex->lock",args,"%i",&type);
switch(type)
|
65df5c | 1997-09-01 | Per Hedbor | | {
|
a49ee6 | 1999-04-02 | Fredrik Hübinette (Hubbe) | | default:
bad_arg_error("mutex->trylock", sp-args, args, 2, "int(0..2)", sp+1-args,
"Unknown mutex locking style: %d\n",type);
case 0:
if(m->key && OB2KEY(m->key)->owner == thread_id)
{
error("Recursive mutex locks!\n");
}
case 2:
case 1:
break;
|
65df5c | 1997-09-01 | Per Hedbor | | }
|
50fd18 | 1997-09-17 | Fredrik Hübinette (Hubbe) | |
|
a49ee6 | 1999-04-02 | Fredrik Hübinette (Hubbe) | | o=clone_object(mutex_key,0);
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | if(!m->key)
{
|
e4293f | 1997-04-17 | Fredrik Hübinette (Hubbe) | | OB2KEY(o)->mut=m;
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | m->key=o;
i=1;
}
|
4bdad0 | 1997-09-01 | Per Hedbor | |
|
65d3c3 | 1997-09-08 | Fredrik Hübinette (Hubbe) | | pop_n_elems(args);
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | if(i)
{
push_object(o);
} else {
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | destruct(o);
free_object(o);
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | push_int(0);
}
}
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | void init_mutex_obj(struct object *o)
{
co_init(& THIS_MUTEX->condition);
THIS_MUTEX->key=0;
}
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | |
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | void exit_mutex_obj(struct object *o)
{
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | THREADS_FPRINTF(1, (stderr, "DESTROYING MUTEX m:%08x\n",
(unsigned int)THIS_MUTEX));
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | if(THIS_MUTEX->key) destruct(THIS_MUTEX->key);
|
88fe36 | 1997-09-04 | Per Hedbor | | THIS_MUTEX->key=0;
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | co_destroy(& THIS_MUTEX->condition);
}
|
60d987 | 2000-03-23 | Fredrik Hübinette (Hubbe) | | #define THIS_KEY ((struct key_storage *)(CURRENT_STORAGE))
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | void init_mutex_key_obj(struct object *o)
{
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | THREADS_FPRINTF(1, (stderr, "KEY k:%08x, o:%08x\n",
(unsigned int)THIS_KEY, (unsigned int)thread_id));
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | THIS_KEY->mut=0;
|
d6ac73 | 1998-04-20 | Henrik Grubbström (Grubba) | | add_ref(THIS_KEY->owner=thread_id);
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | THIS_KEY->initialized=1;
}
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | |
void exit_mutex_key_obj(struct object *o)
{
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | THREADS_FPRINTF(1, (stderr, "UNLOCK k:%08x m:(%08x) t:%08x o:%08x\n",
(unsigned int)THIS_KEY,
(unsigned int)THIS_KEY->mut,
(unsigned int)thread_id,
(unsigned int)THIS_KEY->owner));
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | if(THIS_KEY->mut)
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | {
|
03b1fe | 1997-09-06 | Per Hedbor | | struct mutex_storage *mut = THIS_KEY->mut;
|
c11387 | 1997-09-15 | Henrik Grubbström (Grubba) | |
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
03b1fe | 1997-09-06 | Per Hedbor | | if(mut->key != o)
fatal("Mutex unlock from wrong key %p != %p!\n",THIS_KEY->mut->key,o);
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | #endif
|
03b1fe | 1997-09-06 | Per Hedbor | | mut->key=0;
|
46d7bf | 1997-09-03 | Henrik Grubbström (Grubba) | | if (THIS_KEY->owner) {
free_object(THIS_KEY->owner);
THIS_KEY->owner=0;
}
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | THIS_KEY->mut=0;
THIS_KEY->initialized=0;
|
c11387 | 1997-09-15 | Henrik Grubbström (Grubba) | | co_signal(& mut->condition);
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | }
}
|
60d987 | 2000-03-23 | Fredrik Hübinette (Hubbe) | | #define THIS_COND ((COND_T *)(CURRENT_STORAGE))
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | void f_cond_wait(INT32 args)
{
COND_T *c;
|
1c3c3d | 2000-03-24 | Henrik Grubbström (Grubba) | | if(threads_disabled)
error("Cannot wait for conditions when threads are disabled!\n");
if(args > 1) {
pop_n_elems(args - 1);
args = 1;
}
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | |
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | c=THIS_COND;
|
deedf5 | 2000-03-25 | Fredrik Hübinette (Hubbe) | | if((args > 0) && !IS_ZERO(sp-1))
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | {
|
1c3c3d | 2000-03-24 | Henrik Grubbström (Grubba) | | struct object *key;
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | struct mutex_storage *mut;
if(sp[-1].type != T_OBJECT)
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | error("Bad argument 1 to condition->wait()\n");
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | |
key=sp[-1].u.object;
if(key->prog != mutex_key)
error("Bad argument 1 to condition->wait()\n");
|
368d4a | 1997-09-03 | Per Hedbor | |
|
1c3c3d | 2000-03-24 | Henrik Grubbström (Grubba) | | if (OB2KEY(key)->initialized) {
|
adb19b | 1999-06-30 | Fredrik Hübinette (Hubbe) | |
|
1c3c3d | 2000-03-24 | Henrik Grubbström (Grubba) | | mut = OB2KEY(key)->mut;
if(!mut)
error("Bad argument 1 to condition->wait()\n");
mut->key=0;
OB2KEY(key)->mut=0;
co_signal(& mut->condition);
|
88fe36 | 1997-09-04 | Per Hedbor | |
|
1c3c3d | 2000-03-24 | Henrik Grubbström (Grubba) | |
SWAP_OUT_CURRENT_THREAD();
co_wait(c, &interpreter_lock);
|
88fe36 | 1997-09-04 | Per Hedbor | |
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | |
|
1c3c3d | 2000-03-24 | Henrik Grubbström (Grubba) | | while(mut->key)
co_wait(& mut->condition, &interpreter_lock);
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | mut->key=key;
OB2KEY(key)->mut=mut;
|
1c3c3d | 2000-03-24 | Henrik Grubbström (Grubba) | |
SWAP_IN_CURRENT_THREAD();
pop_n_elems(args);
return;
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | }
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | }
|
1c3c3d | 2000-03-24 | Henrik Grubbström (Grubba) | |
SWAP_OUT_CURRENT_THREAD();
co_wait(c, &interpreter_lock);
SWAP_IN_CURRENT_THREAD();
pop_n_elems(args);
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | }
void f_cond_signal(INT32 args) { pop_n_elems(args); co_signal(THIS_COND); }
void f_cond_broadcast(INT32 args) { pop_n_elems(args); co_broadcast(THIS_COND); }
void init_cond_obj(struct object *o) { co_init(THIS_COND); }
void exit_cond_obj(struct object *o) { co_destroy(THIS_COND); }
|
a7fef4 | 1997-09-03 | Per Hedbor | | void f_thread_backtrace(INT32 args)
{
|
9b92d3 | 1999-01-31 | Fredrik Hübinette (Hubbe) | | struct thread_state *foo = THIS_THREAD;
struct thread_state *bar = OBJ2THREAD( thread_id );
|
a7fef4 | 1997-09-03 | Per Hedbor | | struct svalue *osp = sp;
pop_n_elems(args);
if(foo->sp)
{
SWAP_OUT_THREAD(bar);
SWAP_IN_THREAD(foo);
sp=osp;
f_backtrace(0);
osp=sp;
sp=foo->sp;
SWAP_OUT_THREAD(foo);
SWAP_IN_THREAD(bar);
sp=osp;
} else {
push_int(0);
f_allocate(1);
}
}
|
574088 | 1998-01-01 | Fredrik Hübinette (Hubbe) | | void f_thread_id_status(INT32 args)
{
pop_n_elems(args);
push_int(THIS_THREAD->status);
}
|
9a0d42 | 2000-02-06 | Martin Stjernholm | | void f_thread_id__sprintf (INT32 args)
{
pop_n_elems (args);
push_constant_text ("Thread.Thread(");
push_int (THIS_THREAD->id);
push_constant_text (")");
f_add (3);
}
|
574088 | 1998-01-01 | Fredrik Hübinette (Hubbe) | | static void f_thread_id_result(INT32 args)
{
struct thread_state *th=THIS_THREAD;
SWAP_OUT_CURRENT_THREAD();
while(th->status != THREAD_EXITED)
co_wait(&th->status_change, &interpreter_lock);
SWAP_IN_CURRENT_THREAD();
low_object_index_no_free(sp,
fp->current_object,
thread_id_result_variable);
sp++;
}
|
a7fef4 | 1997-09-03 | Per Hedbor | | void init_thread_obj(struct object *o)
{
|
9b92d3 | 1999-01-31 | Fredrik Hübinette (Hubbe) | | MEMSET(THIS_THREAD, 0, sizeof(struct thread_state));
|
574088 | 1998-01-01 | Fredrik Hübinette (Hubbe) | | THIS_THREAD->status=THREAD_NOT_STARTED;
co_init(& THIS_THREAD->status_change);
|
d86cd7 | 1998-08-24 | Marcus Comstedt | | THIS_THREAD->thread_local=NULL;
|
574088 | 1998-01-01 | Fredrik Hübinette (Hubbe) | | }
void exit_thread_obj(struct object *o)
{
|
d86cd7 | 1998-08-24 | Marcus Comstedt | | if(THIS_THREAD->thread_local != NULL) {
free_mapping(THIS_THREAD->thread_local);
THIS_THREAD->thread_local = NULL;
}
|
574088 | 1998-01-01 | Fredrik Hübinette (Hubbe) | | co_destroy(& THIS_THREAD->status_change);
|
b1f4eb | 1998-01-13 | Fredrik Hübinette (Hubbe) | | th_destroy(& THIS_THREAD->id);
|
a7fef4 | 1997-09-03 | Per Hedbor | | }
|
f6d017 | 1997-10-15 | Fredrik Hübinette (Hubbe) | | static void thread_was_marked(struct object *o)
{
|
9b92d3 | 1999-01-31 | Fredrik Hübinette (Hubbe) | | struct thread_state *tmp=THIS_THREAD;
|
d86cd7 | 1998-08-24 | Marcus Comstedt | | if(tmp->thread_local != NULL)
gc_mark_mapping_as_referenced(tmp->thread_local);
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
f6d017 | 1997-10-15 | Fredrik Hübinette (Hubbe) | | if(tmp->swapped)
{
|
469411 | 1997-11-07 | Fredrik Hübinette (Hubbe) | | debug_gc_xmark_svalues(tmp->evaluator_stack,tmp->sp-tmp->evaluator_stack-1,"idle thread stack");
|
f6d017 | 1997-10-15 | Fredrik Hübinette (Hubbe) | | }
#endif
|
d86cd7 | 1998-08-24 | Marcus Comstedt | | }
static void thread_was_checked(struct object *o)
{
|
9b92d3 | 1999-01-31 | Fredrik Hübinette (Hubbe) | | struct thread_state *tmp=THIS_THREAD;
|
d86cd7 | 1998-08-24 | Marcus Comstedt | | if(tmp->thread_local != NULL)
gc_check(tmp->thread_local);
}
void f_thread_local(INT32 args)
{
static INT32 thread_local_id = 0;
struct object *loc = clone_object(thread_local_prog,0);
((struct thread_local *)loc->storage)->id = thread_local_id++;
pop_n_elems(args);
push_object(loc);
}
void f_thread_local_get(INT32 args)
{
struct svalue key;
struct mapping *m;
|
60d987 | 2000-03-23 | Fredrik Hübinette (Hubbe) | | key.u.integer = ((struct thread_local *)CURRENT_STORAGE)->id;
|
d86cd7 | 1998-08-24 | Marcus Comstedt | | key.type = T_INT;
key.subtype = NUMBER_NUMBER;
pop_n_elems(args);
if(thread_id != NULL &&
|
9b92d3 | 1999-01-31 | Fredrik Hübinette (Hubbe) | | (m = OBJ2THREAD(thread_id)->thread_local) != NULL)
|
d86cd7 | 1998-08-24 | Marcus Comstedt | | mapping_index_no_free(sp++, m, &key);
else {
push_int(0);
sp[-1].subtype=NUMBER_UNDEFINED;
}
}
void f_thread_local_set(INT32 args)
{
struct svalue key;
struct mapping *m;
|
60d987 | 2000-03-23 | Fredrik Hübinette (Hubbe) | | key.u.integer = ((struct thread_local *)CURRENT_STORAGE)->id;
|
d86cd7 | 1998-08-24 | Marcus Comstedt | | key.type = T_INT;
key.subtype = NUMBER_NUMBER;
if(args>1)
pop_n_elems(args-1);
else if(args<1)
error("Too few arguments to thread_local->set()\n");
if(thread_id == NULL)
error("Trying to set thread_local without thread!\n");
|
9b92d3 | 1999-01-31 | Fredrik Hübinette (Hubbe) | | if((m = OBJ2THREAD(thread_id)->thread_local) == NULL)
m = OBJ2THREAD(thread_id)->thread_local =
|
d86cd7 | 1998-08-24 | Marcus Comstedt | | allocate_mapping(4);
mapping_insert(m, &key, &sp[-1]);
}
|
f6d017 | 1997-10-15 | Fredrik Hübinette (Hubbe) | |
|
9d322a | 2000-10-05 | Henrik Grubbström (Grubba) | |
static struct farmer {
struct farmer *neighbour;
void *field;
void (*harvest)(void *);
THREAD_T me;
COND_T harvest_moon;
} *farmers;
static MUTEX_T rosie;
static TH_RETURN_TYPE farm(void *_a)
{
struct farmer *me = (struct farmer *)_a;
do
{
me->harvest( me->field );
me->harvest = 0;
mt_lock( &rosie );
me->neighbour = farmers;
farmers = me;
while(!me->harvest) co_wait( &me->harvest_moon, &rosie );
mt_unlock( &rosie );
} while(1);
return NULL;
}
int th_num_idle_farmers(void)
{
int q = 0;
struct farmer *f = farmers;
while(f) { f = f->neighbour; q++; }
return q;
}
static int _num_farmers;
int th_num_farmers(void)
{
return _num_farmers;
}
static struct farmer *new_farmer(void (*fun)(void *), void *args)
{
struct farmer *me = malloc(sizeof(struct farmer));
if (!me) {
fatal("new_farmer(): Out of memory!\n");
}
dmalloc_accept_leak(me);
_num_farmers++;
me->neighbour = 0;
me->field = args;
me->harvest = fun;
co_init( &me->harvest_moon );
th_create_small(&me->me, farm, me);
return me;
}
void th_farm(void (*fun)(void *), void *here)
{
if(!fun) fatal("The farmers don't known how to handle empty fields\n");
mt_lock( &rosie );
if(farmers)
{
struct farmer *f = farmers;
farmers = f->neighbour;
mt_unlock( &rosie );
f->field = here;
f->harvest = fun;
co_signal( &f->harvest_moon );
return;
}
mt_unlock( &rosie );
new_farmer( fun, here );
}
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | void low_th_init(void)
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | {
|
e4419e | 1997-02-06 | Fredrik Hübinette (Hubbe) | | #ifdef SGI_SPROC_THREADS
#error /* Need to specify a filename */
us_cookie = usinit("");
#endif /* SGI_SPROC_THREADS */
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | THREADS_FPRINTF(0, (stderr, "THREADS_DISALLOW() Initializing threads.\n"));
|
fed8de | 1997-10-05 | Henrik Grubbström (Grubba) | |
#ifdef POSIX_THREADS
#ifdef HAVE_PTHREAD_INIT
pthread_init();
#endif /* HAVE_PTHREAD_INIT */
#endif /* POSIX_THREADS */
|
12ae2f | 1997-09-05 | Henrik Grubbström (Grubba) | | mt_init( & interpreter_lock);
|
e4419e | 1997-02-06 | Fredrik Hübinette (Hubbe) | | mt_lock( & interpreter_lock);
|
eac209 | 1998-02-27 | Marcus Comstedt | | mt_init( & thread_table_lock);
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | mt_init( & interleave_lock);
|
9d322a | 2000-10-05 | Henrik Grubbström (Grubba) | | mt_init( & rosie);
|
ef1e93 | 1998-03-26 | Henrik Grubbström (Grubba) | | co_init( & live_threads_change);
co_init( & threads_disabled_change);
|
eac209 | 1998-02-27 | Marcus Comstedt | | thread_table_init();
|
e4419e | 1997-02-06 | Fredrik Hübinette (Hubbe) | | #ifdef POSIX_THREADS
pthread_attr_init(&pattr);
#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
|
490887 | 1998-08-10 | Fredrik Hübinette (Hubbe) | | pthread_attr_setstacksize(&pattr, thread_stack_size);
|
e4419e | 1997-02-06 | Fredrik Hübinette (Hubbe) | | #endif
pthread_attr_setdetachstate(&pattr, PTHREAD_CREATE_DETACHED);
|
864d3c | 1998-01-29 | Fredrik Hübinette (Hubbe) | |
pthread_attr_init(&small_pattr);
#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
|
26cd94 | 1999-05-07 | Fredrik Hübinette (Hubbe) | | pthread_attr_setstacksize(&small_pattr, 4096*sizeof(char *));
|
864d3c | 1998-01-29 | Fredrik Hübinette (Hubbe) | | #endif
pthread_attr_setdetachstate(&small_pattr, PTHREAD_CREATE_DETACHED);
|
e4419e | 1997-02-06 | Fredrik Hübinette (Hubbe) | | #endif
|
a91ca0 | 1998-07-10 | Henrik Grubbström (Grubba) | | }
void th_init(void)
{
struct program *tmp;
INT32 mutex_key_offset;
|
e4419e | 1997-02-06 | Fredrik Hübinette (Hubbe) | | #ifdef UNIX_THREADS
|
45ee5d | 1999-02-10 | Fredrik Hübinette (Hubbe) | |
ADD_EFUN("thread_set_concurrency",f_thread_set_concurrency,tFunc(tInt,tVoid), OPT_SIDE_EFFECT);
|
e4419e | 1997-02-06 | Fredrik Hübinette (Hubbe) | | #endif
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | |
|
3f87be | 1999-12-14 | Martin Stjernholm | | START_NEW_PROGRAM_ID(THREAD_MUTEX_KEY);
|
90e978 | 1999-01-31 | Fredrik Hübinette (Hubbe) | | mutex_key_offset = ADD_STORAGE(struct key_storage);
|
46d7bf | 1997-09-03 | Henrik Grubbström (Grubba) | |
map_variable("_owner", "object", 0,
mutex_key_offset + OFFSETOF(key_storage, owner), T_OBJECT);
|
598892 | 1996-10-05 | Fredrik Hübinette (Hubbe) | | set_init_callback(init_mutex_key_obj);
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | set_exit_callback(exit_mutex_key_obj);
|
3f87be | 1999-12-14 | Martin Stjernholm | | mutex_key=new_program;
add_ref(mutex_key);
end_class("mutex_key", 0);
|
b1f4eb | 1998-01-13 | Fredrik Hübinette (Hubbe) | | mutex_key->flags|=PROGRAM_DESTRUCT_IMMEDIATE;
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
f839fa | 1997-02-28 | Fredrik Hübinette (Hubbe) | | if(!mutex_key)
fatal("Failed to initialize mutex_key program!\n");
|
e45f66 | 1998-03-20 | Fredrik Hübinette (Hubbe) | | #endif
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | |
|
3f87be | 1999-12-14 | Martin Stjernholm | | START_NEW_PROGRAM_ID(THREAD_MUTEX);
|
52e4c6 | 1999-12-13 | Martin Stjernholm | | ADD_STORAGE(struct mutex_storage);
|
3f87be | 1999-12-14 | Martin Stjernholm | | ADD_FUNCTION("lock",f_mutex_lock,
tFunc(tOr(tInt02,tVoid),tObjIs_THREAD_MUTEX_KEY),0);
|
52e4c6 | 1999-12-13 | Martin Stjernholm | |
|
3f87be | 1999-12-14 | Martin Stjernholm | | ADD_FUNCTION("trylock",f_mutex_trylock,
tFunc(tOr(tInt02,tVoid),tObjIs_THREAD_MUTEX_KEY),0);
|
52e4c6 | 1999-12-13 | Martin Stjernholm | | set_init_callback(init_mutex_obj);
set_exit_callback(exit_mutex_obj);
end_class("mutex", 0);
|
3f87be | 1999-12-14 | Martin Stjernholm | | START_NEW_PROGRAM_ID(THREAD_CONDITION);
|
90e978 | 1999-01-31 | Fredrik Hübinette (Hubbe) | | ADD_STORAGE(COND_T);
|
52e4c6 | 1999-12-13 | Martin Stjernholm | |
|
3f87be | 1999-12-14 | Martin Stjernholm | | ADD_FUNCTION("wait",f_cond_wait,
tFunc(tOr(tVoid,tObjIs_THREAD_MUTEX_KEY),tVoid),0);
|
45ee5d | 1999-02-10 | Fredrik Hübinette (Hubbe) | |
|
b93e6e | 1999-06-19 | Fredrik Hübinette (Hubbe) | | ADD_FUNCTION("signal",f_cond_signal,tFunc(tNone,tVoid),0);
|
45ee5d | 1999-02-10 | Fredrik Hübinette (Hubbe) | |
|
b93e6e | 1999-06-19 | Fredrik Hübinette (Hubbe) | | ADD_FUNCTION("broadcast",f_cond_broadcast,tFunc(tNone,tVoid),0);
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | set_init_callback(init_cond_obj);
set_exit_callback(exit_cond_obj);
|
b98eb3 | 1997-02-11 | Henrik Grubbström (Grubba) | | end_class("condition", 0);
|
de413f | 1998-03-26 | Per Hedbor | |
{
struct program *tmp;
|
3f87be | 1999-12-14 | Martin Stjernholm | | START_NEW_PROGRAM_ID(THREAD_DISABLE_THREADS);
|
de413f | 1998-03-26 | Per Hedbor | | set_init_callback(init_threads_disable);
set_exit_callback(exit_threads_disable);
|
3f87be | 1999-12-14 | Martin Stjernholm | | tmp = new_program;
add_ref(tmp);
end_class("threads_disabled", 0);
|
de413f | 1998-03-26 | Per Hedbor | | tmp->flags|=PROGRAM_DESTRUCT_IMMEDIATE;
add_global_program("_disable_threads", tmp);
|
56a696 | 1998-04-05 | Fredrik Hübinette (Hubbe) | | free_program(tmp);
|
de413f | 1998-03-26 | Per Hedbor | | }
|
6d1a5e | 1996-10-07 | Fredrik Hübinette (Hubbe) | |
|
3f87be | 1999-12-14 | Martin Stjernholm | | START_NEW_PROGRAM_ID(THREAD_LOCAL);
|
90e978 | 1999-01-31 | Fredrik Hübinette (Hubbe) | | ADD_STORAGE(struct thread_local);
|
45ee5d | 1999-02-10 | Fredrik Hübinette (Hubbe) | |
|
b93e6e | 1999-06-19 | Fredrik Hübinette (Hubbe) | | ADD_FUNCTION("get",f_thread_local_get,tFunc(tNone,tMix),0);
|
45ee5d | 1999-02-10 | Fredrik Hübinette (Hubbe) | |
ADD_FUNCTION("set",f_thread_local_set,tFunc(tMix,tMix),0);
|
3f87be | 1999-12-14 | Martin Stjernholm | | thread_local_prog=new_program;
add_ref(thread_local_prog);
end_class("thread_local", 0);
|
d86cd7 | 1998-08-24 | Marcus Comstedt | | if(!thread_local_prog)
fatal("Failed to initialize thread_local program!\n");
|
3f87be | 1999-12-14 | Martin Stjernholm | |
ADD_EFUN("thread_local",f_thread_local,
tFunc(tNone,tObjIs_THREAD_LOCAL),
OPT_SIDE_EFFECT);
|
d86cd7 | 1998-08-24 | Marcus Comstedt | |
|
3f87be | 1999-12-14 | Martin Stjernholm | | START_NEW_PROGRAM_ID(THREAD_ID);
|
9b92d3 | 1999-01-31 | Fredrik Hübinette (Hubbe) | | thread_storage_offset=ADD_STORAGE(struct thread_state);
|
574088 | 1998-01-01 | Fredrik Hübinette (Hubbe) | | thread_id_result_variable=simple_add_variable("result","mixed",0);
|
45ee5d | 1999-02-10 | Fredrik Hübinette (Hubbe) | |
|
b93e6e | 1999-06-19 | Fredrik Hübinette (Hubbe) | | ADD_FUNCTION("backtrace",f_thread_backtrace,tFunc(tNone,tArray),0);
|
45ee5d | 1999-02-10 | Fredrik Hübinette (Hubbe) | |
|
b93e6e | 1999-06-19 | Fredrik Hübinette (Hubbe) | | ADD_FUNCTION("wait",f_thread_id_result,tFunc(tNone,tMix),0);
|
45ee5d | 1999-02-10 | Fredrik Hübinette (Hubbe) | |
|
b93e6e | 1999-06-19 | Fredrik Hübinette (Hubbe) | | ADD_FUNCTION("status",f_thread_id_status,tFunc(tNone,tInt),0);
|
9a0d42 | 2000-02-06 | Martin Stjernholm | | ADD_FUNCTION("_sprintf",f_thread_id__sprintf,tFunc(tNone,tStr),0);
|
f6d017 | 1997-10-15 | Fredrik Hübinette (Hubbe) | | set_gc_mark_callback(thread_was_marked);
|
d86cd7 | 1998-08-24 | Marcus Comstedt | | set_gc_check_callback(thread_was_checked);
|
a7fef4 | 1997-09-03 | Per Hedbor | | set_init_callback(init_thread_obj);
|
a2db6b | 1998-01-02 | Fredrik Hübinette (Hubbe) | | set_exit_callback(exit_thread_obj);
|
3f87be | 1999-12-14 | Martin Stjernholm | | thread_id_prog=new_program;
add_ref(thread_id_prog);
end_class("thread_id", 0);
ADD_EFUN("thread_create",f_thread_create,
tFuncV(tNone,tMixed,tObjIs_THREAD_ID),
OPT_SIDE_EFFECT);
ADD_EFUN("this_thread",f_this_thread,
tFunc(tNone,tObjIs_THREAD_ID),
OPT_EXTERNAL_DEPEND);
ADD_EFUN("all_threads",f_all_threads,
tFunc(tNone,tArr(tObjIs_THREAD_ID)),
OPT_EXTERNAL_DEPEND);
|
52e4c6 | 1999-12-13 | Martin Stjernholm | |
|
5d2f12 | 1998-08-27 | Henrik Grubbström (Grubba) | |
add_integer_constant("THREAD_NOT_STARTED", THREAD_NOT_STARTED, 0);
add_integer_constant("THREAD_RUNNING", THREAD_RUNNING, 0);
add_integer_constant("THREAD_EXITED", THREAD_EXITED, 0);
|
f839fa | 1997-02-28 | Fredrik Hübinette (Hubbe) | | if(!mutex_key)
fatal("Failed to initialize thread program!\n");
|
6d1a5e | 1996-10-07 | Fredrik Hübinette (Hubbe) | |
|
e70975 | 1997-03-12 | Fredrik Hübinette (Hubbe) | | thread_id=clone_object(thread_id_prog,0);
|
9b92d3 | 1999-01-31 | Fredrik Hübinette (Hubbe) | | SWAP_OUT_THREAD(OBJ2THREAD(thread_id));
OBJ2THREAD(thread_id)->swapped=0;
OBJ2THREAD(thread_id)->id=th_self();
|
eac209 | 1998-02-27 | Marcus Comstedt | | thread_table_insert(thread_id);
|
6d1a5e | 1996-10-07 | Fredrik Hübinette (Hubbe) | | }
|
be478c | 1997-08-30 | Henrik Grubbström (Grubba) | | void th_cleanup(void)
|
6d1a5e | 1996-10-07 | Fredrik Hübinette (Hubbe) | | {
|
c3b995 | 2000-02-15 | Henrik Grubbström (Grubba) | | if(thread_id)
{
|
9d322a | 2000-10-05 | Henrik Grubbström (Grubba) | | thread_table_delete(thread_id);
|
c3b995 | 2000-02-15 | Henrik Grubbström (Grubba) | | destruct(thread_id);
free_object(thread_id);
thread_id=0;
}
|
6d1a5e | 1996-10-07 | Fredrik Hübinette (Hubbe) | | if(mutex_key)
{
free_program(mutex_key);
mutex_key=0;
}
|
d86cd7 | 1998-08-24 | Marcus Comstedt | | if(thread_local_prog)
{
free_program(thread_local_prog);
thread_local_prog=0;
}
|
6d1a5e | 1996-10-07 | Fredrik Hübinette (Hubbe) | | if(thread_id_prog)
{
free_program(thread_id_prog);
thread_id_prog=0;
}
|
07513e | 1996-10-04 | Fredrik Hübinette (Hubbe) | | }
#endif
|