summaryrefslogtreecommitdiff
path: root/src/common/thread.c
blob: d680d034742937e15abc437491d6298b7b5dd7b2 (plain) (blame)
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
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
//
// Basic Threading abstraction (for pthread / win32 based systems)
//
// Author: Florian Wilkemeyer <fw@f-ws.de>
//
// Copyright (c) rAthena Project (www.rathena.org) - Licensed under GNU GPL
// For more information, see LICENCE in the main folder

#define HERCULES_CORE

#include "thread.h"

#include "../common/sysinfo.h" // sysinfo->getpagesize()
#include "../common/cbasetypes.h"
#include "../common/malloc.h"
#include "../common/showmsg.h"

#ifdef WIN32
#	include "../common/winapi.h"
#	define __thread __declspec( thread )
#else
#	include <pthread.h>
#	include <sched.h>
#	include <signal.h>
#	include <stdlib.h>
#	include <string.h>
#	include <unistd.h>
#endif

// When Compiling using MSC (on win32..) we know we have support in any case!
#ifdef _MSC_VER
#define HAS_TLS
#endif

#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
};


#ifdef HAS_TLS
__thread int g_rathread_ID = -1;
#endif


///
/// 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 represents the main thread
#ifdef HAS_TLS
	g_rathread_ID = 0;
#endif
	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?
	// Shouldn't 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) {
	// Preserve handle->myID and handle->hThread, set everything else to its default value
	handle->param = NULL;
	handle->proc = NULL;
	handle->prio = RAT_PRIO_NORMAL;
}//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.
#ifdef HAS_TLS
	g_rathread_ID = ((rAthread*)p)->myID;
#endif

#ifndef WIN32
	// When using posix threads
	// the threads inherits the Signal mask from the thread which spawned
	// this thread
	// so we've to block everything we don't 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 % sysinfo->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 resources assoc. with this thread.
		pthread_join( handle->hThread, NULL );
		
		// Tell our manager to release resources ;)
		rat_thread_terminated(handle);
	}
#endif
}//end: rathread_destroy()

rAthread *rathread_self() {
#ifdef HAS_TLS
	rAthread *handle = &l_threads[g_rathread_ID];
	
	if(handle->proc != NULL) // entry point set, so its used!
		return handle;
#else
	// .. so no tls means we have to search the thread by its api-handle ..
	int i;

	#ifdef WIN32
		HANDLE hSelf;
		hSelf = GetCurrent = GetCurrentThread();
	#else
		pthread_t hSelf;
		hSelf = pthread_self();
	#endif
	
	for(i = 0; i < RA_THREADS_MAX; i++){
		if(l_threads[i].hThread == hSelf  &&  l_threads[i].proc != NULL)
			return &l_threads[i];
	}
	
#endif
		
	return NULL;
}//end: rathread_self()


int rathread_get_tid(){

#ifdef HAS_TLS
	return g_rathread_ID;
#else
	// TODO
	#ifdef WIN32
		return (int)GetCurrentThreadId();
	#else
		return (intptr_t)pthread_self();
	#endif
	
#endif
	
}//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()