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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
|
#ifdef WIN32
#include "../common/winapi.h"
#define getpagesize() 4096 // @TODO: implement this properly (GetSystemInfo .. dwPageSize..). (Atm as on all supported win platforms its 4k its static.)
#define __thread __declspec( thread )
#else
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <pthread.h>
#include <sched.h>
#endif
#include "cbasetypes.h"
#include "malloc.h"
#include "showmsg.h"
#include "thread.h"
#define RA_THREADS_MAX 64
struct rAthread {
unsigned int myID;
RATHREAD_PRIO prio;
rAthreadProc proc;
void *param;
#ifdef WIN32
HANDLE hThread;
#else
pthread_t hThread;
#endif
};
__thread int g_rathread_ID = -1;
///
/// Subystem Code
///
static struct rAthread l_threads[RA_THREADS_MAX];
void rathread_init(){
register unsigned int i;
memset(&l_threads, 0x00, RA_THREADS_MAX * sizeof(struct rAthread) );
for(i = 0; i < RA_THREADS_MAX; i++){
l_threads[i].myID = i;
}
// now lets init thread id 0, which represnts the main thread
g_rathread_ID = 0;
l_threads[0].prio = RAT_PRIO_NORMAL;
l_threads[0].proc = (rAthreadProc)0xDEADCAFE;
}//end: rathread_init()
void rathread_final(){
register unsigned int i;
// Unterminated Threads Left?
// Should'nt happen ..
// Kill 'em all!
//
for(i = 1; i < RA_THREADS_MAX; i++){
if(l_threads[i].proc != NULL){
ShowWarning("rAthread_final: unterminated Thread (tid %u entryPoint %p) - forcing to terminate (kill)\n", i, l_threads[i].proc);
rathread_destroy(&l_threads[i]);
}
}
}//end: rathread_final()
// gets called whenever a thread terminated ..
static void rat_thread_terminated( rAthread handle ){
int id_backup = handle->myID;
// Simply set all members to 0 (except the id)
memset(handle, 0x00, sizeof(struct rAthread));
handle->myID = id_backup; // done ;)
}//end: rat_thread_terminated()
#ifdef WIN32
DWORD WINAPI _raThreadMainRedirector(LPVOID p){
#else
static void *_raThreadMainRedirector( void *p ){
sigset_t set; // on Posix Thread platforms
#endif
void *ret;
// Update myID @ TLS to right id.
g_rathread_ID = ((rAthread)p)->myID;
#ifndef WIN32
// When using posix threads
// the threads inherits the Signal mask from the thread which's spawned
// this thread
// so we've to block everything we dont care about.
sigemptyset(&set);
sigaddset(&set, SIGINT);
sigaddset(&set, SIGTERM);
sigaddset(&set, SIGPIPE);
pthread_sigmask(SIG_BLOCK, &set, NULL);
#endif
ret = ((rAthread)p)->proc( ((rAthread)p)->param ) ;
#ifdef WIN32
CloseHandle( ((rAthread)p)->hThread );
#endif
rat_thread_terminated( (rAthread)p );
#ifdef WIN32
return (DWORD)ret;
#else
return ret;
#endif
}//end: _raThreadMainRedirector()
///
/// API Level
///
rAthread rathread_create( rAthreadProc entryPoint, void *param ){
return rathread_createEx( entryPoint, param, (1<<23) /*8MB*/, RAT_PRIO_NORMAL );
}//end: rathread_create()
rAthread rathread_createEx( rAthreadProc entryPoint, void *param, size_t szStack, RATHREAD_PRIO prio ){
#ifndef WIN32
pthread_attr_t attr;
#endif
size_t tmp;
unsigned int i;
rAthread handle = NULL;
// given stacksize aligned to systems pagesize?
tmp = szStack % getpagesize();
if(tmp != 0)
szStack += tmp;
// Get a free Thread Slot.
for(i = 0; i < RA_THREADS_MAX; i++){
if(l_threads[i].proc == NULL){
handle = &l_threads[i];
break;
}
}
if(handle == NULL){
ShowError("rAthread: cannot create new thread (entryPoint: %p) - no free thread slot found!", entryPoint);
return NULL;
}
handle->proc = entryPoint;
handle->param = param;
#ifdef WIN32
handle->hThread = CreateThread(NULL, szStack, _raThreadMainRedirector, (void*)handle, 0, NULL);
#else
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, szStack);
if(pthread_create(&handle->hThread, &attr, _raThreadMainRedirector, (void*)handle) != 0){
handle->proc = NULL;
handle->param = NULL;
return NULL;
}
pthread_attr_destroy(&attr);
#endif
rathread_prio_set( handle, prio );
return handle;
}//end: rathread_createEx
void rathread_destroy ( rAthread handle ){
#ifdef WIN32
if( TerminateThread(handle->hThread, 0) != FALSE){
CloseHandle(handle->hThread);
rat_thread_terminated(handle);
}
#else
if( pthread_cancel( handle->hThread ) == 0){
// We have to join it, otherwise pthread wont re-cycle its internal ressources assoc. with this thread.
//
pthread_join( handle->hThread, NULL );
// Tell our manager to release ressources ;)
rat_thread_terminated(handle);
}
#endif
}//end: rathread_destroy()
rAthread rathread_self( ){
rAthread handle = &l_threads[g_rathread_ID];
if(handle->proc != NULL) // entry point set, so its used!
return handle;
return NULL;
}//end: rathread_self()
int rathread_get_tid(){
return g_rathread_ID;
}//end: rathread_get_tid()
bool rathread_wait( rAthread handle, void* *out_exitCode ){
// Hint:
// no thread data cleanup routine call here!
// its managed by the callProxy itself..
//
#ifdef WIN32
WaitForSingleObject(handle->hThread, INFINITE);
return true;
#else
if(pthread_join(handle->hThread, out_exitCode) == 0)
return true;
return false;
#endif
}//end: rathread_wait()
void rathread_prio_set( rAthread handle, RATHREAD_PRIO prio ){
handle->prio = RAT_PRIO_NORMAL;
//@TODO
}//end: rathread_prio_set()
RATHREAD_PRIO rathread_prio_get( rAthread handle){
return handle->prio;
}//end: rathread_prio_get()
void rathread_yield(){
#ifdef WIN32
SwitchToThread();
#else
sched_yield();
#endif
}//end: rathread_yield()
|
