/* 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