Update copyright to LGPL on all files
[dyninst.git] / testsuite / src / mutatee_util_mt.c
1 /*
2  * Copyright (c) 1996-2009 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31 #include <stdlib.h>
32 #include <stdio.h>
33 #include <assert.h>
34 #include "mutatee_util.h"
35
36 #if defined(os_windows_test)
37
38 #define WIN32_LEAN_AND_MEAN
39 #include <windows.h>
40
41 thread_t spawnNewThread(void *initial_func, void *param) {
42     thread_t newthr;
43     newthr.hndl = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) initial_func, 
44                                param, 0, (LPDWORD) &(newthr.threadid));
45     return newthr;
46 }
47
48 void joinThread(thread_t threadid) {
49     HANDLE tid;
50     DWORD result;
51
52     tid = threadid.hndl;
53     assert(tid != INVALID_HANDLE);
54     for (;;) {
55         GetExitCodeThread(tid, &result);
56         if (result != STILL_ACTIVE)
57             break;
58         Sleep(500);
59     }
60     CloseHandle(tid);
61 }
62
63 thread_t threadSelf() {
64     thread_t self;
65     self.hndl = INVALID_HANDLE;
66     self.threadid = GetCurrentThreadId();
67     return self;
68 }
69
70 void initThreads() {
71 }
72
73 void initLock(testlock_t *newlock) {
74     CRITICAL_SECTION *cs = (CRITICAL_SECTION *) newlock;
75     InitializeCriticalSection(cs);
76 }
77
78 void testLock(testlock_t *lck) {
79     CRITICAL_SECTION *cs = (CRITICAL_SECTION *) lck;
80     EnterCriticalSection(lck);
81 }
82
83 void testUnlock(testlock_t *lck) {
84     CRITICAL_SECTION *cs = (CRITICAL_SECTION *) lck;
85     LeaveCriticalSection(lck);
86 }
87
88 int threads_equal(thread_t a, thread_t b) {
89     return a.threadid == b.threadid;
90 }
91
92 unsigned long thread_int(thread_t a) {
93     return (unsigned long)a.threadid;
94 }
95
96 void schedYield() {
97     Sleep(1);
98 }
99
100 #else
101 #include <pthread.h>
102
103 /*Spawn a posix thread with pthread_create*/
104 thread_t spawnNewThread(void *initial_func, void *param) {
105     static int initialized = 0;
106     static pthread_attr_t attr;
107     pthread_t new_thread;
108     int result;
109
110     if (!initialized) {
111         initialized = 1;
112         pthread_attr_init(&attr);
113         pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
114     }
115     
116     result = pthread_create(&new_thread, &attr, 
117                             (void*(*)(void*)) initial_func, 
118                             param);
119     if (result != 0) {
120         return 0;
121     }
122     return (thread_t) new_thread;
123 }
124
125 void joinThread(thread_t threadid) {
126     pthread_t p = (pthread_t) threadid;
127     pthread_join(p, NULL);
128 }
129
130 void initThreads() {
131 }
132
133 void initLock(testlock_t *newlock) {
134    pthread_mutex_init((pthread_mutex_t *) newlock, NULL);
135 }
136
137 void testLock(testlock_t *lck) {
138    pthread_mutex_lock((pthread_mutex_t *) lck);
139 }
140
141 void testUnlock(testlock_t *lck) {
142    pthread_mutex_unlock((pthread_mutex_t *) lck);
143 }
144
145 thread_t threadSelf() {
146     return (thread_t) pthread_self();
147 }
148
149 int threads_equal(thread_t a, thread_t b) {
150     return a == b;
151 }
152
153 unsigned long thread_int(thread_t a) {
154     return (unsigned long)a;
155 }
156
157 void schedYield() {
158     sched_yield();
159 }
160
161 #endif