1 /* Copyright (C) 2005-2022 Free Software Foundation, Inc.
2 Contributed by Richard Henderson <rth@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 defines the OpenMP API entry points that operate on internal
27 control variables. */
28
29 #include "libgomp.h"
30 #include "gomp-constants.h"
31 #include <limits.h>
32
ialias_redirect(omp_get_active_level)33 ialias_redirect (omp_get_active_level)
34
35 void
36 omp_set_num_threads (int n)
37 {
38 struct gomp_task_icv *icv = gomp_icv (true);
39 icv->nthreads_var = (n > 0 ? n : 1);
40 }
41
42 void
omp_set_dynamic(int val)43 omp_set_dynamic (int val)
44 {
45 struct gomp_task_icv *icv = gomp_icv (true);
46 icv->dyn_var = val;
47 }
48
49 int
omp_get_dynamic(void)50 omp_get_dynamic (void)
51 {
52 struct gomp_task_icv *icv = gomp_icv (false);
53 return icv->dyn_var;
54 }
55
56 #pragma GCC diagnostic push
57 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
58 void
omp_set_nested(int val)59 omp_set_nested (int val)
60 {
61 struct gomp_task_icv *icv = gomp_icv (true);
62 if (val)
63 icv->max_active_levels_var = gomp_supported_active_levels;
64 else if (icv->max_active_levels_var > 1)
65 icv->max_active_levels_var = 1;
66 }
67
68 int
omp_get_nested(void)69 omp_get_nested (void)
70 {
71 struct gomp_task_icv *icv = gomp_icv (false);
72 return (icv->max_active_levels_var > 1
73 && icv->max_active_levels_var > omp_get_active_level ());
74 }
75 #pragma GCC diagnostic pop
76
77 void
omp_set_schedule(omp_sched_t kind,int chunk_size)78 omp_set_schedule (omp_sched_t kind, int chunk_size)
79 {
80 struct gomp_task_icv *icv = gomp_icv (true);
81 switch (kind & ~omp_sched_monotonic)
82 {
83 case omp_sched_static:
84 if (chunk_size < 1)
85 chunk_size = 0;
86 icv->run_sched_chunk_size = chunk_size;
87 break;
88 case omp_sched_dynamic:
89 case omp_sched_guided:
90 if (chunk_size < 1)
91 chunk_size = 1;
92 icv->run_sched_chunk_size = chunk_size;
93 break;
94 case omp_sched_auto:
95 break;
96 default:
97 return;
98 }
99 icv->run_sched_var = kind;
100 }
101
102 void
omp_get_schedule(omp_sched_t * kind,int * chunk_size)103 omp_get_schedule (omp_sched_t *kind, int *chunk_size)
104 {
105 struct gomp_task_icv *icv = gomp_icv (false);
106 *kind = icv->run_sched_var;
107 *chunk_size = icv->run_sched_chunk_size;
108 }
109
110 int
omp_get_max_threads(void)111 omp_get_max_threads (void)
112 {
113 struct gomp_task_icv *icv = gomp_icv (false);
114 return icv->nthreads_var;
115 }
116
117 int
omp_get_thread_limit(void)118 omp_get_thread_limit (void)
119 {
120 struct gomp_task_icv *icv = gomp_icv (false);
121 return icv->thread_limit_var > INT_MAX ? INT_MAX : icv->thread_limit_var;
122 }
123
124 void
omp_set_max_active_levels(int max_levels)125 omp_set_max_active_levels (int max_levels)
126 {
127 if (max_levels >= 0)
128 {
129 struct gomp_task_icv *icv = gomp_icv (true);
130
131 if (max_levels <= gomp_supported_active_levels)
132 icv->max_active_levels_var = max_levels;
133 else
134 icv->max_active_levels_var = gomp_supported_active_levels;
135 }
136 }
137
138 int
omp_get_max_active_levels(void)139 omp_get_max_active_levels (void)
140 {
141 struct gomp_task_icv *icv = gomp_icv (false);
142 return icv->max_active_levels_var;
143 }
144
145 int
omp_get_supported_active_levels(void)146 omp_get_supported_active_levels (void)
147 {
148 return gomp_supported_active_levels;
149 }
150
151 void
omp_set_num_teams(int num_teams)152 omp_set_num_teams (int num_teams)
153 {
154 if (num_teams >= 0)
155 gomp_nteams_var = num_teams;
156 }
157
158 int
omp_get_max_teams(void)159 omp_get_max_teams (void)
160 {
161 return gomp_nteams_var;
162 }
163
164 void
omp_set_teams_thread_limit(int thread_limit)165 omp_set_teams_thread_limit (int thread_limit)
166 {
167 if (thread_limit >= 0)
168 gomp_teams_thread_limit_var = thread_limit;
169 }
170
171 int
omp_get_teams_thread_limit(void)172 omp_get_teams_thread_limit (void)
173 {
174 return gomp_teams_thread_limit_var;
175 }
176
177 int
omp_get_cancellation(void)178 omp_get_cancellation (void)
179 {
180 return gomp_cancel_var;
181 }
182
183 int
omp_get_max_task_priority(void)184 omp_get_max_task_priority (void)
185 {
186 return gomp_max_task_priority_var;
187 }
188
189 omp_proc_bind_t
omp_get_proc_bind(void)190 omp_get_proc_bind (void)
191 {
192 struct gomp_task_icv *icv = gomp_icv (false);
193 return icv->bind_var;
194 }
195
196 int
omp_get_num_places(void)197 omp_get_num_places (void)
198 {
199 return gomp_places_list_len;
200 }
201
202 int
omp_get_place_num(void)203 omp_get_place_num (void)
204 {
205 if (gomp_places_list == NULL)
206 return -1;
207
208 struct gomp_thread *thr = gomp_thread ();
209 if (thr->place == 0)
210 gomp_init_affinity ();
211
212 return (int) thr->place - 1;
213 }
214
215 int
omp_get_partition_num_places(void)216 omp_get_partition_num_places (void)
217 {
218 if (gomp_places_list == NULL)
219 return 0;
220
221 struct gomp_thread *thr = gomp_thread ();
222 if (thr->place == 0)
223 gomp_init_affinity ();
224
225 return thr->ts.place_partition_len;
226 }
227
228 void
omp_get_partition_place_nums(int * place_nums)229 omp_get_partition_place_nums (int *place_nums)
230 {
231 if (gomp_places_list == NULL)
232 return;
233
234 struct gomp_thread *thr = gomp_thread ();
235 if (thr->place == 0)
236 gomp_init_affinity ();
237
238 unsigned int i;
239 for (i = 0; i < thr->ts.place_partition_len; i++)
240 *place_nums++ = thr->ts.place_partition_off + i;
241 }
242
243 void
omp_set_default_allocator(omp_allocator_handle_t allocator)244 omp_set_default_allocator (omp_allocator_handle_t allocator)
245 {
246 struct gomp_thread *thr = gomp_thread ();
247 if (allocator == omp_null_allocator)
248 allocator = omp_default_mem_alloc;
249 thr->ts.def_allocator = (uintptr_t) allocator;
250 }
251
252 omp_allocator_handle_t
omp_get_default_allocator(void)253 omp_get_default_allocator (void)
254 {
255 struct gomp_thread *thr = gomp_thread ();
256 if (thr->ts.def_allocator == omp_null_allocator)
257 return (omp_allocator_handle_t) gomp_def_allocator;
258 else
259 return (omp_allocator_handle_t) thr->ts.def_allocator;
260 }
261
262 ialias (omp_set_dynamic)
263 ialias (omp_get_dynamic)
264 #pragma GCC diagnostic push
265 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
266 ialias (omp_set_nested)
267 ialias (omp_get_nested)
268 #pragma GCC diagnostic pop
269 ialias (omp_set_num_threads)
270 ialias (omp_set_schedule)
271 ialias (omp_get_schedule)
272 ialias (omp_get_max_threads)
273 ialias (omp_get_thread_limit)
274 ialias (omp_set_max_active_levels)
275 ialias (omp_get_max_active_levels)
276 ialias (omp_get_supported_active_levels)
277 ialias (omp_set_num_teams)
278 ialias (omp_get_max_teams)
279 ialias (omp_set_teams_thread_limit)
280 ialias (omp_get_teams_thread_limit)
281 ialias (omp_get_cancellation)
282 ialias (omp_get_proc_bind)
283 ialias (omp_get_max_task_priority)
284 ialias (omp_get_num_places)
285 ialias (omp_get_place_num)
286 ialias (omp_get_partition_num_places)
287 ialias (omp_get_partition_place_nums)
288 ialias (omp_set_default_allocator)
289 ialias (omp_get_default_allocator)
290