libgomp/icv.c

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