189 lines
6.2 KiB
C
189 lines
6.2 KiB
C
/* 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
|