Mercurial > hg > CbC > CbC_gcc
annotate libgomp/libgomp.h @ 143:76e1cf5455ef
add cbc_gc test
| author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Sun, 23 Dec 2018 19:24:05 +0900 |
| parents | 84e7813d76e9 |
| children | 1830386684a0 |
| rev | line source |
|---|---|
| 131 | 1 /* Copyright (C) 2005-2018 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 contains data types and function declarations that are not | |
| 111 | 27 part of the official OpenACC or OpenMP user interfaces. There are |
| 28 declarations in here that are part of the GNU Offloading and Multi | |
| 29 Processing ABI, in that the compiler is required to know about them | |
| 30 and use them. | |
| 0 | 31 |
| 32 The convention is that the all caps prefix "GOMP" is used group items | |
| 33 that are part of the external ABI, and the lower case prefix "gomp" | |
| 34 is used group items that are completely private to the library. */ | |
| 35 | |
| 36 #ifndef LIBGOMP_H | |
| 37 #define LIBGOMP_H 1 | |
| 38 | |
| 111 | 39 #ifndef _LIBGOMP_CHECKING_ |
| 40 /* Define to 1 to perform internal sanity checks. */ | |
| 41 #define _LIBGOMP_CHECKING_ 0 | |
| 42 #endif | |
| 43 | |
| 0 | 44 #include "config.h" |
| 45 #include "gstdint.h" | |
| 111 | 46 #include "libgomp-plugin.h" |
| 131 | 47 #include "gomp-constants.h" |
| 0 | 48 |
| 111 | 49 #ifdef HAVE_PTHREAD_H |
| 0 | 50 #include <pthread.h> |
| 111 | 51 #endif |
| 0 | 52 #include <stdbool.h> |
| 111 | 53 #include <stdlib.h> |
| 54 #include <stdarg.h> | |
| 55 | |
| 56 /* Needed for memset in priority_queue.c. */ | |
| 57 #if _LIBGOMP_CHECKING_ | |
| 58 # ifdef STRING_WITH_STRINGS | |
| 59 # include <string.h> | |
| 60 # include <strings.h> | |
| 61 # else | |
| 62 # ifdef HAVE_STRING_H | |
| 63 # include <string.h> | |
| 64 # else | |
| 65 # ifdef HAVE_STRINGS_H | |
| 66 # include <strings.h> | |
| 67 # endif | |
| 68 # endif | |
| 69 # endif | |
| 70 #endif | |
| 0 | 71 |
| 72 #ifdef HAVE_ATTRIBUTE_VISIBILITY | |
| 73 # pragma GCC visibility push(hidden) | |
| 74 #endif | |
| 75 | |
| 111 | 76 /* If we were a C++ library, we'd get this from <std/atomic>. */ |
| 77 enum memmodel | |
| 78 { | |
| 79 MEMMODEL_RELAXED = 0, | |
| 80 MEMMODEL_CONSUME = 1, | |
| 81 MEMMODEL_ACQUIRE = 2, | |
| 82 MEMMODEL_RELEASE = 3, | |
| 83 MEMMODEL_ACQ_REL = 4, | |
| 84 MEMMODEL_SEQ_CST = 5 | |
| 85 }; | |
| 86 | |
| 87 /* alloc.c */ | |
| 88 | |
| 89 extern void *gomp_malloc (size_t) __attribute__((malloc)); | |
| 90 extern void *gomp_malloc_cleared (size_t) __attribute__((malloc)); | |
| 91 extern void *gomp_realloc (void *, size_t); | |
| 92 | |
| 93 /* Avoid conflicting prototypes of alloca() in system headers by using | |
| 94 GCC's builtin alloca(). */ | |
| 95 #define gomp_alloca(x) __builtin_alloca(x) | |
| 96 | |
| 97 /* error.c */ | |
| 98 | |
| 99 extern void gomp_vdebug (int, const char *, va_list); | |
| 100 extern void gomp_debug (int, const char *, ...) | |
| 101 __attribute__ ((format (printf, 2, 3))); | |
| 102 #define gomp_vdebug(KIND, FMT, VALIST) \ | |
| 103 do { \ | |
| 104 if (__builtin_expect (gomp_debug_var, 0)) \ | |
| 105 (gomp_vdebug) ((KIND), (FMT), (VALIST)); \ | |
| 106 } while (0) | |
| 107 #define gomp_debug(KIND, ...) \ | |
| 108 do { \ | |
| 109 if (__builtin_expect (gomp_debug_var, 0)) \ | |
| 110 (gomp_debug) ((KIND), __VA_ARGS__); \ | |
| 111 } while (0) | |
| 112 extern void gomp_verror (const char *, va_list); | |
| 113 extern void gomp_error (const char *, ...) | |
| 114 __attribute__ ((format (printf, 1, 2))); | |
| 115 extern void gomp_vfatal (const char *, va_list) | |
| 116 __attribute__ ((noreturn)); | |
| 117 extern void gomp_fatal (const char *, ...) | |
| 118 __attribute__ ((noreturn, format (printf, 1, 2))); | |
| 119 | |
| 120 struct gomp_task; | |
| 121 struct gomp_taskgroup; | |
| 122 struct htab; | |
| 123 | |
| 124 #include "priority_queue.h" | |
| 0 | 125 #include "sem.h" |
| 126 #include "mutex.h" | |
| 127 #include "bar.h" | |
| 111 | 128 #include "simple-bar.h" |
| 0 | 129 #include "ptrlock.h" |
| 130 | |
| 131 | |
| 132 /* This structure contains the data to control one work-sharing construct, | |
| 133 either a LOOP (FOR/DO) or a SECTIONS. */ | |
| 134 | |
| 135 enum gomp_schedule_type | |
| 136 { | |
| 137 GFS_RUNTIME, | |
| 138 GFS_STATIC, | |
| 139 GFS_DYNAMIC, | |
| 140 GFS_GUIDED, | |
| 141 GFS_AUTO | |
| 142 }; | |
| 143 | |
| 111 | 144 struct gomp_doacross_work_share |
| 145 { | |
| 146 union { | |
| 147 /* chunk_size copy, as ws->chunk_size is multiplied by incr for | |
| 148 GFS_DYNAMIC. */ | |
| 149 long chunk_size; | |
| 150 /* Likewise, but for ull implementation. */ | |
| 151 unsigned long long chunk_size_ull; | |
| 152 /* For schedule(static,0) this is the number | |
| 153 of iterations assigned to the last thread, i.e. number of | |
| 154 iterations / number of threads. */ | |
| 155 long q; | |
| 156 /* Likewise, but for ull implementation. */ | |
| 157 unsigned long long q_ull; | |
| 158 }; | |
| 159 /* Size of each array entry (padded to cache line size). */ | |
| 160 unsigned long elt_sz; | |
| 161 /* Number of dimensions in sink vectors. */ | |
| 162 unsigned int ncounts; | |
| 163 /* True if the iterations can be flattened. */ | |
| 164 bool flattened; | |
| 165 /* Actual array (of elt_sz sized units), aligned to cache line size. | |
| 166 This is indexed by team_id for GFS_STATIC and outermost iteration | |
| 167 / chunk_size for other schedules. */ | |
| 168 unsigned char *array; | |
| 169 /* These two are only used for schedule(static,0). */ | |
| 170 /* This one is number of iterations % number of threads. */ | |
| 171 long t; | |
| 172 union { | |
| 173 /* And this one is cached t * (q + 1). */ | |
| 174 long boundary; | |
| 175 /* Likewise, but for the ull implementation. */ | |
| 176 unsigned long long boundary_ull; | |
| 177 }; | |
| 178 /* Array of shift counts for each dimension if they can be flattened. */ | |
| 179 unsigned int shift_counts[]; | |
| 180 }; | |
| 181 | |
| 0 | 182 struct gomp_work_share |
| 183 { | |
| 184 /* This member records the SCHEDULE clause to be used for this construct. | |
| 185 The user specification of "runtime" will already have been resolved. | |
| 186 If this is a SECTIONS construct, this value will always be DYNAMIC. */ | |
| 187 enum gomp_schedule_type sched; | |
| 188 | |
| 189 int mode; | |
| 190 | |
| 191 union { | |
| 192 struct { | |
| 193 /* This is the chunk_size argument to the SCHEDULE clause. */ | |
| 194 long chunk_size; | |
| 195 | |
| 196 /* This is the iteration end point. If this is a SECTIONS construct, | |
| 197 this is the number of contained sections. */ | |
| 198 long end; | |
| 199 | |
| 200 /* This is the iteration step. If this is a SECTIONS construct, this | |
| 201 is always 1. */ | |
| 202 long incr; | |
| 203 }; | |
| 204 | |
| 205 struct { | |
| 206 /* The same as above, but for the unsigned long long loop variants. */ | |
| 207 unsigned long long chunk_size_ull; | |
| 208 unsigned long long end_ull; | |
| 209 unsigned long long incr_ull; | |
| 210 }; | |
| 211 }; | |
| 212 | |
| 111 | 213 union { |
| 214 /* This is a circular queue that details which threads will be allowed | |
| 215 into the ordered region and in which order. When a thread allocates | |
| 216 iterations on which it is going to work, it also registers itself at | |
| 217 the end of the array. When a thread reaches the ordered region, it | |
| 218 checks to see if it is the one at the head of the queue. If not, it | |
| 219 blocks on its RELEASE semaphore. */ | |
| 220 unsigned *ordered_team_ids; | |
| 221 | |
| 222 /* This is a pointer to DOACROSS work share data. */ | |
| 223 struct gomp_doacross_work_share *doacross; | |
| 224 }; | |
| 0 | 225 |
| 226 /* This is the number of threads that have registered themselves in | |
| 227 the circular queue ordered_team_ids. */ | |
| 228 unsigned ordered_num_used; | |
| 229 | |
| 230 /* This is the team_id of the currently acknowledged owner of the ordered | |
| 231 section, or -1u if the ordered section has not been acknowledged by | |
| 232 any thread. This is distinguished from the thread that is *allowed* | |
| 233 to take the section next. */ | |
| 234 unsigned ordered_owner; | |
| 235 | |
| 236 /* This is the index into the circular queue ordered_team_ids of the | |
| 237 current thread that's allowed into the ordered reason. */ | |
| 238 unsigned ordered_cur; | |
| 239 | |
| 240 /* This is a chain of allocated gomp_work_share blocks, valid only | |
| 241 in the first gomp_work_share struct in the block. */ | |
| 242 struct gomp_work_share *next_alloc; | |
| 243 | |
| 244 /* The above fields are written once during workshare initialization, | |
| 245 or related to ordered worksharing. Make sure the following fields | |
| 246 are in a different cache line. */ | |
| 247 | |
| 248 /* This lock protects the update of the following members. */ | |
| 249 gomp_mutex_t lock __attribute__((aligned (64))); | |
| 250 | |
| 251 /* This is the count of the number of threads that have exited the work | |
| 252 share construct. If the construct was marked nowait, they have moved on | |
| 253 to other work; otherwise they're blocked on a barrier. The last member | |
| 254 of the team to exit the work share construct must deallocate it. */ | |
| 255 unsigned threads_completed; | |
| 256 | |
| 257 union { | |
| 258 /* This is the next iteration value to be allocated. In the case of | |
| 259 GFS_STATIC loops, this the iteration start point and never changes. */ | |
| 260 long next; | |
| 261 | |
| 262 /* The same, but with unsigned long long type. */ | |
| 263 unsigned long long next_ull; | |
| 264 | |
| 265 /* This is the returned data structure for SINGLE COPYPRIVATE. */ | |
| 266 void *copyprivate; | |
| 267 }; | |
| 268 | |
| 269 union { | |
| 270 /* Link to gomp_work_share struct for next work sharing construct | |
| 271 encountered after this one. */ | |
| 272 gomp_ptrlock_t next_ws; | |
| 273 | |
| 274 /* gomp_work_share structs are chained in the free work share cache | |
| 275 through this. */ | |
| 276 struct gomp_work_share *next_free; | |
| 277 }; | |
| 278 | |
| 279 /* If only few threads are in the team, ordered_team_ids can point | |
| 280 to this array which fills the padding at the end of this struct. */ | |
| 281 unsigned inline_ordered_team_ids[0]; | |
| 282 }; | |
| 283 | |
| 284 /* This structure contains all of the thread-local data associated with | |
| 285 a thread team. This is the data that must be saved when a thread | |
| 286 encounters a nested PARALLEL construct. */ | |
| 287 | |
| 288 struct gomp_team_state | |
| 289 { | |
| 290 /* This is the team of which the thread is currently a member. */ | |
| 291 struct gomp_team *team; | |
| 292 | |
| 293 /* This is the work share construct which this thread is currently | |
| 294 processing. Recall that with NOWAIT, not all threads may be | |
| 295 processing the same construct. */ | |
| 296 struct gomp_work_share *work_share; | |
| 297 | |
| 298 /* This is the previous work share construct or NULL if there wasn't any. | |
| 299 When all threads are done with the current work sharing construct, | |
| 300 the previous one can be freed. The current one can't, as its | |
| 301 next_ws field is used. */ | |
| 302 struct gomp_work_share *last_work_share; | |
| 303 | |
| 304 /* This is the ID of this thread within the team. This value is | |
| 305 guaranteed to be between 0 and N-1, where N is the number of | |
| 306 threads in the team. */ | |
| 307 unsigned team_id; | |
| 308 | |
| 309 /* Nesting level. */ | |
| 310 unsigned level; | |
| 311 | |
| 312 /* Active nesting level. Only active parallel regions are counted. */ | |
| 313 unsigned active_level; | |
| 314 | |
| 111 | 315 /* Place-partition-var, offset and length into gomp_places_list array. */ |
| 316 unsigned place_partition_off; | |
| 317 unsigned place_partition_len; | |
| 318 | |
| 0 | 319 #ifdef HAVE_SYNC_BUILTINS |
| 320 /* Number of single stmts encountered. */ | |
| 321 unsigned long single_count; | |
| 322 #endif | |
| 323 | |
| 324 /* For GFS_RUNTIME loops that resolved to GFS_STATIC, this is the | |
| 325 trip number through the loop. So first time a particular loop | |
| 326 is encountered this number is 0, the second time through the loop | |
| 327 is 1, etc. This is unused when the compiler knows in advance that | |
| 328 the loop is statically scheduled. */ | |
| 329 unsigned long static_trip; | |
| 330 }; | |
| 331 | |
| 111 | 332 struct target_mem_desc; |
| 333 | |
| 334 /* These are the OpenMP 4.0 Internal Control Variables described in | |
| 0 | 335 section 2.3.1. Those described as having one copy per task are |
| 336 stored within the structure; those described as having one copy | |
| 337 for the whole program are (naturally) global variables. */ | |
| 111 | 338 |
| 0 | 339 struct gomp_task_icv |
| 340 { | |
| 341 unsigned long nthreads_var; | |
| 342 enum gomp_schedule_type run_sched_var; | |
| 111 | 343 int run_sched_chunk_size; |
| 344 int default_device_var; | |
| 345 unsigned int thread_limit_var; | |
| 0 | 346 bool dyn_var; |
| 347 bool nest_var; | |
| 111 | 348 char bind_var; |
| 349 /* Internal ICV. */ | |
| 350 struct target_mem_desc *target_data; | |
| 0 | 351 }; |
| 352 | |
| 353 extern struct gomp_task_icv gomp_global_icv; | |
| 354 #ifndef HAVE_SYNC_BUILTINS | |
| 111 | 355 extern gomp_mutex_t gomp_managed_threads_lock; |
| 0 | 356 #endif |
| 357 extern unsigned long gomp_max_active_levels_var; | |
| 111 | 358 extern bool gomp_cancel_var; |
| 359 extern int gomp_max_task_priority_var; | |
| 0 | 360 extern unsigned long long gomp_spin_count_var, gomp_throttled_spin_count_var; |
| 361 extern unsigned long gomp_available_cpus, gomp_managed_threads; | |
| 111 | 362 extern unsigned long *gomp_nthreads_var_list, gomp_nthreads_var_list_len; |
| 363 extern char *gomp_bind_var_list; | |
| 364 extern unsigned long gomp_bind_var_list_len; | |
| 365 extern void **gomp_places_list; | |
| 366 extern unsigned long gomp_places_list_len; | |
| 367 extern unsigned int gomp_num_teams_var; | |
| 368 extern int gomp_debug_var; | |
| 369 extern int goacc_device_num; | |
| 370 extern char *goacc_device_type; | |
| 131 | 371 extern int goacc_default_dims[GOMP_DIM_MAX]; |
| 0 | 372 |
| 373 enum gomp_task_kind | |
| 374 { | |
| 111 | 375 /* Implicit task. */ |
| 0 | 376 GOMP_TASK_IMPLICIT, |
| 111 | 377 /* Undeferred task. */ |
| 378 GOMP_TASK_UNDEFERRED, | |
| 379 /* Task created by GOMP_task and waiting to be run. */ | |
| 0 | 380 GOMP_TASK_WAITING, |
| 111 | 381 /* Task currently executing or scheduled and about to execute. */ |
| 382 GOMP_TASK_TIED, | |
| 383 /* Used for target tasks that have vars mapped and async run started, | |
| 384 but not yet completed. Once that completes, they will be readded | |
| 385 into the queues as GOMP_TASK_WAITING in order to perform the var | |
| 386 unmapping. */ | |
| 387 GOMP_TASK_ASYNC_RUNNING | |
| 388 }; | |
| 389 | |
| 390 struct gomp_task_depend_entry | |
| 391 { | |
| 392 /* Address of dependency. */ | |
| 393 void *addr; | |
| 394 struct gomp_task_depend_entry *next; | |
| 395 struct gomp_task_depend_entry *prev; | |
| 396 /* Task that provides the dependency in ADDR. */ | |
| 397 struct gomp_task *task; | |
| 398 /* Depend entry is of type "IN". */ | |
| 399 bool is_in; | |
| 400 bool redundant; | |
| 401 bool redundant_out; | |
| 402 }; | |
| 403 | |
| 404 struct gomp_dependers_vec | |
| 405 { | |
| 406 size_t n_elem; | |
| 407 size_t allocated; | |
| 408 struct gomp_task *elem[]; | |
| 409 }; | |
| 410 | |
| 411 /* Used when in GOMP_taskwait or in gomp_task_maybe_wait_for_dependencies. */ | |
| 412 | |
| 413 struct gomp_taskwait | |
| 414 { | |
| 415 bool in_taskwait; | |
| 416 bool in_depend_wait; | |
| 417 /* Number of tasks we are waiting for. */ | |
| 418 size_t n_depend; | |
| 419 gomp_sem_t taskwait_sem; | |
| 0 | 420 }; |
| 421 | |
| 422 /* This structure describes a "task" to be run by a thread. */ | |
| 423 | |
| 424 struct gomp_task | |
| 425 { | |
| 111 | 426 /* Parent of this task. */ |
| 0 | 427 struct gomp_task *parent; |
| 111 | 428 /* Children of this task. */ |
| 429 struct priority_queue children_queue; | |
| 430 /* Taskgroup this task belongs in. */ | |
| 431 struct gomp_taskgroup *taskgroup; | |
| 432 /* Tasks that depend on this task. */ | |
| 433 struct gomp_dependers_vec *dependers; | |
| 434 struct htab *depend_hash; | |
| 435 struct gomp_taskwait *taskwait; | |
| 436 /* Number of items in DEPEND. */ | |
| 437 size_t depend_count; | |
| 438 /* Number of tasks this task depends on. Once this counter reaches | |
| 439 0, we have no unsatisfied dependencies, and this task can be put | |
| 440 into the various queues to be scheduled. */ | |
| 441 size_t num_dependees; | |
| 442 | |
| 443 /* Priority of this task. */ | |
| 444 int priority; | |
| 445 /* The priority node for this task in each of the different queues. | |
| 446 We put this here to avoid allocating space for each priority | |
| 447 node. Then we play offsetof() games to convert between pnode[] | |
| 448 entries and the gomp_task in which they reside. */ | |
| 449 struct priority_node pnode[3]; | |
| 450 | |
| 0 | 451 struct gomp_task_icv icv; |
| 452 void (*fn) (void *); | |
| 453 void *fn_data; | |
| 454 enum gomp_task_kind kind; | |
| 455 bool in_tied_task; | |
| 111 | 456 bool final_task; |
| 457 bool copy_ctors_done; | |
| 458 /* Set for undeferred tasks with unsatisfied dependencies which | |
| 459 block further execution of their parent until the dependencies | |
| 460 are satisfied. */ | |
| 461 bool parent_depends_on; | |
| 462 /* Dependencies provided and/or needed for this task. DEPEND_COUNT | |
| 463 is the number of items available. */ | |
| 464 struct gomp_task_depend_entry depend[]; | |
| 465 }; | |
| 466 | |
| 467 /* This structure describes a single #pragma omp taskgroup. */ | |
| 468 | |
| 469 struct gomp_taskgroup | |
| 470 { | |
| 471 struct gomp_taskgroup *prev; | |
| 472 /* Queue of tasks that belong in this taskgroup. */ | |
| 473 struct priority_queue taskgroup_queue; | |
| 474 bool in_taskgroup_wait; | |
| 475 bool cancelled; | |
| 476 gomp_sem_t taskgroup_sem; | |
| 477 size_t num_children; | |
| 478 }; | |
| 479 | |
| 480 /* Various state of OpenMP async offloading tasks. */ | |
| 481 enum gomp_target_task_state | |
| 482 { | |
| 483 GOMP_TARGET_TASK_DATA, | |
| 484 GOMP_TARGET_TASK_BEFORE_MAP, | |
| 485 GOMP_TARGET_TASK_FALLBACK, | |
| 486 GOMP_TARGET_TASK_READY_TO_RUN, | |
| 487 GOMP_TARGET_TASK_RUNNING, | |
| 488 GOMP_TARGET_TASK_FINISHED | |
| 489 }; | |
| 490 | |
| 491 /* This structure describes a target task. */ | |
| 492 | |
| 493 struct gomp_target_task | |
| 494 { | |
| 495 struct gomp_device_descr *devicep; | |
| 496 void (*fn) (void *); | |
| 497 size_t mapnum; | |
| 498 size_t *sizes; | |
| 499 unsigned short *kinds; | |
| 500 unsigned int flags; | |
| 501 enum gomp_target_task_state state; | |
| 502 struct target_mem_desc *tgt; | |
| 503 struct gomp_task *task; | |
| 504 struct gomp_team *team; | |
| 505 /* Device-specific target arguments. */ | |
| 506 void **args; | |
| 507 void *hostaddrs[]; | |
| 0 | 508 }; |
| 509 | |
| 510 /* This structure describes a "team" of threads. These are the threads | |
| 511 that are spawned by a PARALLEL constructs, as well as the work sharing | |
| 512 constructs that the team encounters. */ | |
| 513 | |
| 514 struct gomp_team | |
| 515 { | |
| 516 /* This is the number of threads in the current team. */ | |
| 517 unsigned nthreads; | |
| 518 | |
| 519 /* This is number of gomp_work_share structs that have been allocated | |
| 520 as a block last time. */ | |
| 521 unsigned work_share_chunk; | |
| 522 | |
| 523 /* This is the saved team state that applied to a master thread before | |
| 524 the current thread was created. */ | |
| 525 struct gomp_team_state prev_ts; | |
| 526 | |
| 527 /* This semaphore should be used by the master thread instead of its | |
| 528 "native" semaphore in the thread structure. Required for nested | |
| 529 parallels, as the master is a member of two teams. */ | |
| 530 gomp_sem_t master_release; | |
| 531 | |
| 532 /* This points to an array with pointers to the release semaphore | |
| 533 of the threads in the team. */ | |
| 534 gomp_sem_t **ordered_release; | |
| 535 | |
| 111 | 536 /* List of work shares on which gomp_fini_work_share hasn't been |
| 537 called yet. If the team hasn't been cancelled, this should be | |
| 538 equal to each thr->ts.work_share, but otherwise it can be a possibly | |
| 539 long list of workshares. */ | |
| 540 struct gomp_work_share *work_shares_to_free; | |
| 541 | |
| 0 | 542 /* List of gomp_work_share structs chained through next_free fields. |
| 543 This is populated and taken off only by the first thread in the | |
| 544 team encountering a new work sharing construct, in a critical | |
| 545 section. */ | |
| 546 struct gomp_work_share *work_share_list_alloc; | |
| 547 | |
| 548 /* List of gomp_work_share structs freed by free_work_share. New | |
| 549 entries are atomically added to the start of the list, and | |
| 550 alloc_work_share can safely only move all but the first entry | |
| 551 to work_share_list alloc, as free_work_share can happen concurrently | |
| 552 with alloc_work_share. */ | |
| 553 struct gomp_work_share *work_share_list_free; | |
| 554 | |
| 555 #ifdef HAVE_SYNC_BUILTINS | |
| 556 /* Number of simple single regions encountered by threads in this | |
| 557 team. */ | |
| 558 unsigned long single_count; | |
| 559 #else | |
| 560 /* Mutex protecting addition of workshares to work_share_list_free. */ | |
| 561 gomp_mutex_t work_share_list_free_lock; | |
| 562 #endif | |
| 563 | |
| 564 /* This barrier is used for most synchronization of the team. */ | |
| 565 gomp_barrier_t barrier; | |
| 566 | |
| 567 /* Initial work shares, to avoid allocating any gomp_work_share | |
| 568 structs in the common case. */ | |
| 569 struct gomp_work_share work_shares[8]; | |
| 570 | |
| 571 gomp_mutex_t task_lock; | |
| 111 | 572 /* Scheduled tasks. */ |
| 573 struct priority_queue task_queue; | |
| 574 /* Number of all GOMP_TASK_{WAITING,TIED} tasks in the team. */ | |
| 575 unsigned int task_count; | |
| 576 /* Number of GOMP_TASK_WAITING tasks currently waiting to be scheduled. */ | |
| 577 unsigned int task_queued_count; | |
| 578 /* Number of GOMP_TASK_{WAITING,TIED} tasks currently running | |
| 579 directly in gomp_barrier_handle_tasks; tasks spawned | |
| 580 from e.g. GOMP_taskwait or GOMP_taskgroup_end don't count, even when | |
| 581 that is called from a task run from gomp_barrier_handle_tasks. | |
| 582 task_running_count should be always <= team->nthreads, | |
| 583 and if current task isn't in_tied_task, then it will be | |
| 584 even < team->nthreads. */ | |
| 585 unsigned int task_running_count; | |
| 586 int work_share_cancelled; | |
| 587 int team_cancelled; | |
| 0 | 588 |
| 589 /* This array contains structures for implicit tasks. */ | |
| 590 struct gomp_task implicit_task[]; | |
| 591 }; | |
| 592 | |
| 593 /* This structure contains all data that is private to libgomp and is | |
| 594 allocated per thread. */ | |
| 595 | |
| 596 struct gomp_thread | |
| 597 { | |
| 598 /* This is the function that the thread should run upon launch. */ | |
| 599 void (*fn) (void *data); | |
| 600 void *data; | |
| 601 | |
| 602 /* This is the current team state for this thread. The ts.team member | |
| 603 is NULL only if the thread is idle. */ | |
| 604 struct gomp_team_state ts; | |
| 605 | |
| 606 /* This is the task that the thread is currently executing. */ | |
| 607 struct gomp_task *task; | |
| 608 | |
| 609 /* This semaphore is used for ordered loops. */ | |
| 610 gomp_sem_t release; | |
| 611 | |
| 111 | 612 /* Place this thread is bound to plus one, or zero if not bound |
| 613 to any place. */ | |
| 614 unsigned int place; | |
| 615 | |
| 616 /* User pthread thread pool */ | |
| 0 | 617 struct gomp_thread_pool *thread_pool; |
| 618 }; | |
| 619 | |
| 620 | |
| 621 struct gomp_thread_pool | |
| 622 { | |
| 623 /* This array manages threads spawned from the top level, which will | |
| 624 return to the idle loop once the current PARALLEL construct ends. */ | |
| 625 struct gomp_thread **threads; | |
| 626 unsigned threads_size; | |
| 627 unsigned threads_used; | |
| 111 | 628 /* The last team is used for non-nested teams to delay their destruction to |
| 629 make sure all the threads in the team move on to the pool's barrier before | |
| 630 the team's barrier is destroyed. */ | |
| 0 | 631 struct gomp_team *last_team; |
| 111 | 632 /* Number of threads running in this contention group. */ |
| 633 unsigned long threads_busy; | |
| 0 | 634 |
| 111 | 635 /* This barrier holds and releases threads waiting in thread pools. */ |
| 636 gomp_simple_barrier_t threads_dock; | |
| 637 }; | |
| 638 | |
| 639 enum gomp_cancel_kind | |
| 640 { | |
| 641 GOMP_CANCEL_PARALLEL = 1, | |
| 642 GOMP_CANCEL_LOOP = 2, | |
| 643 GOMP_CANCEL_FOR = GOMP_CANCEL_LOOP, | |
| 644 GOMP_CANCEL_DO = GOMP_CANCEL_LOOP, | |
| 645 GOMP_CANCEL_SECTIONS = 4, | |
| 646 GOMP_CANCEL_TASKGROUP = 8 | |
| 0 | 647 }; |
| 648 | |
| 649 /* ... and here is that TLS data. */ | |
| 650 | |
| 111 | 651 #if defined __nvptx__ |
| 652 extern struct gomp_thread *nvptx_thrs __attribute__((shared)); | |
| 653 static inline struct gomp_thread *gomp_thread (void) | |
| 654 { | |
| 655 int tid; | |
| 656 asm ("mov.u32 %0, %%tid.y;" : "=r" (tid)); | |
| 657 return nvptx_thrs + tid; | |
| 658 } | |
| 659 #elif defined HAVE_TLS || defined USE_EMUTLS | |
| 0 | 660 extern __thread struct gomp_thread gomp_tls_data; |
| 661 static inline struct gomp_thread *gomp_thread (void) | |
| 662 { | |
| 663 return &gomp_tls_data; | |
| 664 } | |
| 665 #else | |
| 666 extern pthread_key_t gomp_tls_key; | |
| 667 static inline struct gomp_thread *gomp_thread (void) | |
| 668 { | |
| 669 return pthread_getspecific (gomp_tls_key); | |
| 670 } | |
| 671 #endif | |
| 672 | |
| 673 extern struct gomp_task_icv *gomp_new_icv (void); | |
| 674 | |
| 675 /* Here's how to access the current copy of the ICVs. */ | |
| 676 | |
| 677 static inline struct gomp_task_icv *gomp_icv (bool write) | |
| 678 { | |
| 679 struct gomp_task *task = gomp_thread ()->task; | |
| 680 if (task) | |
| 681 return &task->icv; | |
| 682 else if (write) | |
| 683 return gomp_new_icv (); | |
| 684 else | |
| 685 return &gomp_global_icv; | |
| 686 } | |
| 687 | |
| 111 | 688 #ifdef LIBGOMP_USE_PTHREADS |
| 0 | 689 /* The attributes to be used during thread creation. */ |
| 690 extern pthread_attr_t gomp_thread_attr; | |
| 691 | |
| 111 | 692 extern pthread_key_t gomp_thread_destructor; |
| 693 #endif | |
| 0 | 694 |
| 695 /* Function prototypes. */ | |
| 696 | |
| 697 /* affinity.c */ | |
| 698 | |
| 699 extern void gomp_init_affinity (void); | |
| 111 | 700 #ifdef LIBGOMP_USE_PTHREADS |
| 701 extern void gomp_init_thread_affinity (pthread_attr_t *, unsigned int); | |
| 702 #endif | |
| 703 extern void **gomp_affinity_alloc (unsigned long, bool); | |
| 704 extern void gomp_affinity_init_place (void *); | |
| 705 extern bool gomp_affinity_add_cpus (void *, unsigned long, unsigned long, | |
| 706 long, bool); | |
| 707 extern bool gomp_affinity_remove_cpu (void *, unsigned long); | |
| 708 extern bool gomp_affinity_copy_place (void *, void *, long); | |
| 709 extern bool gomp_affinity_same_place (void *, void *); | |
| 710 extern bool gomp_affinity_finalize_place_list (bool); | |
| 711 extern bool gomp_affinity_init_level (int, unsigned long, bool); | |
| 712 extern void gomp_affinity_print_place (void *); | |
| 713 extern void gomp_get_place_proc_ids_8 (int, int64_t *); | |
| 0 | 714 |
| 715 /* iter.c */ | |
| 716 | |
| 717 extern int gomp_iter_static_next (long *, long *); | |
| 718 extern bool gomp_iter_dynamic_next_locked (long *, long *); | |
| 719 extern bool gomp_iter_guided_next_locked (long *, long *); | |
| 720 | |
| 721 #ifdef HAVE_SYNC_BUILTINS | |
| 722 extern bool gomp_iter_dynamic_next (long *, long *); | |
| 723 extern bool gomp_iter_guided_next (long *, long *); | |
| 724 #endif | |
| 725 | |
| 726 /* iter_ull.c */ | |
| 727 | |
| 728 extern int gomp_iter_ull_static_next (unsigned long long *, | |
| 729 unsigned long long *); | |
| 730 extern bool gomp_iter_ull_dynamic_next_locked (unsigned long long *, | |
| 731 unsigned long long *); | |
| 732 extern bool gomp_iter_ull_guided_next_locked (unsigned long long *, | |
| 733 unsigned long long *); | |
| 734 | |
| 735 #if defined HAVE_SYNC_BUILTINS && defined __LP64__ | |
| 736 extern bool gomp_iter_ull_dynamic_next (unsigned long long *, | |
| 737 unsigned long long *); | |
| 738 extern bool gomp_iter_ull_guided_next (unsigned long long *, | |
| 739 unsigned long long *); | |
| 740 #endif | |
| 741 | |
| 742 /* ordered.c */ | |
| 743 | |
| 744 extern void gomp_ordered_first (void); | |
| 745 extern void gomp_ordered_last (void); | |
| 746 extern void gomp_ordered_next (void); | |
| 747 extern void gomp_ordered_static_init (void); | |
| 748 extern void gomp_ordered_static_next (void); | |
| 749 extern void gomp_ordered_sync (void); | |
| 111 | 750 extern void gomp_doacross_init (unsigned, long *, long); |
| 751 extern void gomp_doacross_ull_init (unsigned, unsigned long long *, | |
| 752 unsigned long long); | |
| 0 | 753 |
| 754 /* parallel.c */ | |
| 755 | |
| 756 extern unsigned gomp_resolve_num_threads (unsigned, unsigned); | |
| 757 | |
| 758 /* proc.c (in config/) */ | |
| 759 | |
| 760 extern void gomp_init_num_threads (void); | |
| 761 extern unsigned gomp_dynamic_max_threads (void); | |
| 762 | |
| 763 /* task.c */ | |
| 764 | |
| 765 extern void gomp_init_task (struct gomp_task *, struct gomp_task *, | |
| 766 struct gomp_task_icv *); | |
| 767 extern void gomp_end_task (void); | |
| 768 extern void gomp_barrier_handle_tasks (gomp_barrier_state_t); | |
| 111 | 769 extern void gomp_task_maybe_wait_for_dependencies (void **); |
| 770 extern bool gomp_create_target_task (struct gomp_device_descr *, | |
| 771 void (*) (void *), size_t, void **, | |
| 772 size_t *, unsigned short *, unsigned int, | |
| 773 void **, void **, | |
| 774 enum gomp_target_task_state); | |
| 0 | 775 |
| 776 static void inline | |
| 777 gomp_finish_task (struct gomp_task *task) | |
| 778 { | |
| 111 | 779 if (__builtin_expect (task->depend_hash != NULL, 0)) |
| 780 free (task->depend_hash); | |
| 0 | 781 } |
| 782 | |
| 783 /* team.c */ | |
| 784 | |
| 785 extern struct gomp_team *gomp_new_team (unsigned); | |
| 786 extern void gomp_team_start (void (*) (void *), void *, unsigned, | |
| 111 | 787 unsigned, struct gomp_team *); |
| 0 | 788 extern void gomp_team_end (void); |
| 111 | 789 extern void gomp_free_thread (void *); |
| 790 | |
| 791 /* target.c */ | |
| 792 | |
| 793 extern void gomp_init_targets_once (void); | |
| 794 extern int gomp_get_num_devices (void); | |
| 795 extern bool gomp_target_task_fn (void *); | |
| 796 | |
| 797 /* Splay tree definitions. */ | |
| 798 typedef struct splay_tree_node_s *splay_tree_node; | |
| 799 typedef struct splay_tree_s *splay_tree; | |
| 800 typedef struct splay_tree_key_s *splay_tree_key; | |
| 801 | |
| 802 struct target_var_desc { | |
| 803 /* Splay key. */ | |
| 804 splay_tree_key key; | |
| 805 /* True if data should be copied from device to host at the end. */ | |
| 806 bool copy_from; | |
| 807 /* True if data always should be copied from device to host at the end. */ | |
| 808 bool always_copy_from; | |
| 809 /* Relative offset against key host_start. */ | |
| 810 uintptr_t offset; | |
| 811 /* Actual length. */ | |
| 812 uintptr_t length; | |
| 813 }; | |
| 814 | |
| 815 struct target_mem_desc { | |
| 816 /* Reference count. */ | |
| 817 uintptr_t refcount; | |
| 818 /* All the splay nodes allocated together. */ | |
| 819 splay_tree_node array; | |
| 820 /* Start of the target region. */ | |
| 821 uintptr_t tgt_start; | |
| 822 /* End of the targer region. */ | |
| 823 uintptr_t tgt_end; | |
| 824 /* Handle to free. */ | |
| 825 void *to_free; | |
| 826 /* Previous target_mem_desc. */ | |
| 827 struct target_mem_desc *prev; | |
| 828 /* Number of items in following list. */ | |
| 829 size_t list_count; | |
| 830 | |
| 831 /* Corresponding target device descriptor. */ | |
| 832 struct gomp_device_descr *device_descr; | |
| 833 | |
| 834 /* List of target items to remove (or decrease refcount) | |
| 835 at the end of region. */ | |
| 836 struct target_var_desc list[]; | |
| 837 }; | |
| 838 | |
| 839 /* Special value for refcount - infinity. */ | |
| 840 #define REFCOUNT_INFINITY (~(uintptr_t) 0) | |
| 841 /* Special value for refcount - tgt_offset contains target address of the | |
| 842 artificial pointer to "omp declare target link" object. */ | |
| 843 #define REFCOUNT_LINK (~(uintptr_t) 1) | |
| 844 | |
| 845 struct splay_tree_key_s { | |
| 846 /* Address of the host object. */ | |
| 847 uintptr_t host_start; | |
| 848 /* Address immediately after the host object. */ | |
| 849 uintptr_t host_end; | |
| 850 /* Descriptor of the target memory. */ | |
| 851 struct target_mem_desc *tgt; | |
| 852 /* Offset from tgt->tgt_start to the start of the target object. */ | |
| 853 uintptr_t tgt_offset; | |
| 854 /* Reference count. */ | |
| 855 uintptr_t refcount; | |
| 131 | 856 /* Dynamic reference count. */ |
| 857 uintptr_t dynamic_refcount; | |
| 111 | 858 /* Pointer to the original mapping of "omp declare target link" object. */ |
| 859 splay_tree_key link_key; | |
| 860 }; | |
| 861 | |
| 862 /* The comparison function. */ | |
| 863 | |
| 864 static inline int | |
| 865 splay_compare (splay_tree_key x, splay_tree_key y) | |
| 866 { | |
| 867 if (x->host_start == x->host_end | |
| 868 && y->host_start == y->host_end) | |
| 869 return 0; | |
| 870 if (x->host_end <= y->host_start) | |
| 871 return -1; | |
| 872 if (x->host_start >= y->host_end) | |
| 873 return 1; | |
| 874 return 0; | |
| 875 } | |
| 876 | |
| 877 #include "splay-tree.h" | |
| 878 | |
| 879 typedef struct acc_dispatch_t | |
| 880 { | |
| 881 /* This is a linked list of data mapped using the | |
| 882 acc_map_data/acc_unmap_data or "acc enter data"/"acc exit data" pragmas. | |
| 883 Unlike mapped_data in the goacc_thread struct, unmapping can | |
| 884 happen out-of-order with respect to mapping. */ | |
| 885 /* This is guarded by the lock in the "outer" struct gomp_device_descr. */ | |
| 886 struct target_mem_desc *data_environ; | |
| 887 | |
| 888 /* Execute. */ | |
| 889 __typeof (GOMP_OFFLOAD_openacc_exec) *exec_func; | |
| 890 | |
| 891 /* Async cleanup callback registration. */ | |
| 892 __typeof (GOMP_OFFLOAD_openacc_register_async_cleanup) | |
| 893 *register_async_cleanup_func; | |
| 894 | |
| 895 /* Asynchronous routines. */ | |
| 896 __typeof (GOMP_OFFLOAD_openacc_async_test) *async_test_func; | |
| 897 __typeof (GOMP_OFFLOAD_openacc_async_test_all) *async_test_all_func; | |
| 898 __typeof (GOMP_OFFLOAD_openacc_async_wait) *async_wait_func; | |
| 899 __typeof (GOMP_OFFLOAD_openacc_async_wait_async) *async_wait_async_func; | |
| 900 __typeof (GOMP_OFFLOAD_openacc_async_wait_all) *async_wait_all_func; | |
| 901 __typeof (GOMP_OFFLOAD_openacc_async_wait_all_async) | |
| 902 *async_wait_all_async_func; | |
| 903 __typeof (GOMP_OFFLOAD_openacc_async_set_async) *async_set_async_func; | |
| 904 | |
| 905 /* Create/destroy TLS data. */ | |
| 906 __typeof (GOMP_OFFLOAD_openacc_create_thread_data) *create_thread_data_func; | |
| 907 __typeof (GOMP_OFFLOAD_openacc_destroy_thread_data) | |
| 908 *destroy_thread_data_func; | |
| 909 | |
| 910 /* NVIDIA target specific routines. */ | |
| 911 struct { | |
| 912 __typeof (GOMP_OFFLOAD_openacc_cuda_get_current_device) | |
| 913 *get_current_device_func; | |
| 914 __typeof (GOMP_OFFLOAD_openacc_cuda_get_current_context) | |
| 915 *get_current_context_func; | |
| 916 __typeof (GOMP_OFFLOAD_openacc_cuda_get_stream) *get_stream_func; | |
| 917 __typeof (GOMP_OFFLOAD_openacc_cuda_set_stream) *set_stream_func; | |
| 918 } cuda; | |
| 919 } acc_dispatch_t; | |
| 920 | |
| 921 /* Various state of the accelerator device. */ | |
| 922 enum gomp_device_state | |
| 923 { | |
| 924 GOMP_DEVICE_UNINITIALIZED, | |
| 925 GOMP_DEVICE_INITIALIZED, | |
| 926 GOMP_DEVICE_FINALIZED | |
| 927 }; | |
| 928 | |
| 929 /* This structure describes accelerator device. | |
| 930 It contains name of the corresponding libgomp plugin, function handlers for | |
| 931 interaction with the device, ID-number of the device, and information about | |
| 932 mapped memory. */ | |
| 933 struct gomp_device_descr | |
| 934 { | |
| 935 /* Immutable data, which is only set during initialization, and which is not | |
| 936 guarded by the lock. */ | |
| 937 | |
| 938 /* The name of the device. */ | |
| 939 const char *name; | |
| 940 | |
| 941 /* Capabilities of device (supports OpenACC, OpenMP). */ | |
| 942 unsigned int capabilities; | |
| 943 | |
| 944 /* This is the ID number of device among devices of the same type. */ | |
| 945 int target_id; | |
| 946 | |
| 947 /* This is the TYPE of device. */ | |
| 948 enum offload_target_type type; | |
| 949 | |
| 950 /* Function handlers. */ | |
| 951 __typeof (GOMP_OFFLOAD_get_name) *get_name_func; | |
| 952 __typeof (GOMP_OFFLOAD_get_caps) *get_caps_func; | |
| 953 __typeof (GOMP_OFFLOAD_get_type) *get_type_func; | |
| 954 __typeof (GOMP_OFFLOAD_get_num_devices) *get_num_devices_func; | |
| 955 __typeof (GOMP_OFFLOAD_init_device) *init_device_func; | |
| 956 __typeof (GOMP_OFFLOAD_fini_device) *fini_device_func; | |
| 957 __typeof (GOMP_OFFLOAD_version) *version_func; | |
| 958 __typeof (GOMP_OFFLOAD_load_image) *load_image_func; | |
| 959 __typeof (GOMP_OFFLOAD_unload_image) *unload_image_func; | |
| 960 __typeof (GOMP_OFFLOAD_alloc) *alloc_func; | |
| 961 __typeof (GOMP_OFFLOAD_free) *free_func; | |
| 962 __typeof (GOMP_OFFLOAD_dev2host) *dev2host_func; | |
| 963 __typeof (GOMP_OFFLOAD_host2dev) *host2dev_func; | |
| 964 __typeof (GOMP_OFFLOAD_dev2dev) *dev2dev_func; | |
| 965 __typeof (GOMP_OFFLOAD_can_run) *can_run_func; | |
| 966 __typeof (GOMP_OFFLOAD_run) *run_func; | |
| 967 __typeof (GOMP_OFFLOAD_async_run) *async_run_func; | |
| 968 | |
| 969 /* Splay tree containing information about mapped memory regions. */ | |
| 970 struct splay_tree_s mem_map; | |
| 971 | |
| 972 /* Mutex for the mutable data. */ | |
| 973 gomp_mutex_t lock; | |
| 974 | |
| 975 /* Current state of the device. OpenACC allows to move from INITIALIZED state | |
| 976 back to UNINITIALIZED state. OpenMP allows only to move from INITIALIZED | |
| 977 to FINALIZED state (at program shutdown). */ | |
| 978 enum gomp_device_state state; | |
| 979 | |
| 980 /* OpenACC-specific data and functions. */ | |
| 981 /* This is mutable because of its mutable data_environ and target_data | |
| 982 members. */ | |
| 983 acc_dispatch_t openacc; | |
| 984 }; | |
| 985 | |
| 986 /* Kind of the pragma, for which gomp_map_vars () is called. */ | |
| 987 enum gomp_map_vars_kind | |
| 988 { | |
| 989 GOMP_MAP_VARS_OPENACC, | |
| 990 GOMP_MAP_VARS_TARGET, | |
| 991 GOMP_MAP_VARS_DATA, | |
| 992 GOMP_MAP_VARS_ENTER_DATA | |
| 993 }; | |
| 994 | |
| 995 extern void gomp_acc_insert_pointer (size_t, void **, size_t *, void *); | |
| 131 | 996 extern void gomp_acc_remove_pointer (void *, size_t, bool, int, int, int); |
| 997 extern void gomp_acc_declare_allocate (bool, size_t, void **, size_t *, | |
| 998 unsigned short *); | |
| 111 | 999 |
| 1000 extern struct target_mem_desc *gomp_map_vars (struct gomp_device_descr *, | |
| 1001 size_t, void **, void **, | |
| 1002 size_t *, void *, bool, | |
| 1003 enum gomp_map_vars_kind); | |
| 1004 extern void gomp_unmap_vars (struct target_mem_desc *, bool); | |
| 1005 extern void gomp_init_device (struct gomp_device_descr *); | |
| 1006 extern void gomp_free_memmap (struct splay_tree_s *); | |
| 1007 extern void gomp_unload_device (struct gomp_device_descr *); | |
| 131 | 1008 extern bool gomp_remove_var (struct gomp_device_descr *, splay_tree_key); |
| 0 | 1009 |
| 1010 /* work.c */ | |
| 1011 | |
| 1012 extern void gomp_init_work_share (struct gomp_work_share *, bool, unsigned); | |
| 1013 extern void gomp_fini_work_share (struct gomp_work_share *); | |
| 1014 extern bool gomp_work_share_start (bool); | |
| 1015 extern void gomp_work_share_end (void); | |
| 111 | 1016 extern bool gomp_work_share_end_cancel (void); |
| 0 | 1017 extern void gomp_work_share_end_nowait (void); |
| 1018 | |
| 1019 static inline void | |
| 1020 gomp_work_share_init_done (void) | |
| 1021 { | |
| 1022 struct gomp_thread *thr = gomp_thread (); | |
| 1023 if (__builtin_expect (thr->ts.last_work_share != NULL, 1)) | |
| 1024 gomp_ptrlock_set (&thr->ts.last_work_share->next_ws, thr->ts.work_share); | |
| 1025 } | |
| 1026 | |
| 1027 #ifdef HAVE_ATTRIBUTE_VISIBILITY | |
| 1028 # pragma GCC visibility pop | |
| 1029 #endif | |
| 1030 | |
| 1031 /* Now that we're back to default visibility, include the globals. */ | |
| 1032 #include "libgomp_g.h" | |
| 1033 | |
| 1034 /* Include omp.h by parts. */ | |
| 1035 #include "omp-lock.h" | |
| 1036 #define _LIBGOMP_OMP_LOCK_DEFINED 1 | |
| 1037 #include "omp.h.in" | |
| 1038 | |
| 1039 #if !defined (HAVE_ATTRIBUTE_VISIBILITY) \ | |
| 1040 || !defined (HAVE_ATTRIBUTE_ALIAS) \ | |
| 1041 || !defined (HAVE_AS_SYMVER_DIRECTIVE) \ | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1042 || !defined (PIC) \ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1043 || !defined (HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT) |
| 0 | 1044 # undef LIBGOMP_GNU_SYMBOL_VERSIONING |
| 1045 #endif | |
| 1046 | |
| 1047 #ifdef LIBGOMP_GNU_SYMBOL_VERSIONING | |
| 1048 extern void gomp_init_lock_30 (omp_lock_t *) __GOMP_NOTHROW; | |
| 1049 extern void gomp_destroy_lock_30 (omp_lock_t *) __GOMP_NOTHROW; | |
| 1050 extern void gomp_set_lock_30 (omp_lock_t *) __GOMP_NOTHROW; | |
| 1051 extern void gomp_unset_lock_30 (omp_lock_t *) __GOMP_NOTHROW; | |
| 1052 extern int gomp_test_lock_30 (omp_lock_t *) __GOMP_NOTHROW; | |
| 1053 extern void gomp_init_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW; | |
| 1054 extern void gomp_destroy_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW; | |
| 1055 extern void gomp_set_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW; | |
| 1056 extern void gomp_unset_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW; | |
| 1057 extern int gomp_test_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW; | |
| 1058 | |
| 1059 extern void gomp_init_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW; | |
| 1060 extern void gomp_destroy_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW; | |
| 1061 extern void gomp_set_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW; | |
| 1062 extern void gomp_unset_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW; | |
| 1063 extern int gomp_test_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW; | |
| 1064 extern void gomp_init_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW; | |
| 1065 extern void gomp_destroy_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW; | |
| 1066 extern void gomp_set_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW; | |
| 1067 extern void gomp_unset_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW; | |
| 1068 extern int gomp_test_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW; | |
| 1069 | |
| 1070 # define omp_lock_symver(fn) \ | |
| 1071 __asm (".symver g" #fn "_30, " #fn "@@OMP_3.0"); \ | |
| 1072 __asm (".symver g" #fn "_25, " #fn "@OMP_1.0"); | |
| 1073 #else | |
| 1074 # define gomp_init_lock_30 omp_init_lock | |
| 1075 # define gomp_destroy_lock_30 omp_destroy_lock | |
| 1076 # define gomp_set_lock_30 omp_set_lock | |
| 1077 # define gomp_unset_lock_30 omp_unset_lock | |
| 1078 # define gomp_test_lock_30 omp_test_lock | |
| 1079 # define gomp_init_nest_lock_30 omp_init_nest_lock | |
| 1080 # define gomp_destroy_nest_lock_30 omp_destroy_nest_lock | |
| 1081 # define gomp_set_nest_lock_30 omp_set_nest_lock | |
| 1082 # define gomp_unset_nest_lock_30 omp_unset_nest_lock | |
| 1083 # define gomp_test_nest_lock_30 omp_test_nest_lock | |
| 1084 #endif | |
| 1085 | |
| 1086 #ifdef HAVE_ATTRIBUTE_VISIBILITY | |
| 1087 # define attribute_hidden __attribute__ ((visibility ("hidden"))) | |
| 1088 #else | |
| 1089 # define attribute_hidden | |
| 1090 #endif | |
| 1091 | |
| 1092 #ifdef HAVE_ATTRIBUTE_ALIAS | |
| 111 | 1093 # define strong_alias(fn, al) \ |
| 1094 extern __typeof (fn) al __attribute__ ((alias (#fn))); | |
| 1095 | |
| 1096 # define ialias_ulp ialias_str1(__USER_LABEL_PREFIX__) | |
| 1097 # define ialias_str1(x) ialias_str2(x) | |
| 1098 # define ialias_str2(x) #x | |
| 0 | 1099 # define ialias(fn) \ |
| 1100 extern __typeof (fn) gomp_ialias_##fn \ | |
| 1101 __attribute__ ((alias (#fn))) attribute_hidden; | |
| 111 | 1102 # define ialias_redirect(fn) \ |
| 1103 extern __typeof (fn) fn __asm__ (ialias_ulp "gomp_ialias_" #fn) attribute_hidden; | |
| 1104 # define ialias_call(fn) gomp_ialias_ ## fn | |
| 0 | 1105 #else |
| 1106 # define ialias(fn) | |
| 111 | 1107 # define ialias_redirect(fn) |
| 1108 # define ialias_call(fn) fn | |
| 0 | 1109 #endif |
| 1110 | |
| 111 | 1111 /* Helper function for priority_node_to_task() and |
| 1112 task_to_priority_node(). | |
| 1113 | |
| 1114 Return the offset from a task to its priority_node entry. The | |
| 1115 priority_node entry is has a type of TYPE. */ | |
| 1116 | |
| 1117 static inline size_t | |
| 1118 priority_queue_offset (enum priority_queue_type type) | |
| 1119 { | |
| 1120 return offsetof (struct gomp_task, pnode[(int) type]); | |
| 1121 } | |
| 1122 | |
| 1123 /* Return the task associated with a priority NODE of type TYPE. */ | |
| 1124 | |
| 1125 static inline struct gomp_task * | |
| 1126 priority_node_to_task (enum priority_queue_type type, | |
| 1127 struct priority_node *node) | |
| 1128 { | |
| 1129 return (struct gomp_task *) ((char *) node - priority_queue_offset (type)); | |
| 1130 } | |
| 1131 | |
| 1132 /* Return the priority node of type TYPE for a given TASK. */ | |
| 1133 | |
| 1134 static inline struct priority_node * | |
| 1135 task_to_priority_node (enum priority_queue_type type, | |
| 1136 struct gomp_task *task) | |
| 1137 { | |
| 1138 return (struct priority_node *) ((char *) task | |
| 1139 + priority_queue_offset (type)); | |
| 1140 } | |
| 0 | 1141 #endif /* LIBGOMP_H */ |