osapi/win32/systhread.cc

/*
 *      PearPC
 *      systhread.cc
 *
 *      Copyright (C) 2003 Sebastian Biallas (sb@biallas.net)
 *
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License version 2 as
 *      published by the Free Software Foundation.
 *
 *      This program is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *      GNU General Public License for more details.
 *
 *      You should have received a copy of the GNU General Public License
 *      along with this program; if not, write to the Free Software
 *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <cstdlib>
#include "system/systhread.h"

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <windowsx.h>
#include <commctrl.h>
#include <process.h>

struct sys_win32_semaphore {
        CRITICAL_SECTION cs;
        HANDLE sem;
};

int sys_create_mutex(sys_mutex *m)
{
        *m = malloc(sizeof (CRITICAL_SECTION));
        InitializeCriticalSection((CRITICAL_SECTION *)*m);
        return 0;
}

int sys_create_semaphore(sys_semaphore *s)
{
        *s = malloc(sizeof (sys_win32_semaphore));
        InitializeCriticalSection(&((sys_win32_semaphore *)*s)->cs);
        ((sys_win32_semaphore *)*s)->sem = CreateSemaphore(NULL, 0, 1000000, NULL);
        return 0;
}

int sys_create_thread(sys_thread *t, int flags, sys_thread_function start_routine, void *arg)
{
        unsigned long *p = (unsigned long *)malloc(sizeof (unsigned long));
        *t = p;
        *p = _beginthread((void (*)(void *))start_routine, 0, arg);
        return 0;
}

void sys_destroy_mutex(sys_mutex m)
{
        DeleteCriticalSection((CRITICAL_SECTION *)m);
        free(m);
}

void sys_destroy_semaphore(sys_semaphore s)
{
        DeleteCriticalSection(&((sys_win32_semaphore *)s)->cs);
        CloseHandle(((sys_win32_semaphore *)s)->sem);
        free(s);
}

void sys_destroy_thread(sys_thread t)
{
        // NOOP
}

int sys_lock_mutex(sys_mutex m)
{
        EnterCriticalSection((CRITICAL_SECTION *)m);
        return 0;
}

int sys_trylock_mutex(sys_mutex m)
{
        // this doesnt seems to be possible on windows
        EnterCriticalSection((CRITICAL_SECTION *)m);
        return 0;
}

void sys_unlock_mutex(sys_mutex m)
{
        LeaveCriticalSection((CRITICAL_SECTION *)m);
}

void sys_signal_semaphore(sys_semaphore s)
{
        ReleaseSemaphore(((sys_win32_semaphore *)s)->sem, 1, NULL);
}

void sys_signal_all_semaphore(sys_semaphore s)
{
        ReleaseSemaphore(((sys_win32_semaphore *)s)->sem, 1, NULL);
}

void sys_wait_semaphore(sys_semaphore s)
{
        LeaveCriticalSection(&((sys_win32_semaphore *)s)->cs);
        WaitForSingleObject(((sys_win32_semaphore *)s)->sem, INFINITE);
        EnterCriticalSection(&((sys_win32_semaphore *)s)->cs);
}

void sys_wait_semaphore_bounded(sys_semaphore s, int ms)
{
        LeaveCriticalSection(&((sys_win32_semaphore *)s)->cs);  
        WaitForSingleObject(((sys_win32_semaphore *)s)->sem, ms);
        EnterCriticalSection(&((sys_win32_semaphore *)s)->cs);
}

void sys_lock_semaphore(sys_semaphore s)
{
        EnterCriticalSection(&((sys_win32_semaphore *)s)->cs);
}

void sys_unlock_semaphore(sys_semaphore s)
{
        LeaveCriticalSection(&((sys_win32_semaphore *)s)->cs);
}

void sys_exit_thread(void *ret)
{
}

void *sys_join_thread(sys_thread t)
{
}
1	dpavlin	1	/*
2			* PearPC
3			* systhread.cc
4			*
5			* Copyright (C) 2003 Sebastian Biallas (sb@biallas.net)
6			*
7			* This program is free software; you can redistribute it and/or modify
8			* it under the terms of the GNU General Public License version 2 as
9			* published by the Free Software Foundation.
10			*
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.
15			*
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., 675 Mass Ave, Cambridge, MA 02139, USA.
19			*/
20
21			#include <cstdlib>
22			#include "system/systhread.h"
23
24			#define WIN32_LEAN_AND_MEAN
25			#include <windows.h>
26			#include <windowsx.h>
27			#include <commctrl.h>
28			#include <process.h>
29
30			struct sys_win32_semaphore {
31			CRITICAL_SECTION cs;
32			HANDLE sem;
33			};
34
35			int sys_create_mutex(sys_mutex *m)
36			{
37			*m = malloc(sizeof (CRITICAL_SECTION));
38			InitializeCriticalSection((CRITICAL_SECTION )m);
39			return 0;
40			}
41
42			int sys_create_semaphore(sys_semaphore *s)
43			{
44			*s = malloc(sizeof (sys_win32_semaphore));
45			InitializeCriticalSection(&((sys_win32_semaphore )s)->cs);
46			((sys_win32_semaphore )s)->sem = CreateSemaphore(NULL, 0, 1000000, NULL);
47			return 0;
48			}
49
50			int sys_create_thread(sys_thread t, int flags, sys_thread_function start_routine, void arg)
51			{
52			unsigned long p = (unsigned long )malloc(sizeof (unsigned long));
53			*t = p;
54			p = _beginthread((void ()(void *))start_routine, 0, arg);
55			return 0;
56			}
57
58			void sys_destroy_mutex(sys_mutex m)
59			{
60			DeleteCriticalSection((CRITICAL_SECTION *)m);
61			free(m);
62			}
63
64			void sys_destroy_semaphore(sys_semaphore s)
65			{
66			DeleteCriticalSection(&((sys_win32_semaphore *)s)->cs);
67			CloseHandle(((sys_win32_semaphore *)s)->sem);
68			free(s);
69			}
70
71			void sys_destroy_thread(sys_thread t)
72			{
73			// NOOP
74			}
75
76			int sys_lock_mutex(sys_mutex m)
77			{
78			EnterCriticalSection((CRITICAL_SECTION *)m);
79			return 0;
80			}
81
82			int sys_trylock_mutex(sys_mutex m)
83			{
84			// this doesnt seems to be possible on windows
85			EnterCriticalSection((CRITICAL_SECTION *)m);
86			return 0;
87			}
88
89			void sys_unlock_mutex(sys_mutex m)
90			{
91			LeaveCriticalSection((CRITICAL_SECTION *)m);
92			}
93
94			void sys_signal_semaphore(sys_semaphore s)
95			{
96			ReleaseSemaphore(((sys_win32_semaphore *)s)->sem, 1, NULL);
97			}
98
99			void sys_signal_all_semaphore(sys_semaphore s)
100			{
101			ReleaseSemaphore(((sys_win32_semaphore *)s)->sem, 1, NULL);
102			}
103
104			void sys_wait_semaphore(sys_semaphore s)
105			{
106			LeaveCriticalSection(&((sys_win32_semaphore *)s)->cs);
107			WaitForSingleObject(((sys_win32_semaphore *)s)->sem, INFINITE);
108			EnterCriticalSection(&((sys_win32_semaphore *)s)->cs);
109			}
110
111			void sys_wait_semaphore_bounded(sys_semaphore s, int ms)
112			{
113			LeaveCriticalSection(&((sys_win32_semaphore *)s)->cs);
114			WaitForSingleObject(((sys_win32_semaphore *)s)->sem, ms);
115			EnterCriticalSection(&((sys_win32_semaphore *)s)->cs);
116			}
117
118			void sys_lock_semaphore(sys_semaphore s)
119			{
120			EnterCriticalSection(&((sys_win32_semaphore *)s)->cs);
121			}
122
123			void sys_unlock_semaphore(sys_semaphore s)
124			{
125			LeaveCriticalSection(&((sys_win32_semaphore *)s)->cs);
126			}
127
128			void sys_exit_thread(void *ret)
129			{
130			}
131
132			void *sys_join_thread(sys_thread t)
133			{
134			}