2 * Empire - A multi-player, client/server Internet based war game.
3 * Copyright (C) 1986-2006, Dave Pare, Jeff Bailey, Thomas Ruschak,
4 * Ken Stevens, Steve McClure
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 * See files README, COPYING and CREDITS in the root of the source
23 * tree for related information and legal notices. It is expected
24 * that future projects/authors will amend these files as needed.
28 * ntthread.c: Interface from Empire threads to Windows NT threads
30 * Known contributors to this file:
33 * Ron Koenderink, 2004-2005
37 * EMPTHREADs for Windows NT.
39 * Actually, threads for any Win32 platform, like Win95, Win98, WinCE,
40 * and whatever other toy OSs are in our future from Microsoft.
42 * WIN32 has a full pre-emptive threading environment. But Empire can
43 * not handle pre-emptive threading. Thus, we will use the threads,
44 * but limit the preemption using a Mutex semaphore.
51 #include <sys/types.h>
56 #include "empthread.h"
57 #include "prototypes.h"
65 #define loc_MIN_THREAD_STACK 16384
67 /************************
72 /* The thread name, passed in at create time. */
74 /* The thread description, passed in at create time. */
77 /* True if this is the main line, and not a real thread. */
80 /* The user data passed in at create time. */
83 /* True if this thread has been killed. */
86 /* The entry function for the thread. */
87 void (*pfnEntry) (void *);
89 /* The system thread ID. */
90 unsigned long ulThreadID;
92 /* An Event sem that the thread will wait/sleep on. */
97 /************************
104 /* An exclusion semaphore for this sem. */
106 /* An Event sem that the thread(s) will sleep on. */
109 /* The count variable */
113 /* This is the thread exclusion/non-premption mutex. */
114 /* The running thread has this MUTEX, and all others are */
115 /* either blocked on it, or waiting for some OS response. */
116 static HANDLE hThreadMutex;
118 /* This is the thread startup event sem. */
119 /* We use this to lockstep when we are starting up threads. */
120 static HANDLE hThreadStartEvent;
122 /* This is an event used to wakeup the main thread */
123 /* to start the shutdown sequence. */
124 static HANDLE hShutdownEvent;
126 /* The Thread Local Storage index. We store the pThread pointer */
127 /* for each thread at this index. */
128 static DWORD dwTLSIndex;
130 /* The current running thread. */
131 static empth_t *pCurThread;
134 static unsigned long ulTickAtStart;
136 /* Pointer out to global context. "player". */
137 /* From empth_init parameter. */
138 static void **ppvUserData;
140 /* Global flags. From empth_init parameter. */
141 static int global_flags;
144 /************************
147 * Print out the current thread's status??
150 loc_debug(const char *pszFmt, ...)
153 unsigned long ulCurTick;
154 unsigned long ulRunTick;
155 unsigned long ulMs, ulSec, ulMin, ulHr;
156 empth_t *pThread = TlsGetValue(dwTLSIndex);
159 if ((global_flags & EMPTH_PRINT) != 0) {
161 /* Ticks are in milliseconds */
162 ulCurTick = GetTickCount();
164 ulRunTick = ulCurTick - ulTickAtStart;
165 ulMs = ulRunTick % 1000L;
166 ulSec = (ulRunTick / 1000L) % 60L;
167 ulMin = (ulRunTick / (60L * 1000L)) % 60L;
168 ulHr = (ulRunTick / (60L * 60L * 1000L));
170 va_start(vaList, pszFmt);
171 vsprintf(buf, pszFmt, vaList);
175 printf("%ld:%02ld:%02ld.%03ld %17s: %s\n",
176 ulHr, ulMin, ulSec, ulMs, pThread->szName, buf);
178 printf("%ld:%02ld:%02ld.%03ld %17s: %s\n",
179 ulHr, ulMin, ulSec, ulMs, "UNKNOWN", buf);
185 /************************
190 loc_FreeThreadInfo(empth_t *pThread)
193 if (pThread->hThreadEvent)
194 CloseHandle(pThread->hThreadEvent);
195 memset(pThread, 0, sizeof(*pThread));
200 /************************
203 * This thread wants to run.
204 * When this function returns, the globals are set to this thread
205 * info, and the thread owns the MUTEX sem.
208 loc_RunThisThread(void)
210 empth_t *pThread = TlsGetValue(dwTLSIndex);
212 if (pThread->bKilled) {
213 if (!pThread->bMainThread) {
214 TlsSetValue(dwTLSIndex, NULL);
215 loc_FreeThreadInfo(pThread);
220 /* Get the MUTEX semaphore, wait forever. */
221 WaitForSingleObject(hThreadMutex, INFINITE);
224 /* Set the globals to this thread. */
225 *ppvUserData = pThread->pvUserData;
227 pCurThread = pThread;
229 /* Hmm, a problem, eh? */
230 logerror("RunThisThread, someone already running.");
234 /************************
235 * loc_BlockThisThread
237 * This thread was running. It no longer wants to.
240 loc_BlockThisThread(void)
242 empth_t *pThread = TlsGetValue(dwTLSIndex);
244 if (pCurThread == pThread) {
245 /* Reset the globals back to original */
250 /* Release the MUTEX */
251 ReleaseMutex(hThreadMutex);
253 /* Hmm, this thread was not the running one. */
254 logerror("BlockThisThread, not running.");
258 /************************
261 * Ctrl-C, Ctrl-Break, Window-Closure, User-Logging-Off or
262 * System-Shutdown will initiate a shutdown.
263 * This is done by calling empth_request_shutdown()
266 loc_Exit_Handler(DWORD fdwCtrlType)
271 case CTRL_CLOSE_EVENT:
272 case CTRL_BREAK_EVENT:
273 case CTRL_LOGOFF_EVENT:
274 case CTRL_SHUTDOWN_EVENT:
275 empth_request_shutdown();
282 /************************
283 * empth_request_shutdown
285 * This wakes up the main thread so shutdown can proceed.
286 * This is done by signalling hShutdownEvent.
289 empth_request_shutdown(void)
291 SetEvent(hShutdownEvent);
294 /************************
295 * loc_BlockMainThread
297 * This blocks up the main thread. loc_WakeupMainThread() is used
298 * wakeup the main so shutdown can proceed.
301 loc_BlockMainThread(void)
303 /* Get the MUTEX semaphore, wait the number of MS */
304 WaitForSingleObject(hShutdownEvent, INFINITE);
307 /************************
310 * This is the main line of each thread.
311 * This is really a static local func....
314 empth_threadMain(void *pvData)
318 empth_t *pThread = pvData;
324 /* Store pThread on this thread. */
325 TlsSetValue(dwTLSIndex, pvData);
327 /* Get the ID of the thread. */
328 pThread->ulThreadID = GetCurrentThreadId();
330 /* Signal that the thread has started. */
331 SetEvent(hThreadStartEvent);
333 /* seed the rand() function */
335 srand(now ^ (unsigned int)pThread);
337 /* Switch to this thread context */
340 /* Run the thread. */
341 if (pThread->pfnEntry)
342 pThread->pfnEntry(pThread->pvUserData);
344 /* Kill the thread. */
348 /************************
351 * Initialize the thread environment.
353 * This is called from the program main line.
356 empth_init(void **ctx_ptr, int flags)
358 empth_t *pThread = NULL;
360 ulTickAtStart = GetTickCount();
361 ppvUserData = ctx_ptr;
362 global_flags = flags;
363 dwTLSIndex = TlsAlloc();
365 /* Create the thread mutex sem. */
366 /* Initally unowned. */
367 hThreadMutex = CreateMutex(NULL, FALSE, NULL);
369 logerror("Failed to create mutex %lu", GetLastError());
373 /* Create the thread start event sem. */
374 /* Automatic state reset. */
375 hThreadStartEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
376 if (!hThreadStartEvent) {
377 logerror("Failed to create start event %lu", GetLastError());
381 /* Create the shutdown event for the main thread. */
383 hShutdownEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
384 if (!hShutdownEvent) {
385 logerror("Failed to create shutdown event %lu", GetLastError());
388 SetConsoleCtrlHandler((PHANDLER_ROUTINE)loc_Exit_Handler, TRUE);
390 /* Create the global Thread context. */
391 pThread = malloc(sizeof(*pThread));
393 logerror("not enough memory to create main thread.");
396 memset(pThread, 0, sizeof(*pThread));
398 strncpy(pThread->szName, "Main", sizeof(pThread->szName) - 1);
399 strncpy(pThread->szDesc, "The main process",
400 sizeof(pThread->szDesc) - 1);
401 pThread->ulThreadID = GetCurrentThreadId();
402 pThread->bMainThread = TRUE;
404 TlsSetValue(dwTLSIndex, pThread);
406 /* Make this the running thread. */
409 logerror("NT pthreads initialized");
414 /************************
417 * Create a new thread.
419 * prio - priority, not particularly useful in our context.
420 * entry - entry point function for thread.
422 * flags - debug control.
423 * LWP_STACKCHECK - not needed
424 * name - name of the thread, for debug.
425 * desc - description of thread, for debug.
426 * ud - "user data". The "ctx_ptr" gets this value
427 * when the thread is active.
428 * It is also passed to the entry function...
431 empth_create(int prio, void (*entry)(void *), int size, int flags,
432 char *name, char *desc, void *ud)
434 empth_t *pThread = NULL;
436 loc_debug("creating new thread %s:%s", name, desc);
438 pThread = malloc(sizeof(*pThread));
440 logerror("not enough memory to create thread: %s (%s)", name,
444 memset(pThread, 0, sizeof(*pThread));
446 strncpy(pThread->szName, name, sizeof(pThread->szName) - 1);
447 strncpy(pThread->szDesc, desc, sizeof(pThread->szDesc) - 1);
448 pThread->pvUserData = ud;
449 pThread->pfnEntry = entry;
450 pThread->bMainThread = FALSE;
452 /* Create thread event sem, auto reset. */
453 pThread->hThreadEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
455 if (size < loc_MIN_THREAD_STACK)
456 size = loc_MIN_THREAD_STACK;
458 pThread->ulThreadID = _beginthread(empth_threadMain, size, pThread);
459 if (pThread->ulThreadID == -1) {
460 logerror("can not create thread: %s (%s): %s", name, desc,
465 loc_debug("new thread id is %ld", pThread->ulThreadID);
471 loc_FreeThreadInfo(pThread);
477 /************************
483 empth_t *pThread = TlsGetValue(dwTLSIndex);
488 /************************
494 empth_t *pThread = TlsGetValue(dwTLSIndex);
496 loc_BlockThisThread();
498 loc_debug("empth_exit");
500 if (pThread->bMainThread) {
501 loc_BlockMainThread();
505 TlsSetValue(dwTLSIndex, NULL);
506 loc_FreeThreadInfo(pThread);
511 /************************
514 * Yield processing to another thread.
519 loc_BlockThisThread();
523 /************************
526 * Kill off the thread.
529 empth_terminate(empth_t *pThread)
531 loc_debug("killing thread %s", pThread->szName);
532 pThread->bKilled = TRUE;
534 SetEvent(pThread->hThreadEvent);
537 /************************
540 * Do a select on the given file.
543 * This would be one of the main functions used within gen\io.c
546 empth_select(int fd, int flags)
548 WSAEVENT hEventObject[2];
549 empth_t *pThread = TlsGetValue(dwTLSIndex);
551 loc_debug("%s select on %d",
552 flags == EMPTH_FD_READ ? "read" : "write", fd);
553 loc_BlockThisThread();
555 hEventObject[0] = WSACreateEvent();
556 hEventObject[1] = pThread->hThreadEvent;
558 if (flags == EMPTH_FD_READ)
559 WSAEventSelect(fd, hEventObject[0], FD_READ | FD_ACCEPT | FD_CLOSE);
560 else if (flags == EMPTH_FD_WRITE)
561 WSAEventSelect(fd, hEventObject[0], FD_WRITE | FD_CLOSE);
563 logerror("bad flag %d passed to empth_select", flags);
567 WSAWaitForMultipleEvents(2, hEventObject, FALSE, WSA_INFINITE, FALSE);
569 WSAEventSelect(fd, hEventObject[0], 0);
571 WSACloseEvent(hEventObject[0]);
576 /************************
579 * Wake up the specified thread.
582 empth_wakeup(empth_t *pThread)
584 loc_debug("waking up thread %s", pThread->szName);
586 /* Let it run if it is blocked... */
587 SetEvent(pThread->hThreadEvent);
590 /************************
593 * Put the given thread to sleep...
596 empth_sleep(time_t until)
600 loc_BlockThisThread();
602 while ((lSec = until - time(0)) > 0) {
603 loc_debug("going to sleep %ld sec", lSec);
607 loc_debug("sleep done. Waiting to run.");
613 /************************
616 * Create a signalling semaphore.
619 empth_sem_create(char *name, int cnt)
623 pSem = malloc(sizeof(*pSem));
625 logerror("out of memory at %s:%d", __FILE__, __LINE__);
629 memset(pSem, 0, sizeof(pSem));
630 strncpy(pSem->szName, name, sizeof(pSem->szName) - 1);
632 pSem->hMutex = CreateMutex(NULL, FALSE, NULL);
633 pSem->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
639 /************************
642 * Hit/signal the specified semaphore.
645 empth_sem_signal(empth_sem_t *pSem)
647 loc_debug("signal on semaphore %s:%d", pSem->szName, pSem->count);
649 /* Wait for the Semaphore */
650 WaitForSingleObject(pSem->hMutex, INFINITE);
652 if (pSem->count++ < 0) {
653 SetEvent(pSem->hEvent);
656 ReleaseMutex(pSem->hMutex);
659 /************************
662 * Wait for the specified signal semaphore to be signaled.
665 empth_sem_wait(empth_sem_t *pSem)
667 empth_t *pThread = TlsGetValue(dwTLSIndex);
669 loc_debug("wait on semaphore %s:%d", pSem->szName, pSem->count);
671 /* Remove the thread from the running state. */
672 loc_BlockThisThread();
674 /* Wait for the Semaphore */
675 WaitForSingleObject(pSem->hMutex, INFINITE);
676 if (--pSem->count < 0) {
677 loc_debug("blocking");
678 ReleaseMutex(pSem->hMutex);
680 WaitForSingleObject(pSem->hEvent, INFINITE);
682 loc_debug("waking up");
684 ReleaseMutex(pSem->hMutex);