1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
  
30
  
31
  
32
  
33
  
34
  
35
  
36
  
37
  
38
  
39
  
40
  
41
  
42
  
43
  
44
  
45
  
46
  
47
  
48
  
49
  
50
  
51
  
52
  
53
  
54
  
55
  
56
  
57
  
58
  
59
  
60
  
61
  
62
  
63
  
64
  
65
  
66
  
67
  
68
  
69
  
70
  
71
  
72
  
73
  
74
  
75
  
76
  
77
  
78
  
79
  
80
  
81
  
82
  
83
  
84
  
85
  
86
  
87
  
88
  
89
  
90
  
91
  
92
  
93
  
94
  
95
  
96
  
97
  
98
  
99
  
100
  
101
  
102
  
103
  
104
  
105
  
106
  
107
  
108
  
109
  
110
  
111
  
112
  
#ifndef THREADS_H 
#define THREADS_H 
 
#include "machine.h" 
#include "interpret.h" 
#include "error.h" 
 
#ifdef _REENTRANT 
 
#ifdef HAVE_PTHREAD_H 
#include <pthread.h> 
#undef HAVE_PTHREAD_H 
#endif 
 
extern int num_threads; 
 
#define MUTEX_T pthread_mutex_t 
#define mt_init(X) pthread_mutex_init((X),0) 
#define mt_lock(X) pthread_mutex_lock(X) 
#define mt_trylock(X) pthread_mutex_trylock(X) 
#define mt_unlock(X) pthread_mutex_unlock(X) 
#define mt_destroy(X) pthread_mutex_destroy(X) 
 
extern MUTEX_T interpreter_lock, compiler_lock; 
 
#define th_create(ID,fun,arg) pthread_create(ID,&pattr,fun,arg) 
#define th_exit(foo) pthread_exit(foo) 
 
#define COND_T pthread_cond_t 
#define co_init(X) pthread_cond_init((X), 0) 
#define co_wait(COND, MUTEX) pthread_cond_wait((COND), (MUTEX)) 
#define co_signal(X) pthread_cond_signal(X) 
#define co_broadcast(X) pthread_cond_broadcast(X) 
#define co_destroy(X) pthread_cond_destroy(X) 
 
struct svalue; 
struct frame; 
 
struct thread_state { 
  int swapped; 
  struct svalue *sp,*evaluator_stack; 
  struct svalue **mark_sp,**mark_stack; 
  struct frame *fp; 
  int evaluator_stack_malloced; 
  int mark_stack_malloced; 
  JMP_BUF *recoveries; 
}; 
 
#define THREADS_ALLOW() \ 
  do {\ 
     struct thread_state _tmp; \ 
     _tmp.swapped=0; \ 
     if(num_threads > 1 && !threads_disabled) { \ 
       _tmp.swapped=1; \ 
       _tmp.sp=sp; \ 
       _tmp.evaluator_stack=evaluator_stack; \ 
       _tmp.mark_sp=mark_sp; \ 
       _tmp.mark_stack=mark_stack; \ 
       _tmp.fp=fp; \ 
       _tmp.recoveries=recoveries; \ 
       _tmp.evaluator_stack_malloced=evaluator_stack_malloced; \ 
       _tmp.mark_stack_malloced=mark_stack_malloced; \ 
       mt_unlock(& interpreter_lock); \ 
     } 
 
#define THREADS_DISALLOW() \ 
     if(_tmp.swapped) { \ 
       mt_lock(& interpreter_lock); \ 
       sp=_tmp.sp; \ 
       evaluator_stack=_tmp.evaluator_stack; \ 
       mark_sp=_tmp.mark_sp; \ 
       mark_stack=_tmp.mark_stack; \ 
       fp=_tmp.fp; \ 
       recoveries=_tmp.recoveries; \ 
       evaluator_stack_malloced=_tmp.evaluator_stack_malloced; \ 
       mark_stack_malloced=_tmp.mark_stack_malloced; \ 
     } \ 
   } while(0) 
 
/* Prototypes begin here */ 
void *new_thread_func(void * data); 
void f_thread_create(INT32 args); 
void th_init(); 
void f_mutex_lock(INT32 args); 
void f_mutex_trylock(INT32 args); 
void init_mutex_obj(struct object *o); 
void exit_mutex_obj(struct object *o); 
void init_mutex_key_obj(struct object *o); 
void exit_mutex_key_obj(struct object *o); 
void f_cond_wait(INT32 args); 
void f_cond_signal(INT32 args); 
void f_cond_broadcast(INT32 args); 
void init_cond_obj(struct object *o); 
void exit_cond_obj(struct object *o); 
void th_init_programs(); 
/* Prototypes end here */ 
 
#else 
#define mt_init(X) 
#define mt_lock(X) 
#define mt_unlock(X) 
#define THREADS_ALLOW() 
#define THREADS_DISALLOW() 
#define th_init() 
#define th_init_programs() 
#endif 
 
 
extern int threads_disabled; 
#endif