1 /* Copyright (C) 2005-2024 Free Software Foundation, Inc. 2 Contributed by Richard Henderson <rth (at) redhat.com>. 3 4 This file is part of the GNU Offloading and Multi Processing Library 5 (libgomp). 6 7 Libgomp is free software; you can redistribute it and/or modify it 8 under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3, or (at your option) 10 any later version. 11 12 Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY 13 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 14 FOR A PARTICULAR PURPOSE. See the GNU General Public License for 15 more details. 16 17 Under Section 7 of GPL version 3, you are granted additional 18 permissions described in the GCC Runtime Library Exception, version 19 3.1, as published by the Free Software Foundation. 20 21 You should have received a copy of the GNU General Public License and 22 a copy of the GCC Runtime Library Exception along with this program; 23 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 24 <http://www.gnu.org/licenses/>. */ 25 26 /* This file handles the SECTIONS construct. */ 27 28 #include "libgomp.h" 29 #include <string.h> 30 31 32 ialias_redirect (GOMP_taskgroup_reduction_register) 33 34 /* Initialize the given work share construct from the given arguments. */ 35 36 static inline void 37 gomp_sections_init (struct gomp_work_share *ws, unsigned count) 38 { 39 ws->sched = GFS_DYNAMIC; 40 ws->chunk_size = 1; 41 ws->end = count + 1L; 42 ws->incr = 1; 43 ws->next = 1; 44 #ifdef HAVE_SYNC_BUILTINS 45 /* Prepare things to make each iteration faster. */ 46 if (sizeof (long) > sizeof (unsigned)) 47 ws->mode = 1; 48 else 49 { 50 struct gomp_thread *thr = gomp_thread (); 51 struct gomp_team *team = thr->ts.team; 52 long nthreads = team ? team->nthreads : 1; 53 54 ws->mode = ((nthreads | ws->end) 55 < 1UL << (sizeof (long) * __CHAR_BIT__ / 2 - 1)); 56 } 57 #else 58 ws->mode = 0; 59 #endif 60 } 61 62 /* This routine is called when first encountering a sections construct 63 that is not bound directly to a parallel construct. The first thread 64 that arrives will create the work-share construct; subsequent threads 65 will see the construct exists and allocate work from it. 66 67 COUNT is the number of sections in this construct. 68 69 Returns the 1-based section number for this thread to perform, or 0 if 70 all work was assigned to other threads prior to this thread's arrival. */ 71 72 unsigned 73 GOMP_sections_start (unsigned count) 74 { 75 struct gomp_thread *thr = gomp_thread (); 76 long s, e, ret; 77 78 if (gomp_work_share_start (0)) 79 { 80 gomp_sections_init (thr->ts.work_share, count); 81 gomp_work_share_init_done (); 82 } 83 84 #ifdef HAVE_SYNC_BUILTINS 85 if (gomp_iter_dynamic_next (&s, &e)) 86 ret = s; 87 else 88 ret = 0; 89 #else 90 gomp_mutex_lock (&thr->ts.work_share->lock); 91 if (gomp_iter_dynamic_next_locked (&s, &e)) 92 ret = s; 93 else 94 ret = 0; 95 gomp_mutex_unlock (&thr->ts.work_share->lock); 96 #endif 97 98 return ret; 99 } 100 101 unsigned 102 GOMP_sections2_start (unsigned count, uintptr_t *reductions, void **mem) 103 { 104 struct gomp_thread *thr = gomp_thread (); 105 long s, e, ret; 106 107 if (reductions) 108 gomp_workshare_taskgroup_start (); 109 if (gomp_work_share_start (0)) 110 { 111 gomp_sections_init (thr->ts.work_share, count); 112 if (reductions) 113 { 114 GOMP_taskgroup_reduction_register (reductions); 115 thr->task->taskgroup->workshare = true; 116 thr->ts.work_share->task_reductions = reductions; 117 } 118 if (mem) 119 { 120 uintptr_t size = (uintptr_t) *mem; 121 #define INLINE_ORDERED_TEAM_IDS_OFF \ 122 ((offsetof (struct gomp_work_share, inline_ordered_team_ids) \ 123 + __alignof__ (long long) - 1) & ~(__alignof__ (long long) - 1)) 124 if (sizeof (struct gomp_work_share) 125 <= INLINE_ORDERED_TEAM_IDS_OFF 126 || __alignof__ (struct gomp_work_share) < __alignof__ (long long) 127 || size > (sizeof (struct gomp_work_share) 128 - INLINE_ORDERED_TEAM_IDS_OFF)) 129 *mem 130 = (void *) (thr->ts.work_share->ordered_team_ids 131 = gomp_malloc_cleared (size)); 132 else 133 *mem = memset (((char *) thr->ts.work_share) 134 + INLINE_ORDERED_TEAM_IDS_OFF, '\0', size); 135 } 136 gomp_work_share_init_done (); 137 } 138 else 139 { 140 if (reductions) 141 { 142 uintptr_t *first_reductions = thr->ts.work_share->task_reductions; 143 gomp_workshare_task_reduction_register (reductions, 144 first_reductions); 145 } 146 if (mem) 147 { 148 if ((offsetof (struct gomp_work_share, inline_ordered_team_ids) 149 & (__alignof__ (long long) - 1)) == 0) 150 *mem = (void *) thr->ts.work_share->ordered_team_ids; 151 else 152 { 153 uintptr_t p = (uintptr_t) thr->ts.work_share->ordered_team_ids; 154 p += __alignof__ (long long) - 1; 155 p &= ~(__alignof__ (long long) - 1); 156 *mem = (void *) p; 157 } 158 } 159 } 160 161 #ifdef HAVE_SYNC_BUILTINS 162 if (gomp_iter_dynamic_next (&s, &e)) 163 ret = s; 164 else 165 ret = 0; 166 #else 167 gomp_mutex_lock (&thr->ts.work_share->lock); 168 if (gomp_iter_dynamic_next_locked (&s, &e)) 169 ret = s; 170 else 171 ret = 0; 172 gomp_mutex_unlock (&thr->ts.work_share->lock); 173 #endif 174 175 return ret; 176 } 177 178 /* This routine is called when the thread completes processing of the 179 section currently assigned to it. If the work-share construct is 180 bound directly to a parallel construct, then the construct may have 181 been set up before the parallel. In which case, this may be the 182 first iteration for the thread. 183 184 Returns the 1-based section number for this thread to perform, or 0 if 185 all work was assigned to other threads prior to this thread's arrival. */ 186 187 unsigned 188 GOMP_sections_next (void) 189 { 190 long s, e, ret; 191 192 #ifdef HAVE_SYNC_BUILTINS 193 if (gomp_iter_dynamic_next (&s, &e)) 194 ret = s; 195 else 196 ret = 0; 197 #else 198 struct gomp_thread *thr = gomp_thread (); 199 200 gomp_mutex_lock (&thr->ts.work_share->lock); 201 if (gomp_iter_dynamic_next_locked (&s, &e)) 202 ret = s; 203 else 204 ret = 0; 205 gomp_mutex_unlock (&thr->ts.work_share->lock); 206 #endif 207 208 return ret; 209 } 210 211 /* This routine pre-initializes a work-share construct to avoid one 212 synchronization once we get into the loop. */ 213 214 void 215 GOMP_parallel_sections_start (void (*fn) (void *), void *data, 216 unsigned num_threads, unsigned count) 217 { 218 struct gomp_team *team; 219 220 num_threads = gomp_resolve_num_threads (num_threads, count); 221 team = gomp_new_team (num_threads); 222 gomp_sections_init (&team->work_shares[0], count); 223 gomp_team_start (fn, data, num_threads, 0, team, NULL); 224 } 225 226 ialias_redirect (GOMP_parallel_end) 227 228 void 229 GOMP_parallel_sections (void (*fn) (void *), void *data, 230 unsigned num_threads, unsigned count, unsigned flags) 231 { 232 struct gomp_team *team; 233 234 num_threads = gomp_resolve_num_threads (num_threads, count); 235 team = gomp_new_team (num_threads); 236 gomp_sections_init (&team->work_shares[0], count); 237 gomp_team_start (fn, data, num_threads, flags, team, NULL); 238 fn (data); 239 GOMP_parallel_end (); 240 } 241 242 /* The GOMP_section_end* routines are called after the thread is told 243 that all sections are complete. The first two versions synchronize 244 all threads; the nowait version does not. */ 245 246 void 247 GOMP_sections_end (void) 248 { 249 gomp_work_share_end (); 250 } 251 252 bool 253 GOMP_sections_end_cancel (void) 254 { 255 return gomp_work_share_end_cancel (); 256 } 257 258 void 259 GOMP_sections_end_nowait (void) 260 { 261 gomp_work_share_end_nowait (); 262 } 263
Indexes created Tue Feb 24 08:35:24 UTC 2026