35a8037e1f3d7efdcd6398b9406ce36989dfdfde
[urcu.git] / tests / common / api.h
1 #ifndef _INCLUDE_API_H
2 #define _INCLUDE_API_H
3
4 /*
5 * common.h: Common Linux kernel-isms.
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 as published by
9 * the Free Software Foundation; but version 2 of the License only due
10 * to code included from the Linux kernel.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Copyright (c) 2006 Paul E. McKenney, IBM.
22 *
23 * Much code taken from the Linux kernel. For such code, the option
24 * to redistribute under later versions of GPL might not be available.
25 */
26
27 #include <urcu/compiler.h>
28 #include <urcu/arch.h>
29 #include "cpuset.h"
30
31 /*
32 * Machine parameters.
33 */
34
35 #define ____cacheline_internodealigned_in_smp \
36 __attribute__((__aligned__(CAA_CACHE_LINE_SIZE)))
37
38 /*
39 * api_pthreads.h: API mapping to pthreads environment.
40 *
41 * This program is free software; you can redistribute it and/or modify
42 * it under the terms of the GNU General Public License as published by
43 * the Free Software Foundation; either version 2 of the License, or
44 * (at your option) any later version. However, please note that much
45 * of the code in this file derives from the Linux kernel, and that such
46 * code may not be available except under GPLv2.
47 *
48 * This program is distributed in the hope that it will be useful,
49 * but WITHOUT ANY WARRANTY; without even the implied warranty of
50 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
51 * GNU General Public License for more details.
52 *
53 * You should have received a copy of the GNU General Public License
54 * along with this program; if not, write to the Free Software
55 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
56 *
57 * Copyright (c) 2006 Paul E. McKenney, IBM.
58 */
59
60 #include <stdio.h>
61 #include <stdlib.h>
62 #include <errno.h>
63 #include <limits.h>
64 #include <sys/types.h>
65 #include <pthread.h>
66 #include <sys/param.h>
67 /* #include "atomic.h" */
68
69 /*
70 * Exclusive locking primitives.
71 */
72
73 typedef pthread_mutex_t spinlock_t;
74
75 #define DEFINE_SPINLOCK(lock) spinlock_t lock = PTHREAD_MUTEX_INITIALIZER;
76 #define __SPIN_LOCK_UNLOCKED(lockp) PTHREAD_MUTEX_INITIALIZER
77
78 static void spin_lock_init(spinlock_t *sp)
79 {
80 if (pthread_mutex_init(sp, NULL) != 0) {
81 perror("spin_lock_init:pthread_mutex_init");
82 exit(-1);
83 }
84 }
85
86 static void spin_lock(spinlock_t *sp)
87 {
88 if (pthread_mutex_lock(sp) != 0) {
89 perror("spin_lock:pthread_mutex_lock");
90 exit(-1);
91 }
92 }
93
94 static void spin_unlock(spinlock_t *sp)
95 {
96 if (pthread_mutex_unlock(sp) != 0) {
97 perror("spin_unlock:pthread_mutex_unlock");
98 exit(-1);
99 }
100 }
101
102 #define spin_lock_irqsave(l, f) do { f = 1; spin_lock(l); } while (0)
103 #define spin_unlock_irqrestore(l, f) do { f = 0; spin_unlock(l); } while (0)
104
105 /*
106 * Thread creation/destruction primitives.
107 */
108
109 typedef pthread_t thread_id_t;
110
111 #define NR_THREADS 4096
112
113 #define __THREAD_ID_MAP_EMPTY ((thread_id_t) 0)
114 #define __THREAD_ID_MAP_WAITING ((thread_id_t) 1)
115 thread_id_t __thread_id_map[NR_THREADS];
116 spinlock_t __thread_id_map_mutex;
117
118 #define for_each_thread(t) \
119 for (t = 0; t < NR_THREADS; t++)
120
121 #define for_each_running_thread(t) \
122 for (t = 0; t < NR_THREADS; t++) \
123 if ((__thread_id_map[t] != __THREAD_ID_MAP_EMPTY) && \
124 (__thread_id_map[t] != __THREAD_ID_MAP_WAITING))
125
126 #define for_each_tid(t, tid) \
127 for (t = 0; t < NR_THREADS; t++) \
128 if ((((tid) = __thread_id_map[t]) != __THREAD_ID_MAP_EMPTY) && \
129 ((tid) != __THREAD_ID_MAP_WAITING))
130
131 pthread_key_t thread_id_key;
132
133 static int __smp_thread_id(void)
134 {
135 int i;
136 thread_id_t tid = pthread_self();
137
138 for (i = 0; i < NR_THREADS; i++) {
139 if (__thread_id_map[i] == tid) {
140 long v = i + 1; /* must be non-NULL. */
141
142 if (pthread_setspecific(thread_id_key, (void *)v) != 0) {
143 perror("pthread_setspecific");
144 exit(-1);
145 }
146 return i;
147 }
148 }
149 spin_lock(&__thread_id_map_mutex);
150 for (i = 0; i < NR_THREADS; i++) {
151 if (__thread_id_map[i] == tid) {
152 spin_unlock(&__thread_id_map_mutex);
153 return i;
154 }
155 }
156 spin_unlock(&__thread_id_map_mutex);
157 fprintf(stderr, "smp_thread_id: Rogue thread, id: %lu(%#lx)\n",
158 (unsigned long) tid, (unsigned long) tid);
159 exit(-1);
160 }
161
162 static int smp_thread_id(void)
163 {
164 void *id;
165
166 id = pthread_getspecific(thread_id_key);
167 if (id == NULL)
168 return __smp_thread_id();
169 return (long)(id - 1);
170 }
171
172 static thread_id_t create_thread(void *(*func)(void *), void *arg)
173 {
174 thread_id_t tid;
175 int i;
176
177 spin_lock(&__thread_id_map_mutex);
178 for (i = 0; i < NR_THREADS; i++) {
179 if (__thread_id_map[i] == __THREAD_ID_MAP_EMPTY)
180 break;
181 }
182 if (i >= NR_THREADS) {
183 spin_unlock(&__thread_id_map_mutex);
184 fprintf(stderr, "Thread limit of %d exceeded!\n", NR_THREADS);
185 exit(-1);
186 }
187 __thread_id_map[i] = __THREAD_ID_MAP_WAITING;
188 spin_unlock(&__thread_id_map_mutex);
189 if (pthread_create(&tid, NULL, func, arg) != 0) {
190 perror("create_thread:pthread_create");
191 exit(-1);
192 }
193 __thread_id_map[i] = tid;
194 return tid;
195 }
196
197 static void *wait_thread(thread_id_t tid)
198 {
199 int i;
200 void *vp;
201
202 for (i = 0; i < NR_THREADS; i++) {
203 if (__thread_id_map[i] == tid)
204 break;
205 }
206 if (i >= NR_THREADS){
207 fprintf(stderr, "wait_thread: bad tid = %lu(%#lx)\n",
208 (unsigned long)tid, (unsigned long)tid);
209 exit(-1);
210 }
211 if (pthread_join(tid, &vp) != 0) {
212 perror("wait_thread:pthread_join");
213 exit(-1);
214 }
215 __thread_id_map[i] = __THREAD_ID_MAP_EMPTY;
216 return vp;
217 }
218
219 static void wait_all_threads(void)
220 {
221 int i;
222 thread_id_t tid;
223
224 for (i = 1; i < NR_THREADS; i++) {
225 tid = __thread_id_map[i];
226 if (tid != __THREAD_ID_MAP_EMPTY &&
227 tid != __THREAD_ID_MAP_WAITING)
228 (void)wait_thread(tid);
229 }
230 }
231
232 static void run_on(int cpu)
233 {
234 #if HAVE_SCHED_SETAFFINITY
235 cpu_set_t mask;
236
237 CPU_ZERO(&mask);
238 CPU_SET(cpu, &mask);
239 #if SCHED_SETAFFINITY_ARGS == 2
240 sched_setaffinity(0, &mask);
241 #else
242 sched_setaffinity(0, sizeof(mask), &mask);
243 #endif
244 #endif /* HAVE_SCHED_SETAFFINITY */
245 }
246
247 /*
248 * timekeeping -- very crude -- should use MONOTONIC...
249 */
250
251 long long get_microseconds(void)
252 {
253 struct timeval tv;
254
255 if (gettimeofday(&tv, NULL) != 0)
256 abort();
257 return ((long long)tv.tv_sec) * 1000000LL + (long long)tv.tv_usec;
258 }
259
260 /*
261 * Per-thread variables.
262 */
263
264 #define DEFINE_PER_THREAD(type, name) \
265 struct { \
266 __typeof__(type) v \
267 __attribute__((__aligned__(CAA_CACHE_LINE_SIZE))); \
268 } __per_thread_##name[NR_THREADS]
269 #define DECLARE_PER_THREAD(type, name) extern DEFINE_PER_THREAD(type, name)
270
271 #define per_thread(name, thread) __per_thread_##name[thread].v
272 #define __get_thread_var(name) per_thread(name, smp_thread_id())
273
274 #define init_per_thread(name, v) \
275 do { \
276 int __i_p_t_i; \
277 for (__i_p_t_i = 0; __i_p_t_i < NR_THREADS; __i_p_t_i++) \
278 per_thread(name, __i_p_t_i) = v; \
279 } while (0)
280
281 DEFINE_PER_THREAD(int, smp_processor_id);
282
283 /*
284 * Bug checks.
285 */
286
287 #define BUG_ON(c) do { if (!(c)) abort(); } while (0)
288
289 /*
290 * Initialization -- Must be called before calling any primitives.
291 */
292
293 static void smp_init(void)
294 {
295 int i;
296
297 spin_lock_init(&__thread_id_map_mutex);
298 __thread_id_map[0] = pthread_self();
299 for (i = 1; i < NR_THREADS; i++)
300 __thread_id_map[i] = __THREAD_ID_MAP_EMPTY;
301 init_per_thread(smp_processor_id, 0);
302 if (pthread_key_create(&thread_id_key, NULL) != 0) {
303 perror("pthread_key_create");
304 exit(-1);
305 }
306 }
307
308 #endif
This page took 0.05307 seconds and 3 git commands to generate.