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