You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
188 lines
6.2 KiB
188 lines
6.2 KiB
/* Copyright (C) 2019 Free Software Foundation, Inc. |
|
Contributed by Jakub Jelinek <jakub@redhat.com>. |
|
|
|
This file is part of the GNU Offloading and Multi Processing Library |
|
(libgomp). |
|
|
|
Libgomp is free software; you can redistribute it and/or modify it |
|
under the terms of the GNU General Public License as published by |
|
the Free Software Foundation; either version 3, or (at your option) |
|
any later version. |
|
|
|
Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY |
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS |
|
FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
|
more details. |
|
|
|
Under Section 7 of GPL version 3, you are granted additional |
|
permissions described in the GCC Runtime Library Exception, version |
|
3.1, as published by the Free Software Foundation. |
|
|
|
You should have received a copy of the GNU General Public License and |
|
a copy of the GCC Runtime Library Exception along with this program; |
|
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
|
<http://www.gnu.org/licenses/>. */ |
|
|
|
/* Remapping of nonmonotonic runtime schedule and maybe nonmonotonic runtime |
|
schedule loop entrypoints (the used by GCC 9 and later for runtime |
|
schedule without monotonic or nonmonotonic modifiers). |
|
RHEL 7 libgomp only implements the GOMP*loop*runtime* entrypoints without |
|
nonmonotonic in the names, which always implement monotonic scheduling, |
|
but the library doesn't implement any other scheduling, even in GCC 9 |
|
and monotonic scheduling is a valid implementation of non-monotonic |
|
scheduling. */ |
|
|
|
#include <stdbool.h> |
|
|
|
typedef unsigned long long ull; |
|
extern bool GOMP_loop_runtime_start (long, long, long, long *, long *); |
|
extern bool GOMP_loop_runtime_next (long *, long *); |
|
extern void GOMP_parallel_loop_runtime (void (*)(void *), void *, |
|
unsigned, long, long, long, |
|
unsigned); |
|
extern bool GOMP_loop_ull_runtime_start (bool, ull, ull, ull, ull *, ull *); |
|
extern bool GOMP_loop_ull_runtime_next (ull *, ull *); |
|
extern bool GOMP_loop_dynamic_next (long *, long *); |
|
extern bool GOMP_loop_dynamic_start (long, long, long, long, long *, long *); |
|
extern bool GOMP_loop_guided_next (long *, long *); |
|
extern bool GOMP_loop_guided_start (long, long, long, long, long *, long *); |
|
extern bool GOMP_loop_ull_dynamic_next (ull *, ull *); |
|
extern bool GOMP_loop_ull_dynamic_start (bool, ull, ull, ull, ull, ull *, |
|
ull *); |
|
extern bool GOMP_loop_ull_guided_next (ull *, ull *); |
|
extern bool GOMP_loop_ull_guided_start (bool, ull, ull, ull, ull, ull *, |
|
ull *); |
|
extern void GOMP_parallel_loop_dynamic (void (*)(void *), void *, |
|
unsigned, long, long, long, long, |
|
unsigned); |
|
extern void GOMP_parallel_loop_guided (void (*)(void *), void *, |
|
unsigned, long, long, long, long, |
|
unsigned); |
|
#define alias(x, y) __typeof (x) y __attribute__((alias (#x))) |
|
|
|
#pragma GCC visibility push(hidden) |
|
|
|
bool |
|
GOMP_loop_nonmonotonic_runtime_start (long start, long end, long incr, |
|
long *istart, long *iend) |
|
{ |
|
return GOMP_loop_runtime_start (start, end, incr, istart, iend); |
|
} |
|
alias (GOMP_loop_nonmonotonic_runtime_start, |
|
GOMP_loop_maybe_nonmonotonic_runtime_start); |
|
|
|
bool |
|
GOMP_loop_nonmonotonic_runtime_next (long *istart, long *iend) |
|
{ |
|
return GOMP_loop_runtime_next (istart, iend); |
|
} |
|
alias (GOMP_loop_nonmonotonic_runtime_next, |
|
GOMP_loop_maybe_nonmonotonic_runtime_next); |
|
|
|
void |
|
GOMP_parallel_loop_nonmonotonic_runtime (void (*fn)(void *), void *data, |
|
unsigned num_threads, long start, |
|
long end, long incr, unsigned flags) |
|
{ |
|
return GOMP_parallel_loop_runtime (fn, data, num_threads, start, |
|
end, incr, flags); |
|
} |
|
alias (GOMP_parallel_loop_nonmonotonic_runtime, |
|
GOMP_parallel_loop_maybe_nonmonotonic_runtime); |
|
|
|
bool |
|
GOMP_loop_ull_nonmonotonic_runtime_start (bool up, ull start, ull end, |
|
ull incr, ull *istart, ull *iend) |
|
{ |
|
return GOMP_loop_ull_runtime_start (up, start, end, incr, istart, iend); |
|
} |
|
alias (GOMP_loop_ull_nonmonotonic_runtime_start, |
|
GOMP_loop_ull_maybe_nonmonotonic_runtime_start); |
|
|
|
bool |
|
GOMP_loop_ull_nonmonotonic_runtime_next (ull *istart, ull *iend) |
|
{ |
|
return GOMP_loop_ull_runtime_next (istart, iend); |
|
} |
|
alias (GOMP_loop_ull_nonmonotonic_runtime_next, |
|
GOMP_loop_ull_maybe_nonmonotonic_runtime_next); |
|
|
|
bool |
|
GOMP_loop_nonmonotonic_dynamic_next (long *istart, long *iend) |
|
{ |
|
return GOMP_loop_dynamic_next (istart, iend); |
|
} |
|
|
|
bool |
|
GOMP_loop_nonmonotonic_dynamic_start (long start, long end, long incr, |
|
long chunk_size, long *istart, |
|
long *iend) |
|
{ |
|
return GOMP_loop_dynamic_start (start, end, incr, chunk_size, istart, iend); |
|
} |
|
|
|
bool |
|
GOMP_loop_nonmonotonic_guided_next (long *istart, long *iend) |
|
{ |
|
return GOMP_loop_guided_next (istart, iend); |
|
} |
|
|
|
bool |
|
GOMP_loop_nonmonotonic_guided_start (long start, long end, long incr, |
|
long chunk_size, long *istart, long *iend) |
|
{ |
|
return GOMP_loop_guided_start (start, end, incr, chunk_size, istart, iend); |
|
} |
|
|
|
bool |
|
GOMP_loop_ull_nonmonotonic_dynamic_next (ull *istart, ull *iend) |
|
{ |
|
return GOMP_loop_ull_dynamic_next (istart, iend); |
|
} |
|
|
|
bool |
|
GOMP_loop_ull_nonmonotonic_dynamic_start (bool up, ull start, |
|
ull end, ull incr, |
|
ull chunk_size, |
|
ull *istart, ull *iend) |
|
{ |
|
return GOMP_loop_ull_dynamic_start (up, start, end, incr, chunk_size, istart, |
|
iend); |
|
} |
|
|
|
bool |
|
GOMP_loop_ull_nonmonotonic_guided_next (ull *istart, ull *iend) |
|
{ |
|
return GOMP_loop_ull_guided_next (istart, iend); |
|
} |
|
|
|
bool |
|
GOMP_loop_ull_nonmonotonic_guided_start (bool up, ull start, ull end, |
|
ull incr, ull chunk_size, |
|
ull *istart, ull *iend) |
|
{ |
|
return GOMP_loop_ull_guided_start (up, start, end, incr, chunk_size, istart, |
|
iend); |
|
} |
|
|
|
void |
|
GOMP_parallel_loop_nonmonotonic_dynamic (void (*fn) (void *), void *data, |
|
unsigned num_threads, long start, |
|
long end, long incr, long chunk_size, |
|
unsigned flags) |
|
{ |
|
GOMP_parallel_loop_dynamic (fn, data, num_threads, start, end, incr, |
|
chunk_size, flags); |
|
} |
|
|
|
void |
|
GOMP_parallel_loop_nonmonotonic_guided (void (*fn) (void *), void *data, |
|
unsigned num_threads, long start, |
|
long end, long incr, long chunk_size, |
|
unsigned flags) |
|
{ |
|
GOMP_parallel_loop_guided (fn, data, num_threads, start, end, incr, |
|
chunk_size, flags); |
|
} |
|
|
|
#pragma GCC visibility pop
|
|
|