]>
Commit | Line | Data |
---|---|---|
748086b7 | 1 | /* Copyright (C) 2005, 2009 Free Software Foundation, Inc. |
953ff289 DN |
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 | |
748086b7 JJ |
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. | |
953ff289 DN |
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 | |
748086b7 | 13 | FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
953ff289 DN |
14 | more details. |
15 | ||
748086b7 JJ |
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/>. */ | |
953ff289 DN |
24 | |
25 | /* This file handles the ORDERED construct. */ | |
26 | ||
27 | #include "libgomp.h" | |
28 | ||
29 | ||
30 | /* This function is called when first allocating an iteration block. That | |
31 | is, the thread is not currently on the queue. The work-share lock must | |
32 | be held on entry. */ | |
33 | ||
34 | void | |
35 | gomp_ordered_first (void) | |
36 | { | |
37 | struct gomp_thread *thr = gomp_thread (); | |
38 | struct gomp_team *team = thr->ts.team; | |
39 | struct gomp_work_share *ws = thr->ts.work_share; | |
40 | unsigned index; | |
41 | ||
42 | /* Work share constructs can be orphaned. */ | |
43 | if (team == NULL || team->nthreads == 1) | |
44 | return; | |
45 | ||
46 | index = ws->ordered_cur + ws->ordered_num_used; | |
47 | if (index >= team->nthreads) | |
48 | index -= team->nthreads; | |
49 | ws->ordered_team_ids[index] = thr->ts.team_id; | |
50 | ||
51 | /* If this is the first and only thread in the queue, then there is | |
52 | no one to release us when we get to our ordered section. Post to | |
53 | our own release queue now so that we won't block later. */ | |
54 | if (ws->ordered_num_used++ == 0) | |
55 | gomp_sem_post (team->ordered_release[thr->ts.team_id]); | |
56 | } | |
57 | ||
58 | /* This function is called when completing the last iteration block. That | |
59 | is, there are no more iterations to perform and so the thread should be | |
60 | removed from the queue entirely. Because of the way ORDERED blocks are | |
61 | managed, it follows that we currently own access to the ORDERED block, | |
62 | and should now pass it on to the next thread. The work-share lock must | |
63 | be held on entry. */ | |
64 | ||
65 | void | |
66 | gomp_ordered_last (void) | |
67 | { | |
68 | struct gomp_thread *thr = gomp_thread (); | |
69 | struct gomp_team *team = thr->ts.team; | |
70 | struct gomp_work_share *ws = thr->ts.work_share; | |
71 | unsigned next_id; | |
72 | ||
73 | /* Work share constructs can be orphaned. */ | |
74 | if (team == NULL || team->nthreads == 1) | |
75 | return; | |
76 | ||
77 | /* We're no longer the owner. */ | |
78 | ws->ordered_owner = -1; | |
79 | ||
80 | /* If we're not the last thread in the queue, then wake the next. */ | |
81 | if (--ws->ordered_num_used > 0) | |
82 | { | |
83 | unsigned next = ws->ordered_cur + 1; | |
84 | if (next == team->nthreads) | |
85 | next = 0; | |
86 | ws->ordered_cur = next; | |
87 | ||
88 | next_id = ws->ordered_team_ids[next]; | |
89 | gomp_sem_post (team->ordered_release[next_id]); | |
90 | } | |
91 | } | |
92 | ||
93 | ||
94 | /* This function is called when allocating a subsequent allocation block. | |
95 | That is, we're done with the current iteration block and we're allocating | |
96 | another. This is the logical combination of a call to gomp_ordered_last | |
97 | followed by a call to gomp_ordered_first. The work-share lock must be | |
98 | held on entry. */ | |
99 | ||
100 | void | |
101 | gomp_ordered_next (void) | |
102 | { | |
103 | struct gomp_thread *thr = gomp_thread (); | |
104 | struct gomp_team *team = thr->ts.team; | |
105 | struct gomp_work_share *ws = thr->ts.work_share; | |
106 | unsigned index, next_id; | |
107 | ||
108 | /* Work share constructs can be orphaned. */ | |
109 | if (team == NULL || team->nthreads == 1) | |
110 | return; | |
111 | ||
112 | /* We're no longer the owner. */ | |
113 | ws->ordered_owner = -1; | |
114 | ||
115 | /* If there's only one thread in the queue, that must be us. */ | |
116 | if (ws->ordered_num_used == 1) | |
117 | { | |
118 | /* We have a similar situation as in gomp_ordered_first | |
119 | where we need to post to our own release semaphore. */ | |
120 | gomp_sem_post (team->ordered_release[thr->ts.team_id]); | |
121 | return; | |
122 | } | |
123 | ||
124 | /* If the queue is entirely full, then we move ourself to the end of | |
125 | the queue merely by incrementing ordered_cur. Only if it's not | |
126 | full do we have to write our id. */ | |
127 | if (ws->ordered_num_used < team->nthreads) | |
128 | { | |
129 | index = ws->ordered_cur + ws->ordered_num_used; | |
130 | if (index >= team->nthreads) | |
131 | index -= team->nthreads; | |
132 | ws->ordered_team_ids[index] = thr->ts.team_id; | |
133 | } | |
134 | ||
135 | index = ws->ordered_cur + 1; | |
136 | if (index == team->nthreads) | |
137 | index = 0; | |
138 | ws->ordered_cur = index; | |
139 | ||
140 | next_id = ws->ordered_team_ids[index]; | |
141 | gomp_sem_post (team->ordered_release[next_id]); | |
142 | } | |
143 | ||
144 | ||
145 | /* This function is called when a statically scheduled loop is first | |
146 | being created. */ | |
147 | ||
148 | void | |
149 | gomp_ordered_static_init (void) | |
150 | { | |
151 | struct gomp_thread *thr = gomp_thread (); | |
152 | struct gomp_team *team = thr->ts.team; | |
153 | ||
154 | if (team == NULL || team->nthreads == 1) | |
155 | return; | |
156 | ||
157 | gomp_sem_post (team->ordered_release[0]); | |
158 | } | |
159 | ||
160 | /* This function is called when a statically scheduled loop is moving to | |
161 | the next allocation block. Static schedules are not first come first | |
162 | served like the others, so we're to move to the numerically next thread, | |
163 | not the next thread on a list. The work-share lock should *not* be held | |
164 | on entry. */ | |
165 | ||
166 | void | |
167 | gomp_ordered_static_next (void) | |
168 | { | |
169 | struct gomp_thread *thr = gomp_thread (); | |
170 | struct gomp_team *team = thr->ts.team; | |
171 | struct gomp_work_share *ws = thr->ts.work_share; | |
172 | unsigned id = thr->ts.team_id; | |
173 | ||
174 | if (team == NULL || team->nthreads == 1) | |
175 | return; | |
176 | ||
177 | ws->ordered_owner = -1; | |
178 | ||
179 | /* This thread currently owns the lock. Increment the owner. */ | |
180 | if (++id == team->nthreads) | |
181 | id = 0; | |
182 | ws->ordered_team_ids[0] = id; | |
183 | gomp_sem_post (team->ordered_release[id]); | |
184 | } | |
185 | ||
186 | /* This function is called when we need to assert that the thread owns the | |
187 | ordered section. Due to the problem of posted-but-not-waited semaphores, | |
188 | this needs to happen before completing a loop iteration. */ | |
189 | ||
190 | void | |
191 | gomp_ordered_sync (void) | |
192 | { | |
193 | struct gomp_thread *thr = gomp_thread (); | |
194 | struct gomp_team *team = thr->ts.team; | |
195 | struct gomp_work_share *ws = thr->ts.work_share; | |
196 | ||
197 | /* Work share constructs can be orphaned. But this clearly means that | |
198 | we are the only thread, and so we automatically own the section. */ | |
199 | if (team == NULL || team->nthreads == 1) | |
200 | return; | |
201 | ||
202 | /* ??? I believe it to be safe to access this data without taking the | |
203 | ws->lock. The only presumed race condition is with the previous | |
204 | thread on the queue incrementing ordered_cur such that it points | |
205 | to us, concurrently with our check below. But our team_id is | |
206 | already present in the queue, and the other thread will always | |
207 | post to our release semaphore. So the two cases are that we will | |
208 | either win the race an momentarily block on the semaphore, or lose | |
209 | the race and find the semaphore already unlocked and so not block. | |
210 | Either way we get correct results. */ | |
211 | ||
212 | if (ws->ordered_owner != thr->ts.team_id) | |
213 | { | |
214 | gomp_sem_wait (team->ordered_release[thr->ts.team_id]); | |
215 | ws->ordered_owner = thr->ts.team_id; | |
216 | } | |
217 | } | |
218 | ||
219 | /* This function is called by user code when encountering the start of an | |
220 | ORDERED block. We must check to see if the current thread is at the | |
221 | head of the queue, and if not, block. */ | |
222 | ||
223 | #ifdef HAVE_ATTRIBUTE_ALIAS | |
224 | extern void GOMP_ordered_start (void) | |
225 | __attribute__((alias ("gomp_ordered_sync"))); | |
226 | #else | |
227 | void | |
228 | GOMP_ordered_start (void) | |
229 | { | |
230 | gomp_ordered_sync (); | |
231 | } | |
232 | #endif | |
233 | ||
234 | /* This function is called by user code when encountering the end of an | |
235 | ORDERED block. With the current ORDERED implementation there's nothing | |
236 | for us to do. | |
237 | ||
238 | However, the current implementation has a flaw in that it does not allow | |
239 | the next thread into the ORDERED section immediately after the current | |
240 | thread exits the ORDERED section in its last iteration. The existance | |
241 | of this function allows the implementation to change. */ | |
242 | ||
243 | void | |
244 | GOMP_ordered_end (void) | |
245 | { | |
246 | } |