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
  
/* 
 * $Id: threads.h,v 1.119 2002/09/11 14:03:50 marcus Exp $ 
 */ 
#ifndef THREADS_H 
#define THREADS_H 
 
#include "machine.h" 
#include "object.h" 
#include "pike_error.h" 
#include "interpret.h" 
#include "pike_threadlib.h" 
 
#ifdef PIKE_THREADS 
 
struct svalue; 
struct pike_frame; 
 
extern PIKE_MUTEX_T interleave_lock; 
 
#define THREAD_NOT_STARTED -1 
#define THREAD_RUNNING 0 
#define THREAD_EXITED 1 
 
struct thread_state { 
  struct Pike_interpreter state; 
  char swapped; 
  char status; 
  COND_T status_change; 
  THREAD_T id; 
  struct mapping *thread_local; 
  struct thread_state *hashlink, **backlink; 
#ifdef PROFILING 
#if SIZEOF_LONG_LONG - 0 != 0 
  long long time_base; 
#else 
  long time_base; 
#endif 
#endif /* PROFILING */ 
}; 
 
 
/* Prototypes begin here */ 
int low_nt_create_thread(unsigned stack_size, 
                         unsigned (TH_STDCALL *func)(void *), 
                         void *arg, 
                         unsigned *id); 
struct thread_starter; 
struct thread_local; 
void low_init_threads_disable(void); 
void init_threads_disable(struct object *o); 
void exit_threads_disable(struct object *o); 
void init_interleave_mutex(IMUTEX_T *im); 
void exit_interleave_mutex(IMUTEX_T *im); 
void thread_table_init(void); 
unsigned INT32 thread_table_hash(THREAD_T *tid); 
PMOD_EXPORT void thread_table_insert(struct object *o); 
PMOD_EXPORT void thread_table_delete(struct object *o); 
PMOD_EXPORT struct thread_state *thread_state_for_id(THREAD_T tid); 
PMOD_EXPORT struct object *thread_for_id(THREAD_T tid); 
PMOD_EXPORT void f_all_threads(INT32 args); 
PMOD_EXPORT int count_pike_threads(void); 
TH_RETURN_TYPE new_thread_func(void * data); 
void f_thread_create(INT32 args); 
void f_thread_set_concurrency(INT32 args); 
PMOD_EXPORT void f_this_thread(INT32 args); 
struct mutex_storage; 
struct key_storage; 
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 f_thread_backtrace(INT32 args); 
void f_thread_id_status(INT32 args); 
void init_thread_obj(struct object *o); 
void exit_thread_obj(struct object *o); 
PMOD_EXPORT void f_thread_local(INT32 args); 
void f_thread_local_get(INT32 args); 
void f_thread_local_set(INT32 args); 
void low_th_init(void); 
void th_init(void); 
void th_cleanup(void); 
int th_num_idle_farmers(void); 
int th_num_farmers(void); 
PMOD_EXPORT void th_farm(void (*fun)(void *), void *here); 
/* Prototypes end here */ 
 
#endif 
 
 
/* for compatibility */ 
#include "interpret.h" 
 
#endif /* THREADS_H */