URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
Compare Revisions
- This comparison shows the changes necessary to convert path
/openrisc/trunk/gnu-old/gcc-4.2.2/libgomp/config/linux
- from Rev 154 to Rev 816
- ↔ Reverse comparison
Rev 154 → Rev 816
/powerpc/futex.h
0,0 → 1,70
/* Copyright (C) 2005 Free Software Foundation, Inc. |
Contributed by Richard Henderson <rth@redhat.com>. |
|
This file is part of the GNU OpenMP Library (libgomp). |
|
Libgomp is free software; you can redistribute it and/or modify it |
under the terms of the GNU Lesser General Public License as published by |
the Free Software Foundation; either version 2.1 of the License, or |
(at your option) any later version. |
|
Libgomp 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 Lesser General Public License for |
more details. |
|
You should have received a copy of the GNU Lesser General Public License |
along with libgomp; see the file COPYING.LIB. If not, write to the |
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
MA 02110-1301, USA. */ |
|
/* As a special exception, if you link this library with other files, some |
of which are compiled with GCC, to produce an executable, this library |
does not by itself cause the resulting executable to be covered by the |
GNU General Public License. This exception does not however invalidate |
any other reasons why the executable file might be covered by the GNU |
General Public License. */ |
|
/* Provide target-specific access to the futex system call. */ |
|
#include <sys/syscall.h> |
#define FUTEX_WAIT 0 |
#define FUTEX_WAKE 1 |
|
static inline void |
sys_futex0 (int *addr, int op, int val) |
{ |
register long int r0 __asm__ ("r0"); |
register long int r3 __asm__ ("r3"); |
register long int r4 __asm__ ("r4"); |
register long int r5 __asm__ ("r5"); |
register long int r6 __asm__ ("r6"); |
|
r0 = SYS_futex; |
r3 = (long) addr; |
r4 = op; |
r5 = val; |
r6 = 0; |
|
/* ??? The powerpc64 sysdep.h file clobbers ctr; the powerpc32 sysdep.h |
doesn't. It doesn't much matter for us. In the interest of unity, |
go ahead and clobber it always. */ |
|
__asm volatile ("sc" |
: "=r"(r0), "=r"(r3), "=r"(r4), "=r"(r5), "=r"(r6) |
: "r"(r0), "r"(r3), "r"(r4), "r"(r5), "r"(r6) |
: "r7", "r8", "r9", "r10", "r11", "r12", |
"cr0", "ctr", "memory"); |
} |
|
static inline void |
futex_wait (int *addr, int val) |
{ |
sys_futex0 (addr, FUTEX_WAIT, val); |
} |
|
static inline void |
futex_wake (int *addr, int count) |
{ |
sys_futex0 (addr, FUTEX_WAKE, count); |
} |
/ia64/futex.h
0,0 → 1,71
/* Copyright (C) 2005 Free Software Foundation, Inc. |
Contributed by Richard Henderson <rth@redhat.com>. |
|
This file is part of the GNU OpenMP Library (libgomp). |
|
Libgomp is free software; you can redistribute it and/or modify it |
under the terms of the GNU Lesser General Public License as published by |
the Free Software Foundation; either version 2.1 of the License, or |
(at your option) any later version. |
|
Libgomp 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 Lesser General Public License for |
more details. |
|
You should have received a copy of the GNU Lesser General Public License |
along with libgomp; see the file COPYING.LIB. If not, write to the |
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
MA 02110-1301, USA. */ |
|
/* As a special exception, if you link this library with other files, some |
of which are compiled with GCC, to produce an executable, this library |
does not by itself cause the resulting executable to be covered by the |
GNU General Public License. This exception does not however invalidate |
any other reasons why the executable file might be covered by the GNU |
General Public License. */ |
|
/* Provide target-specific access to the futex system call. */ |
|
#include <sys/syscall.h> |
|
#define FUTEX_WAIT 0 |
#define FUTEX_WAKE 1 |
|
|
static inline void |
sys_futex0(int *addr, int op, int val) |
{ |
register long out0 asm ("out0") = (long) addr; |
register long out1 asm ("out1") = op; |
register long out2 asm ("out2") = val; |
register long out3 asm ("out3") = 0; |
register long r15 asm ("r15") = SYS_futex; |
|
__asm __volatile ("break 0x100000" |
: "=r"(r15), "=r"(out0), "=r"(out1), "=r"(out2), "=r"(out3) |
: "r"(r15), "r"(out0), "r"(out1), "r"(out2), "r"(out3) |
: "memory", "r8", "r10", "out4", "out5", "out6", "out7", |
/* Non-stacked integer registers, minus r8, r10, r15. */ |
"r2", "r3", "r9", "r11", "r12", "r13", "r14", "r16", "r17", "r18", |
"r19", "r20", "r21", "r22", "r23", "r24", "r25", "r26", "r27", |
"r28", "r29", "r30", "r31", |
/* Predicate registers. */ |
"p6", "p7", "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15", |
/* Non-rotating fp registers. */ |
"f6", "f7", "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", |
/* Branch registers. */ |
"b6"); |
} |
|
static inline void |
futex_wait (int *addr, int val) |
{ |
sys_futex0 (addr, FUTEX_WAIT, val); |
} |
|
static inline void |
futex_wake (int *addr, int count) |
{ |
sys_futex0 (addr, FUTEX_WAKE, count); |
} |
/mutex.c
0,0 → 1,52
/* Copyright (C) 2005 Free Software Foundation, Inc. |
Contributed by Richard Henderson <rth@redhat.com>. |
|
This file is part of the GNU OpenMP Library (libgomp). |
|
Libgomp is free software; you can redistribute it and/or modify it |
under the terms of the GNU Lesser General Public License as published by |
the Free Software Foundation; either version 2.1 of the License, or |
(at your option) any later version. |
|
Libgomp 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 Lesser General Public License for |
more details. |
|
You should have received a copy of the GNU Lesser General Public License |
along with libgomp; see the file COPYING.LIB. If not, write to the |
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
MA 02110-1301, USA. */ |
|
/* As a special exception, if you link this library with other files, some |
of which are compiled with GCC, to produce an executable, this library |
does not by itself cause the resulting executable to be covered by the |
GNU General Public License. This exception does not however invalidate |
any other reasons why the executable file might be covered by the GNU |
General Public License. */ |
|
/* This is a Linux specific implementation of a mutex synchronization |
mechanism for libgomp. This type is private to the library. This |
implementation uses atomic instructions and the futex syscall. */ |
|
#include "libgomp.h" |
#include "futex.h" |
|
|
void |
gomp_mutex_lock_slow (gomp_mutex_t *mutex) |
{ |
do |
{ |
int oldval = __sync_val_compare_and_swap (mutex, 1, 2); |
if (oldval != 0) |
futex_wait (mutex, 2); |
} |
while (!__sync_bool_compare_and_swap (mutex, 0, 2)); |
} |
|
void |
gomp_mutex_unlock_slow (gomp_mutex_t *mutex) |
{ |
futex_wake (mutex, 1); |
} |
/alpha/futex.h
0,0 → 1,76
/* Copyright (C) 2005 Free Software Foundation, Inc. |
Contributed by Richard Henderson <rth@redhat.com>. |
|
This file is part of the GNU OpenMP Library (libgomp). |
|
Libgomp is free software; you can redistribute it and/or modify it |
under the terms of the GNU Lesser General Public License as published by |
the Free Software Foundation; either version 2.1 of the License, or |
(at your option) any later version. |
|
Libgomp 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 Lesser General Public License for |
more details. |
|
You should have received a copy of the GNU Lesser General Public License |
along with libgomp; see the file COPYING.LIB. If not, write to the |
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
MA 02110-1301, USA. */ |
|
/* As a special exception, if you link this library with other files, some |
of which are compiled with GCC, to produce an executable, this library |
does not by itself cause the resulting executable to be covered by the |
GNU General Public License. This exception does not however invalidate |
any other reasons why the executable file might be covered by the GNU |
General Public License. */ |
|
/* Provide target-specific access to the futex system call. */ |
|
#ifndef SYS_futex |
#define SYS_futex 394 |
#endif |
#define FUTEX_WAIT 0 |
#define FUTEX_WAKE 1 |
|
|
static inline void |
futex_wait (int *addr, int val) |
{ |
register long sc_0 __asm__("$0"); |
register long sc_16 __asm__("$16"); |
register long sc_17 __asm__("$17"); |
register long sc_18 __asm__("$18"); |
register long sc_19 __asm__("$19"); |
|
sc_0 = SYS_futex; |
sc_16 = (long) addr; |
sc_17 = FUTEX_WAIT; |
sc_18 = val; |
sc_19 = 0; |
__asm volatile ("callsys" |
: "=r" (sc_0), "=r"(sc_19) |
: "0"(sc_0), "r" (sc_16), "r"(sc_17), "r"(sc_18), "1"(sc_19) |
: "$1", "$2", "$3", "$4", "$5", "$6", "$7", "$8", |
"$22", "$23", "$24", "$25", "$27", "$28", "memory"); |
} |
|
static inline void |
futex_wake (int *addr, int count) |
{ |
register long sc_0 __asm__("$0"); |
register long sc_16 __asm__("$16"); |
register long sc_17 __asm__("$17"); |
register long sc_18 __asm__("$18"); |
register long sc_19 __asm__("$19"); |
|
sc_0 = SYS_futex; |
sc_16 = (long) addr; |
sc_17 = FUTEX_WAKE; |
sc_18 = count; |
__asm volatile ("callsys" |
: "=r" (sc_0), "=r"(sc_19) |
: "0"(sc_0), "r" (sc_16), "r"(sc_17), "r"(sc_18) |
: "$1", "$2", "$3", "$4", "$5", "$6", "$7", "$8", |
"$22", "$23", "$24", "$25", "$27", "$28", "memory"); |
} |
/bar.c
0,0 → 1,64
/* Copyright (C) 2005 Free Software Foundation, Inc. |
Contributed by Richard Henderson <rth@redhat.com>. |
|
This file is part of the GNU OpenMP Library (libgomp). |
|
Libgomp is free software; you can redistribute it and/or modify it |
under the terms of the GNU Lesser General Public License as published by |
the Free Software Foundation; either version 2.1 of the License, or |
(at your option) any later version. |
|
Libgomp 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 Lesser General Public License for |
more details. |
|
You should have received a copy of the GNU Lesser General Public License |
along with libgomp; see the file COPYING.LIB. If not, write to the |
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
MA 02110-1301, USA. */ |
|
/* As a special exception, if you link this library with other files, some |
of which are compiled with GCC, to produce an executable, this library |
does not by itself cause the resulting executable to be covered by the |
GNU General Public License. This exception does not however invalidate |
any other reasons why the executable file might be covered by the GNU |
General Public License. */ |
|
/* This is a Linux specific implementation of a barrier synchronization |
mechanism for libgomp. This type is private to the library. This |
implementation uses atomic instructions and the futex syscall. */ |
|
#include "libgomp.h" |
#include "futex.h" |
#include <limits.h> |
|
|
void |
gomp_barrier_wait_end (gomp_barrier_t *bar, bool last) |
{ |
if (last) |
{ |
bar->generation++; |
futex_wake (&bar->generation, INT_MAX); |
} |
else |
{ |
unsigned int generation = bar->generation; |
|
gomp_mutex_unlock (&bar->mutex); |
|
do |
futex_wait (&bar->generation, generation); |
while (bar->generation == generation); |
} |
|
if (__sync_add_and_fetch (&bar->arrived, -1) == 0) |
gomp_mutex_unlock (&bar->mutex); |
} |
|
void |
gomp_barrier_wait (gomp_barrier_t *barrier) |
{ |
gomp_barrier_wait_end (barrier, gomp_barrier_wait_start (barrier)); |
} |
/sem.c
0,0 → 1,65
/* Copyright (C) 2005 Free Software Foundation, Inc. |
Contributed by Richard Henderson <rth@redhat.com>. |
|
This file is part of the GNU OpenMP Library (libgomp). |
|
Libgomp is free software; you can redistribute it and/or modify it |
under the terms of the GNU Lesser General Public License as published by |
the Free Software Foundation; either version 2.1 of the License, or |
(at your option) any later version. |
|
Libgomp 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 Lesser General Public License for |
more details. |
|
You should have received a copy of the GNU Lesser General Public License |
along with libgomp; see the file COPYING.LIB. If not, write to the |
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
MA 02110-1301, USA. */ |
|
/* As a special exception, if you link this library with other files, some |
of which are compiled with GCC, to produce an executable, this library |
does not by itself cause the resulting executable to be covered by the |
GNU General Public License. This exception does not however invalidate |
any other reasons why the executable file might be covered by the GNU |
General Public License. */ |
|
/* This is a Linux specific implementation of a semaphore synchronization |
mechanism for libgomp. This type is private to the library. This |
implementation uses atomic instructions and the futex syscall. */ |
|
#include "libgomp.h" |
#include "futex.h" |
|
|
void |
gomp_sem_wait_slow (gomp_sem_t *sem) |
{ |
while (1) |
{ |
int val = __sync_val_compare_and_swap (sem, 0, -1); |
if (val > 0) |
{ |
if (__sync_bool_compare_and_swap (sem, val, val - 1)) |
return; |
} |
futex_wait (sem, -1); |
} |
} |
|
void |
gomp_sem_post_slow (gomp_sem_t *sem) |
{ |
int old, tmp = *sem, wake; |
|
do |
{ |
old = tmp; |
wake = old > 0 ? old + 1 : 1; |
tmp = __sync_val_compare_and_swap (sem, old, wake); |
} |
while (old != tmp); |
|
futex_wake (sem, wake); |
} |
/x86/futex.h
0,0 → 1,110
/* Copyright (C) 2005 Free Software Foundation, Inc. |
Contributed by Richard Henderson <rth@redhat.com>. |
|
This file is part of the GNU OpenMP Library (libgomp). |
|
Libgomp is free software; you can redistribute it and/or modify it |
under the terms of the GNU Lesser General Public License as published by |
the Free Software Foundation; either version 2.1 of the License, or |
(at your option) any later version. |
|
Libgomp 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 Lesser General Public License for |
more details. |
|
You should have received a copy of the GNU Lesser General Public License |
along with libgomp; see the file COPYING.LIB. If not, write to the |
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
MA 02110-1301, USA. */ |
|
/* As a special exception, if you link this library with other files, some |
of which are compiled with GCC, to produce an executable, this library |
does not by itself cause the resulting executable to be covered by the |
GNU General Public License. This exception does not however invalidate |
any other reasons why the executable file might be covered by the GNU |
General Public License. */ |
|
/* Provide target-specific access to the futex system call. */ |
|
#define FUTEX_WAIT 0 |
#define FUTEX_WAKE 1 |
|
#ifdef __LP64__ |
# ifndef SYS_futex |
# define SYS_futex 202 |
# endif |
|
static inline void |
futex_wait (int *addr, int val) |
{ |
register long r10 __asm__("%r10") = 0; |
long res; |
|
__asm volatile ("syscall" |
: "=a" (res) |
: "0"(SYS_futex), "D" (addr), "S"(FUTEX_WAIT), |
"d"(val), "r"(r10) |
: "r11", "rcx", "memory"); |
} |
|
static inline void |
futex_wake (int *addr, int count) |
{ |
long res; |
|
__asm volatile ("syscall" |
: "=a" (res) |
: "0"(SYS_futex), "D" (addr), "S"(FUTEX_WAKE), "d"(count) |
: "r11", "rcx", "memory"); |
} |
#else |
# ifndef SYS_futex |
# define SYS_futex 240 |
# endif |
|
# ifdef __PIC__ |
|
static inline void |
sys_futex0 (int *addr, int op, int val) |
{ |
long res; |
|
__asm volatile ("xchgl\t%%ebx, %2\n\t" |
"int\t$0x80\n\t" |
"xchgl\t%%ebx, %2" |
: "=a" (res) |
: "0"(SYS_futex), "r" (addr), "c"(op), |
"d"(val), "S"(0) |
: "memory"); |
} |
|
# else |
|
static inline void |
sys_futex0 (int *addr, int op, int val) |
{ |
long res; |
|
__asm volatile ("int $0x80" |
: "=a" (res) |
: "0"(SYS_futex), "b" (addr), "c"(op), |
"d"(val), "S"(0) |
: "memory"); |
} |
|
# endif /* __PIC__ */ |
|
static inline void |
futex_wait (int *addr, int val) |
{ |
sys_futex0 (addr, FUTEX_WAIT, val); |
} |
|
static inline void |
futex_wake (int *addr, int count) |
{ |
sys_futex0 (addr, FUTEX_WAKE, count); |
} |
|
#endif /* __LP64__ */ |
/omp-lock.h
0,0 → 1,10
/* This header is used during the build process to find the size and |
alignment of the public OpenMP locks, so that we can export data |
structures without polluting the namespace. |
|
When using the Linux futex primitive, non-recursive locks require |
only one int. Recursive locks require we identify the owning thread |
and so require two ints. */ |
|
typedef int omp_lock_t; |
typedef struct { int owner, count; } omp_nest_lock_t; |
/mutex.h
0,0 → 1,63
/* Copyright (C) 2005 Free Software Foundation, Inc. |
Contributed by Richard Henderson <rth@redhat.com>. |
|
This file is part of the GNU OpenMP Library (libgomp). |
|
Libgomp is free software; you can redistribute it and/or modify it |
under the terms of the GNU Lesser General Public License as published by |
the Free Software Foundation; either version 2.1 of the License, or |
(at your option) any later version. |
|
Libgomp 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 Lesser General Public License for |
more details. |
|
You should have received a copy of the GNU Lesser General Public License |
along with libgomp; see the file COPYING.LIB. If not, write to the |
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
MA 02110-1301, USA. */ |
|
/* As a special exception, if you link this library with other files, some |
of which are compiled with GCC, to produce an executable, this library |
does not by itself cause the resulting executable to be covered by the |
GNU General Public License. This exception does not however invalidate |
any other reasons why the executable file might be covered by the GNU |
General Public License. */ |
|
/* This is a Linux specific implementation of a mutex synchronization |
mechanism for libgomp. This type is private to the library. This |
implementation uses atomic instructions and the futex syscall. */ |
|
#ifndef GOMP_MUTEX_H |
#define GOMP_MUTEX_H 1 |
|
typedef int gomp_mutex_t; |
|
#define GOMP_MUTEX_INIT_0 1 |
|
static inline void gomp_mutex_init (gomp_mutex_t *mutex) |
{ |
*mutex = 0; |
} |
|
extern void gomp_mutex_lock_slow (gomp_mutex_t *mutex); |
static inline void gomp_mutex_lock (gomp_mutex_t *mutex) |
{ |
if (!__sync_bool_compare_and_swap (mutex, 0, 1)) |
gomp_mutex_lock_slow (mutex); |
} |
|
extern void gomp_mutex_unlock_slow (gomp_mutex_t *mutex); |
static inline void gomp_mutex_unlock (gomp_mutex_t *mutex) |
{ |
int val = __sync_lock_test_and_set (mutex, 0); |
if (__builtin_expect (val > 1, 0)) |
gomp_mutex_unlock_slow (mutex); |
} |
|
static inline void gomp_mutex_destroy (gomp_mutex_t *mutex) |
{ |
} |
|
#endif /* GOMP_MUTEX_H */ |
/sparc/futex.h
0,0 → 1,80
/* Copyright (C) 2005 Free Software Foundation, Inc. |
Contributed by Jakub Jelinek <jakub@redhat.com>. |
|
This file is part of the GNU OpenMP Library (libgomp). |
|
Libgomp is free software; you can redistribute it and/or modify it |
under the terms of the GNU Lesser General Public License as published by |
the Free Software Foundation; either version 2.1 of the License, or |
(at your option) any later version. |
|
Libgomp 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 Lesser General Public License for |
more details. |
|
You should have received a copy of the GNU Lesser General Public License |
along with libgomp; see the file COPYING.LIB. If not, write to the |
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
MA 02110-1301, USA. */ |
|
/* As a special exception, if you link this library with other files, some |
of which are compiled with GCC, to produce an executable, this library |
does not by itself cause the resulting executable to be covered by the |
GNU General Public License. This exception does not however invalidate |
any other reasons why the executable file might be covered by the GNU |
General Public License. */ |
|
/* Provide target-specific access to the futex system call. */ |
|
#include <sys/syscall.h> |
#define FUTEX_WAIT 0 |
#define FUTEX_WAKE 1 |
|
static inline void |
sys_futex0 (int *addr, int op, int val) |
{ |
register long int g1 __asm__ ("g1"); |
register long int o0 __asm__ ("o0"); |
register long int o1 __asm__ ("o1"); |
register long int o2 __asm__ ("o2"); |
register long int o3 __asm__ ("o3"); |
|
g1 = SYS_futex; |
o0 = (long) addr; |
o1 = op; |
o2 = val; |
o3 = 0; |
|
#ifdef __arch64__ |
# define SYSCALL_STRING "ta\t0x6d" |
#else |
# define SYSCALL_STRING "ta\t0x10" |
#endif |
|
__asm volatile (SYSCALL_STRING |
: "=r" (g1), "=r" (o0) |
: "0" (g1), "1" (o0), "r" (o1), "r" (o2), "r" (o3) |
: "g2", "g3", "g4", "g5", "g6", |
"f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", |
"f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", |
"f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", |
"f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", |
#ifdef __arch64__ |
"f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46", |
"f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62", |
#endif |
"cc", "memory"); |
} |
|
static inline void |
futex_wait (int *addr, int val) |
{ |
sys_futex0 (addr, FUTEX_WAIT, val); |
} |
|
static inline void |
futex_wake (int *addr, int count) |
{ |
sys_futex0 (addr, FUTEX_WAKE, count); |
} |
/lock.c
0,0 → 1,182
/* Copyright (C) 2005 Free Software Foundation, Inc. |
Contributed by Richard Henderson <rth@redhat.com>. |
|
This file is part of the GNU OpenMP Library (libgomp). |
|
Libgomp is free software; you can redistribute it and/or modify it |
under the terms of the GNU Lesser General Public License as published by |
the Free Software Foundation; either version 2.1 of the License, or |
(at your option) any later version. |
|
Libgomp 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 Lesser General Public License for |
more details. |
|
You should have received a copy of the GNU Lesser General Public License |
along with libgomp; see the file COPYING.LIB. If not, write to the |
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
MA 02110-1301, USA. */ |
|
/* As a special exception, if you link this library with other files, some |
of which are compiled with GCC, to produce an executable, this library |
does not by itself cause the resulting executable to be covered by the |
GNU General Public License. This exception does not however invalidate |
any other reasons why the executable file might be covered by the GNU |
General Public License. */ |
|
/* This is a Linux specific implementation of the public OpenMP locking |
primitives. This implementation uses atomic instructions and the futex |
syscall. */ |
|
#include "libgomp.h" |
#include <string.h> |
#include <unistd.h> |
#include <sys/syscall.h> |
#include "futex.h" |
|
|
/* The internal gomp_mutex_t and the external non-recursive omp_lock_t |
have the same form. Re-use it. */ |
|
void |
omp_init_lock (omp_lock_t *lock) |
{ |
gomp_mutex_init (lock); |
} |
|
void |
omp_destroy_lock (omp_lock_t *lock) |
{ |
gomp_mutex_destroy (lock); |
} |
|
void |
omp_set_lock (omp_lock_t *lock) |
{ |
gomp_mutex_lock (lock); |
} |
|
void |
omp_unset_lock (omp_lock_t *lock) |
{ |
gomp_mutex_unlock (lock); |
} |
|
int |
omp_test_lock (omp_lock_t *lock) |
{ |
return __sync_bool_compare_and_swap (lock, 0, 1); |
} |
|
/* The external recursive omp_nest_lock_t form requires additional work. */ |
|
/* We need an integer to uniquely identify this thread. Most generally |
this is the thread's TID, which ideally we'd get this straight from |
the TLS block where glibc keeps it. Unfortunately, we can't get at |
that directly. |
|
If we don't support (or have disabled) TLS, one function call is as |
good (or bad) as any other. Use the syscall all the time. |
|
On an ILP32 system (defined here as not LP64), we can make do with |
any thread-local pointer. Ideally we'd use the TLS base address, |
since that requires the least amount of arithmetic, but that's not |
always available directly. Make do with the gomp_thread pointer |
since it's handy. */ |
|
#if !defined (HAVE_TLS) |
static inline int gomp_tid (void) |
{ |
return syscall (SYS_gettid); |
} |
#elif !defined(__LP64__) |
static inline int gomp_tid (void) |
{ |
return (int) gomp_thread (); |
} |
#else |
static __thread int tid_cache; |
static inline int gomp_tid (void) |
{ |
int tid = tid_cache; |
if (__builtin_expect (tid == 0, 0)) |
tid_cache = tid = syscall (SYS_gettid); |
return tid; |
} |
#endif |
|
|
void |
omp_init_nest_lock (omp_nest_lock_t *lock) |
{ |
memset (lock, 0, sizeof (lock)); |
} |
|
void |
omp_destroy_nest_lock (omp_nest_lock_t *lock) |
{ |
} |
|
void |
omp_set_nest_lock (omp_nest_lock_t *lock) |
{ |
int otid, tid = gomp_tid (); |
|
while (1) |
{ |
otid = __sync_val_compare_and_swap (&lock->owner, 0, tid); |
if (otid == 0) |
{ |
lock->count = 1; |
return; |
} |
if (otid == tid) |
{ |
lock->count++; |
return; |
} |
|
futex_wait (&lock->owner, otid); |
} |
} |
|
void |
omp_unset_nest_lock (omp_nest_lock_t *lock) |
{ |
/* ??? Validate that we own the lock here. */ |
|
if (--lock->count == 0) |
{ |
__sync_lock_release (&lock->owner); |
futex_wake (&lock->owner, 1); |
} |
} |
|
int |
omp_test_nest_lock (omp_nest_lock_t *lock) |
{ |
int otid, tid = gomp_tid (); |
|
otid = __sync_val_compare_and_swap (&lock->owner, 0, tid); |
if (otid == 0) |
{ |
lock->count = 1; |
return 1; |
} |
if (otid == tid) |
return ++lock->count; |
|
return 0; |
} |
|
ialias (omp_init_lock) |
ialias (omp_init_nest_lock) |
ialias (omp_destroy_lock) |
ialias (omp_destroy_nest_lock) |
ialias (omp_set_lock) |
ialias (omp_set_nest_lock) |
ialias (omp_unset_lock) |
ialias (omp_unset_nest_lock) |
ialias (omp_test_lock) |
ialias (omp_test_nest_lock) |
/bar.h
0,0 → 1,75
/* Copyright (C) 2005 Free Software Foundation, Inc. |
Contributed by Richard Henderson <rth@redhat.com>. |
|
This file is part of the GNU OpenMP Library (libgomp). |
|
Libgomp is free software; you can redistribute it and/or modify it |
under the terms of the GNU Lesser General Public License as published by |
the Free Software Foundation; either version 2.1 of the License, or |
(at your option) any later version. |
|
Libgomp 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 Lesser General Public License for |
more details. |
|
You should have received a copy of the GNU Lesser General Public License |
along with libgomp; see the file COPYING.LIB. If not, write to the |
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
MA 02110-1301, USA. */ |
|
/* As a special exception, if you link this library with other files, some |
of which are compiled with GCC, to produce an executable, this library |
does not by itself cause the resulting executable to be covered by the |
GNU General Public License. This exception does not however invalidate |
any other reasons why the executable file might be covered by the GNU |
General Public License. */ |
|
/* This is a Linux specific implementation of a barrier synchronization |
mechanism for libgomp. This type is private to the library. This |
implementation uses atomic instructions and the futex syscall. */ |
|
#ifndef GOMP_BARRIER_H |
#define GOMP_BARRIER_H 1 |
|
#include "mutex.h" |
|
typedef struct |
{ |
gomp_mutex_t mutex; |
unsigned total; |
unsigned arrived; |
int generation; |
} gomp_barrier_t; |
|
static inline void gomp_barrier_init (gomp_barrier_t *bar, unsigned count) |
{ |
gomp_mutex_init (&bar->mutex); |
bar->total = count; |
bar->arrived = 0; |
bar->generation = 0; |
} |
|
static inline void gomp_barrier_reinit (gomp_barrier_t *bar, unsigned count) |
{ |
gomp_mutex_lock (&bar->mutex); |
bar->total = count; |
gomp_mutex_unlock (&bar->mutex); |
} |
|
static inline void gomp_barrier_destroy (gomp_barrier_t *bar) |
{ |
/* Before destroying, make sure all threads have left the barrier. */ |
gomp_mutex_lock (&bar->mutex); |
} |
|
extern void gomp_barrier_wait (gomp_barrier_t *); |
extern void gomp_barrier_wait_end (gomp_barrier_t *, bool); |
|
static inline bool gomp_barrier_wait_start (gomp_barrier_t *bar) |
{ |
gomp_mutex_lock (&bar->mutex); |
return ++bar->arrived == bar->total; |
} |
|
#endif /* GOMP_BARRIER_H */ |
/sem.h
0,0 → 1,60
/* Copyright (C) 2005 Free Software Foundation, Inc. |
Contributed by Richard Henderson <rth@redhat.com>. |
|
This file is part of the GNU OpenMP Library (libgomp). |
|
Libgomp is free software; you can redistribute it and/or modify it |
under the terms of the GNU Lesser General Public License as published by |
the Free Software Foundation; either version 2.1 of the License, or |
(at your option) any later version. |
|
Libgomp 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 Lesser General Public License for |
more details. |
|
You should have received a copy of the GNU Lesser General Public License |
along with libgomp; see the file COPYING.LIB. If not, write to the |
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
MA 02110-1301, USA. */ |
|
/* As a special exception, if you link this library with other files, some |
of which are compiled with GCC, to produce an executable, this library |
does not by itself cause the resulting executable to be covered by the |
GNU General Public License. This exception does not however invalidate |
any other reasons why the executable file might be covered by the GNU |
General Public License. */ |
|
/* This is a Linux specific implementation of a semaphore synchronization |
mechanism for libgomp. This type is private to the library. This |
implementation uses atomic instructions and the futex syscall. */ |
|
#ifndef GOMP_SEM_H |
#define GOMP_SEM_H 1 |
|
typedef int gomp_sem_t; |
|
static inline void gomp_sem_init (gomp_sem_t *sem, int value) |
{ |
*sem = value; |
} |
|
extern void gomp_sem_wait_slow (gomp_sem_t *); |
static inline void gomp_sem_wait (gomp_sem_t *sem) |
{ |
if (!__sync_bool_compare_and_swap (sem, 1, 0)) |
gomp_sem_wait_slow (sem); |
} |
|
extern void gomp_sem_post_slow (gomp_sem_t *); |
static inline void gomp_sem_post (gomp_sem_t *sem) |
{ |
if (!__sync_bool_compare_and_swap (sem, 0, 1)) |
gomp_sem_post_slow (sem); |
} |
|
static inline void gomp_sem_destroy (gomp_sem_t *sem) |
{ |
} |
|
#endif /* GOMP_SEM_H */ |
/s390/futex.h
0,0 → 1,64
/* Copyright (C) 2005 Free Software Foundation, Inc. |
Contributed by Jakub Jelinek <jakub@redhat.com>. |
|
This file is part of the GNU OpenMP Library (libgomp). |
|
Libgomp is free software; you can redistribute it and/or modify it |
under the terms of the GNU Lesser General Public License as published by |
the Free Software Foundation; either version 2.1 of the License, or |
(at your option) any later version. |
|
Libgomp 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 Lesser General Public License for |
more details. |
|
You should have received a copy of the GNU Lesser General Public License |
along with libgomp; see the file COPYING.LIB. If not, write to the |
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
MA 02110-1301, USA. */ |
|
/* As a special exception, if you link this library with other files, some |
of which are compiled with GCC, to produce an executable, this library |
does not by itself cause the resulting executable to be covered by the |
GNU General Public License. This exception does not however invalidate |
any other reasons why the executable file might be covered by the GNU |
General Public License. */ |
|
/* Provide target-specific access to the futex system call. */ |
|
#include <sys/syscall.h> |
#define FUTEX_WAIT 0 |
#define FUTEX_WAKE 1 |
|
static inline void |
sys_futex0 (int *addr, int op, int val) |
{ |
register long int gpr2 __asm__ ("2"); |
register long int gpr3 __asm__ ("3"); |
register long int gpr4 __asm__ ("4"); |
register long int gpr5 __asm__ ("5"); |
|
gpr2 = (long) addr; |
gpr3 = op; |
gpr4 = val; |
gpr5 = 0; |
|
__asm volatile ("svc %b1" |
: "=d" (gpr2) |
: "i" (SYS_futex), |
"0" (gpr2), "d" (gpr3), "d" (gpr4), "d" (gpr5) |
: "memory"); |
} |
|
static inline void |
futex_wait (int *addr, int val) |
{ |
sys_futex0 (addr, FUTEX_WAIT, val); |
} |
|
static inline void |
futex_wake (int *addr, int count) |
{ |
sys_futex0 (addr, FUTEX_WAKE, count); |
} |