Mercurial > hg > CbC > CbC_gcc
annotate libgomp/sections.c @ 122:fb3d53c41846
do not expand code segment
| author | mir3636 |
|---|---|
| date | Thu, 22 Mar 2018 17:37:58 +0900 |
| parents | 04ced10e8804 |
| children | 84e7813d76e9 |
| rev | line source |
|---|---|
| 111 | 1 /* Copyright (C) 2005-2017 Free Software Foundation, Inc. |
| 0 | 2 Contributed by Richard Henderson <rth@redhat.com>. |
| 3 | |
| 111 | 4 This file is part of the GNU Offloading and Multi Processing Library |
| 5 (libgomp). | |
| 0 | 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 | |
| 30 | |
| 31 /* Initialize the given work share construct from the given arguments. */ | |
| 32 | |
| 33 static inline void | |
| 34 gomp_sections_init (struct gomp_work_share *ws, unsigned count) | |
| 35 { | |
| 36 ws->sched = GFS_DYNAMIC; | |
| 37 ws->chunk_size = 1; | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
38 ws->end = count + 1L; |
| 0 | 39 ws->incr = 1; |
| 40 ws->next = 1; | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
41 #ifdef HAVE_SYNC_BUILTINS |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
42 /* Prepare things to make each iteration faster. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
43 if (sizeof (long) > sizeof (unsigned)) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
44 ws->mode = 1; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
45 else |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
46 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
47 struct gomp_thread *thr = gomp_thread (); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
48 struct gomp_team *team = thr->ts.team; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
49 long nthreads = team ? team->nthreads : 1; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
50 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
51 ws->mode = ((nthreads | ws->end) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
52 < 1UL << (sizeof (long) * __CHAR_BIT__ / 2 - 1)); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
53 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
54 #else |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
55 ws->mode = 0; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
56 #endif |
| 0 | 57 } |
| 58 | |
| 59 /* This routine is called when first encountering a sections construct | |
| 60 that is not bound directly to a parallel construct. The first thread | |
| 61 that arrives will create the work-share construct; subsequent threads | |
| 62 will see the construct exists and allocate work from it. | |
| 63 | |
| 64 COUNT is the number of sections in this construct. | |
| 65 | |
| 66 Returns the 1-based section number for this thread to perform, or 0 if | |
| 67 all work was assigned to other threads prior to this thread's arrival. */ | |
| 68 | |
| 69 unsigned | |
| 70 GOMP_sections_start (unsigned count) | |
| 71 { | |
| 72 struct gomp_thread *thr = gomp_thread (); | |
| 73 long s, e, ret; | |
| 74 | |
| 75 if (gomp_work_share_start (false)) | |
| 76 { | |
| 77 gomp_sections_init (thr->ts.work_share, count); | |
| 78 gomp_work_share_init_done (); | |
| 79 } | |
| 80 | |
| 81 #ifdef HAVE_SYNC_BUILTINS | |
| 82 if (gomp_iter_dynamic_next (&s, &e)) | |
| 83 ret = s; | |
| 84 else | |
| 85 ret = 0; | |
| 86 #else | |
| 87 gomp_mutex_lock (&thr->ts.work_share->lock); | |
| 88 if (gomp_iter_dynamic_next_locked (&s, &e)) | |
| 89 ret = s; | |
| 90 else | |
| 91 ret = 0; | |
| 92 gomp_mutex_unlock (&thr->ts.work_share->lock); | |
| 93 #endif | |
| 94 | |
| 95 return ret; | |
| 96 } | |
| 97 | |
| 98 /* This routine is called when the thread completes processing of the | |
| 99 section currently assigned to it. If the work-share construct is | |
| 100 bound directly to a parallel construct, then the construct may have | |
| 101 been set up before the parallel. In which case, this may be the | |
| 102 first iteration for the thread. | |
| 103 | |
| 104 Returns the 1-based section number for this thread to perform, or 0 if | |
| 105 all work was assigned to other threads prior to this thread's arrival. */ | |
| 106 | |
| 107 unsigned | |
| 108 GOMP_sections_next (void) | |
| 109 { | |
| 110 long s, e, ret; | |
| 111 | |
| 112 #ifdef HAVE_SYNC_BUILTINS | |
| 113 if (gomp_iter_dynamic_next (&s, &e)) | |
| 114 ret = s; | |
| 115 else | |
| 116 ret = 0; | |
| 117 #else | |
| 118 struct gomp_thread *thr = gomp_thread (); | |
| 119 | |
| 120 gomp_mutex_lock (&thr->ts.work_share->lock); | |
| 121 if (gomp_iter_dynamic_next_locked (&s, &e)) | |
| 122 ret = s; | |
| 123 else | |
| 124 ret = 0; | |
| 125 gomp_mutex_unlock (&thr->ts.work_share->lock); | |
| 126 #endif | |
| 127 | |
| 128 return ret; | |
| 129 } | |
| 130 | |
| 131 /* This routine pre-initializes a work-share construct to avoid one | |
| 132 synchronization once we get into the loop. */ | |
| 133 | |
| 134 void | |
| 135 GOMP_parallel_sections_start (void (*fn) (void *), void *data, | |
| 136 unsigned num_threads, unsigned count) | |
| 137 { | |
| 138 struct gomp_team *team; | |
| 139 | |
| 140 num_threads = gomp_resolve_num_threads (num_threads, count); | |
| 141 team = gomp_new_team (num_threads); | |
| 142 gomp_sections_init (&team->work_shares[0], count); | |
| 111 | 143 gomp_team_start (fn, data, num_threads, 0, team); |
| 144 } | |
| 145 | |
| 146 ialias_redirect (GOMP_parallel_end) | |
| 147 | |
| 148 void | |
| 149 GOMP_parallel_sections (void (*fn) (void *), void *data, | |
| 150 unsigned num_threads, unsigned count, unsigned flags) | |
| 151 { | |
| 152 struct gomp_team *team; | |
| 153 | |
| 154 num_threads = gomp_resolve_num_threads (num_threads, count); | |
| 155 team = gomp_new_team (num_threads); | |
| 156 gomp_sections_init (&team->work_shares[0], count); | |
| 157 gomp_team_start (fn, data, num_threads, flags, team); | |
| 158 fn (data); | |
| 159 GOMP_parallel_end (); | |
| 0 | 160 } |
| 161 | |
| 162 /* The GOMP_section_end* routines are called after the thread is told | |
| 111 | 163 that all sections are complete. The first two versions synchronize |
| 0 | 164 all threads; the nowait version does not. */ |
| 165 | |
| 166 void | |
| 167 GOMP_sections_end (void) | |
| 168 { | |
| 169 gomp_work_share_end (); | |
| 170 } | |
| 171 | |
| 111 | 172 bool |
| 173 GOMP_sections_end_cancel (void) | |
| 174 { | |
| 175 return gomp_work_share_end_cancel (); | |
| 176 } | |
| 177 | |
| 0 | 178 void |
| 179 GOMP_sections_end_nowait (void) | |
| 180 { | |
| 181 gomp_work_share_end_nowait (); | |
| 182 } |