|
0
|
1 /* Copyright (C) 2005, 2009 Free Software Foundation, Inc.
|
|
|
2 Contributed by Richard Henderson <rth@redhat.com>.
|
|
|
3
|
|
|
4 This file is part of the GNU OpenMP Library (libgomp).
|
|
|
5
|
|
|
6 Libgomp is free software; you can redistribute it and/or modify it
|
|
|
7 under the terms of the GNU General Public License as published by
|
|
|
8 the Free Software Foundation; either version 3, or (at your option)
|
|
|
9 any later version.
|
|
|
10
|
|
|
11 Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
|
13 FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
|
14 more details.
|
|
|
15
|
|
|
16 Under Section 7 of GPL version 3, you are granted additional
|
|
|
17 permissions described in the GCC Runtime Library Exception, version
|
|
|
18 3.1, as published by the Free Software Foundation.
|
|
|
19
|
|
|
20 You should have received a copy of the GNU General Public License and
|
|
|
21 a copy of the GCC Runtime Library Exception along with this program;
|
|
|
22 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|
|
23 <http://www.gnu.org/licenses/>. */
|
|
|
24
|
|
|
25 /* This file handles the CRITICAL construct. */
|
|
|
26
|
|
|
27 #include "libgomp.h"
|
|
|
28 #include <stdlib.h>
|
|
|
29
|
|
|
30
|
|
|
31 static gomp_mutex_t default_lock;
|
|
|
32
|
|
|
33 void
|
|
|
34 GOMP_critical_start (void)
|
|
|
35 {
|
|
|
36 gomp_mutex_lock (&default_lock);
|
|
|
37 }
|
|
|
38
|
|
|
39 void
|
|
|
40 GOMP_critical_end (void)
|
|
|
41 {
|
|
|
42 gomp_mutex_unlock (&default_lock);
|
|
|
43 }
|
|
|
44
|
|
|
45 #ifndef HAVE_SYNC_BUILTINS
|
|
|
46 static gomp_mutex_t create_lock_lock;
|
|
|
47 #endif
|
|
|
48
|
|
|
49 void
|
|
|
50 GOMP_critical_name_start (void **pptr)
|
|
|
51 {
|
|
|
52 gomp_mutex_t *plock;
|
|
|
53
|
|
|
54 /* If a mutex fits within the space for a pointer, and is zero initialized,
|
|
|
55 then use the pointer space directly. */
|
|
|
56 if (GOMP_MUTEX_INIT_0
|
|
|
57 && sizeof (gomp_mutex_t) <= sizeof (void *)
|
|
|
58 && __alignof (gomp_mutex_t) <= sizeof (void *))
|
|
|
59 plock = (gomp_mutex_t *)pptr;
|
|
|
60
|
|
|
61 /* Otherwise we have to be prepared to malloc storage. */
|
|
|
62 else
|
|
|
63 {
|
|
|
64 plock = *pptr;
|
|
|
65
|
|
|
66 if (plock == NULL)
|
|
|
67 {
|
|
|
68 #ifdef HAVE_SYNC_BUILTINS
|
|
|
69 gomp_mutex_t *nlock = gomp_malloc (sizeof (gomp_mutex_t));
|
|
|
70 gomp_mutex_init (nlock);
|
|
|
71
|
|
|
72 plock = __sync_val_compare_and_swap (pptr, NULL, nlock);
|
|
|
73 if (plock != NULL)
|
|
|
74 {
|
|
|
75 gomp_mutex_destroy (nlock);
|
|
|
76 free (nlock);
|
|
|
77 }
|
|
|
78 else
|
|
|
79 plock = nlock;
|
|
|
80 #else
|
|
|
81 gomp_mutex_lock (&create_lock_lock);
|
|
|
82 plock = *pptr;
|
|
|
83 if (plock == NULL)
|
|
|
84 {
|
|
|
85 plock = gomp_malloc (sizeof (gomp_mutex_t));
|
|
|
86 gomp_mutex_init (plock);
|
|
|
87 __sync_synchronize ();
|
|
|
88 *pptr = plock;
|
|
|
89 }
|
|
|
90 gomp_mutex_unlock (&create_lock_lock);
|
|
|
91 #endif
|
|
|
92 }
|
|
|
93 }
|
|
|
94
|
|
|
95 gomp_mutex_lock (plock);
|
|
|
96 }
|
|
|
97
|
|
|
98 void
|
|
|
99 GOMP_critical_name_end (void **pptr)
|
|
|
100 {
|
|
|
101 gomp_mutex_t *plock;
|
|
|
102
|
|
|
103 /* If a mutex fits within the space for a pointer, and is zero initialized,
|
|
|
104 then use the pointer space directly. */
|
|
|
105 if (GOMP_MUTEX_INIT_0
|
|
|
106 && sizeof (gomp_mutex_t) <= sizeof (void *)
|
|
|
107 && __alignof (gomp_mutex_t) <= sizeof (void *))
|
|
|
108 plock = (gomp_mutex_t *)pptr;
|
|
|
109 else
|
|
|
110 plock = *pptr;
|
|
|
111
|
|
|
112 gomp_mutex_unlock (plock);
|
|
|
113 }
|
|
|
114
|
|
|
115 /* This mutex is used when atomic operations don't exist for the target
|
|
|
116 in the mode requested. The result is not globally atomic, but works so
|
|
|
117 long as all parallel references are within #pragma omp atomic directives.
|
|
|
118 According to responses received from omp@openmp.org, appears to be within
|
|
|
119 spec. Which makes sense, since that's how several other compilers
|
|
|
120 handle this situation as well. */
|
|
|
121
|
|
|
122 static gomp_mutex_t atomic_lock;
|
|
|
123
|
|
|
124 void
|
|
|
125 GOMP_atomic_start (void)
|
|
|
126 {
|
|
|
127 gomp_mutex_lock (&atomic_lock);
|
|
|
128 }
|
|
|
129
|
|
|
130 void
|
|
|
131 GOMP_atomic_end (void)
|
|
|
132 {
|
|
|
133 gomp_mutex_unlock (&atomic_lock);
|
|
|
134 }
|
|
|
135
|
|
|
136 #if !GOMP_MUTEX_INIT_0
|
|
|
137 static void __attribute__((constructor))
|
|
|
138 initialize_critical (void)
|
|
|
139 {
|
|
|
140 gomp_mutex_init (&default_lock);
|
|
|
141 gomp_mutex_init (&atomic_lock);
|
|
|
142 #ifndef HAVE_SYNC_BUILTINS
|
|
|
143 gomp_mutex_init (&create_lock_lock);
|
|
|
144 #endif
|
|
|
145 }
|
|
|
146 #endif
|
