[OpenMP] Remove obsolete external interface for device RT

[jdoerfert]

Summary

We do not generate _serialized_parallel calls in device mode, no
need for an external API.

[JonChesterfield]

I thought these were used for nested parallel clauses, but if clang doesn't emit calls to them, better deleted

[JonChesterfield]

Yep, dead - looks like the calls from the gpu were removed when __kmpc_parallel_51 was introduced

openmp/libomptarget/DeviceRTL/include/Interface.h

 
 /// TODO
 bool __kmpc_kernel_parallel(ParallelRegionFnTy *WorkFn);
 
 /// TODO
 void __kmpc_kernel_end_parallel();
 
 /// TODO
-void __kmpc_serialized_parallel(IdentTy *Loc, uint32_t);
-
-/// TODO
-void __kmpc_end_serialized_parallel(IdentTy *Loc, uint32_t);
-
-/// TODO
 void __kmpc_push_proc_bind(IdentTy *Loc, uint32_t TId, int ProcBind);
 
 /// TODO
 void __kmpc_push_num_teams(IdentTy *Loc, int32_t TId, int32_t NumTeams,
                            int32_t ThreadLimit);
 
 /// TODO
 uint16_t __kmpc_parallel_level(IdentTy *Loc, uint32_t);

openmp/libomptarget/DeviceRTL/src/Parallelism.cpp

 
 void __kmpc_parallel_51(IdentTy *ident, int32_t, int32_t if_expr,
                         int32_t num_threads, int proc_bind, void *fn,
                         void *wrapper_fn, void **args, int64_t nargs) {
 
   uint32_t TId = mapping::getThreadIdInBlock();
   // Handle the serialized case first, same for SPMD/non-SPMD.
   if (OMP_UNLIKELY(!if_expr || icv::Level)) {
-    __kmpc_serialized_parallel(ident, TId);
+    state::enterDataEnvironment();
+    ++icv::Level;
     invokeMicrotask(TId, 0, fn, args, nargs);
-    __kmpc_end_serialized_parallel(ident, TId);
+    state::exitDataEnvironment();
     return;
   }
 
   uint32_t NumThreads = determineNumberOfThreads(num_threads);
   if (mapping::isSPMDMode()) {
     // Avoid the race between the read of the `icv::Level` above and the write
     // below by synchronizing all threads here.
     synchronize::threadsAligned();
__attribute__((noinline)) void __kmpc_kernel_end_parallel() {
   // In case we have modified an ICV for this thread before a ThreadState was
   // created. We drop it now to not contaminate the next parallel region.
   ASSERT(!mapping::isSPMDMode());
   uint32_t TId = mapping::getThreadIdInBlock();
   state::resetStateForThread(TId);
   ASSERT(!mapping::isSPMDMode());
 }
 
-void __kmpc_serialized_parallel(IdentTy *, uint32_t TId) {
-  state::enterDataEnvironment();
-  ++icv::Level;
-}
-
-void __kmpc_end_serialized_parallel(IdentTy *, uint32_t TId) {
-  state::exitDataEnvironment();
-}
-
 uint16_t __kmpc_parallel_level(IdentTy *, uint32_t) { return omp_get_level(); }
 
 int32_t __kmpc_global_thread_num(IdentTy *) { return omp_get_thread_num(); }
 
 void __kmpc_push_num_threads(IdentTy *, int32_t, int32_t NumThreads) {
   icv::NThreads = NumThreads;
 }
 
 void __kmpc_push_num_teams(IdentTy *loc, int32_t tid, int32_t num_teams,
                            int32_t thread_limit) {}
 
 void __kmpc_push_proc_bind(IdentTy *loc, uint32_t tid, int proc_bind) {}
 }
 
 #pragma omp end declare target

openmp/libomptarget/deviceRTLs/common/src/parallel.cu

EXTERN void __kmpc_kernel_end_parallel() {
   omptarget_nvptx_threadPrivateContext->SetTopLevelTaskDescr(
       threadId, currTaskDescr->GetPrevTaskDescr());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // support for parallel that goes sequential
 ////////////////////////////////////////////////////////////////////////////////
 
-EXTERN void __kmpc_serialized_parallel(kmp_Ident *loc, uint32_t global_tid) {
-  PRINT0(LD_IO, "call to __kmpc_serialized_parallel\n");
+static void serializedParallel(kmp_Ident *loc, uint32_t global_tid) {
+  PRINT0(LD_IO, "call to serializedParallel\n");
 
   IncParallelLevel(/*ActiveParallel=*/false, __kmpc_impl_activemask());
 
   if (isRuntimeUninitialized()) {
     ASSERT0(LT_FUSSY, __kmpc_is_spmd_exec_mode(),
             "Expected SPMD mode with uninitialized runtime.");
     return;
   }
static void serializedParallel(kmp_Ident *loc, uint32_t global_tid) {
   // - there is only one thread per team
   newTaskDescr->ThreadId() = 0;
 
   // set new task descriptor as top
   omptarget_nvptx_threadPrivateContext->SetTopLevelTaskDescr(threadId,
                                                              newTaskDescr);
 }
 
-EXTERN void __kmpc_end_serialized_parallel(kmp_Ident *loc,
+static void endSerializedParallel(kmp_Ident *loc,
                                            uint32_t global_tid) {
-  PRINT0(LD_IO, "call to __kmpc_end_serialized_parallel\n");
+  PRINT0(LD_IO, "call to endSerializedParallel\n");
 
   DecParallelLevel(/*ActiveParallel=*/false, __kmpc_impl_activemask());
 
   if (isRuntimeUninitialized()) {
     ASSERT0(LT_FUSSY, __kmpc_is_spmd_exec_mode(),
             "Expected SPMD mode with uninitialized runtime.");
     return;
   }
NOINLINE EXTERN void __kmpc_parallel_51(kmp_Ident *ident, kmp_int32 global_tid,
                                         void *fn, void *wrapper_fn, void **args,
                                         size_t nargs) {
   // Handle the serialized case first, same for SPMD/non-SPMD except that in
   // SPMD mode we already incremented the parallel level counter, account for
   // that.
   bool InParallelRegion =
       (__kmpc_parallel_level() > __kmpc_is_spmd_exec_mode());
   if (!if_expr || InParallelRegion) {
-    __kmpc_serialized_parallel(ident, global_tid);
+    serializedParallel(ident, global_tid);
     __kmp_invoke_microtask(global_tid, 0, fn, args, nargs);
-    __kmpc_end_serialized_parallel(ident, global_tid);
+    endSerializedParallel(ident, global_tid);
     return;
   }
 
   if (__kmpc_is_spmd_exec_mode()) {
     __kmp_invoke_microtask(global_tid, 0, fn, args, nargs);
     return;
   }
 

openmp/libomptarget/deviceRTLs/interface.h

 ////////////////////////////////////////////////////////////////////////////////
 // external interface
 ////////////////////////////////////////////////////////////////////////////////
 
 // parallel
 EXTERN int32_t __kmpc_global_thread_num(kmp_Ident *loc);
 EXTERN void __kmpc_push_num_threads(kmp_Ident *loc, int32_t global_tid,
                                     int32_t num_threads);
-EXTERN void __kmpc_serialized_parallel(kmp_Ident *loc, uint32_t global_tid);
-EXTERN void __kmpc_end_serialized_parallel(kmp_Ident *loc, uint32_t global_tid);
 NOINLINE EXTERN uint8_t __kmpc_parallel_level();
 
 // proc bind
 EXTERN void __kmpc_push_proc_bind(kmp_Ident *loc, uint32_t global_tid,
                                   int proc_bind);
 EXTERN int omp_get_num_places(void);
 EXTERN int omp_get_place_num_procs(int place_num);
 EXTERN void omp_get_place_proc_ids(int place_num, int *ids);