[OpenMP] RFC: fixes for LIBOMP_OMP_VERSION=4.5/4

[lebedev.ri]

Summary

I have discovered this because i wanted to experiment with building static libomp
(with openmp-4.0 support only) for debugging purposes.

This is marked as RFC because i'm not sure if non-default values for
LIBOMP_OMP_VERSION are supposed to work or not.

There are three kinds of problems here:

1. __kmp_compare_and_store_acq() simply does not exist. It was added in D47903 by @jlpeyton I'm guessing __kmp_atomic_compare_store_acq() was meant.
2. In __kmp_is_ticket_lock_initialized(), lck->lk.initialized is std::atomic<bool>, while lck is kmp_ticket_lock_t *. Naturally, they can't be equality-compared. Either, it should return the value read from lck->lk.initialized, or do what __kmp_is_queuing_lock_initialized() does, compare the passed pointer with the field in the struct pointed by the pointer. I think the latter is correct-er choice here.
3. Tests were not versioned. They assume that LIBOMP_OMP_VERSION is at the latest version.

Thoughts?

[Hahnfeld]

I think there was a discussion in the past whether it makes sense to allow building for an older version of the standard, given that the library guarantees backwards compatibility. Your findings once again show that nobody is even compile-testing the old code, so I think it would be best to just remove all the #ifdefs and code that is not needed anymore. For everything else there's a version control system that you can ask about old versions of the code.

[lebedev.ri]

In D55496#1324745, @Hahnfeld wrote:

II think it would be best to just remove all the #ifdefs and code that is not needed anymore.

Sure, i could do that instead, if that is the final decision.
I just don't want it to stay in the current sudo-broken state.

[AndreyChurbanov]

In D55496#1324768, @lebedev.ri wrote:

In D55496#1324745, @Hahnfeld wrote:

II think it would be best to just remove all the #ifdefs and code that is not needed anymore.

Sure, i could do that instead, if that is the final decision.
I just don't want it to stay in the current sudo-broken state.

I don't mind removing the OpenMP versioning from sources, but this is much bigger change which will be harder to review.
Feel free to commit this for now, or work on the removing of all OpenMP versioning.

[lebedev.ri]

In D55496#1327109, @AndreyChurbanov wrote:

In D55496#1324768, @lebedev.ri wrote:

In D55496#1324745, @Hahnfeld wrote:

II think it would be best to just remove all the #ifdefs and code that is not needed anymore.

Sure, i could do that instead, if that is the final decision.
I just don't want it to stay in the current sudo-broken state.

I don't mind removing the OpenMP versioning from sources, but this is much bigger change which will be harder to review.

... and the one that would need an RFC i would imagine.

Feel free to commit this for now, or work on the removing of all OpenMP versioning.

Ok, thank you for the review.

openmp/trunk/runtime/src/kmp_lock.h

if (__kmp_env_consistency_check) {                                         \
           lck->tas.lk.depth_locked != -1) {                                    \
         KMP_FATAL(LockNestableUsedAsSimple, func);                             \
       }                                                                        \
       if ((gtid >= 0) && (lck->tas.lk.poll - 1 == gtid)) {                     \
         KMP_FATAL(LockIsAlreadyOwned, func);                                   \
       }                                                                        \
     }                                                                          \
     if (lck->tas.lk.poll != 0 ||                                               \
-        !__kmp_compare_and_store_acq(&lck->tas.lk.poll, 0, gtid + 1)) {        \
+        !__kmp_atomic_compare_store_acq(&lck->tas.lk.poll, 0, gtid + 1)) {     \
       kmp_uint32 spins;                                                        \
       KMP_FSYNC_PREPARE(lck);                                                  \
       KMP_INIT_YIELD(spins);                                                   \
       if (TCR_4(__kmp_nth) >                                                   \
           (__kmp_avail_proc ? __kmp_avail_proc : __kmp_xproc)) {               \
         KMP_YIELD(TRUE);                                                       \
       } else {                                                                 \
         KMP_YIELD_SPIN(spins);                                                 \
       }                                                                        \
-      while (lck->tas.lk.poll != 0 ||                                          \
-             !__kmp_compare_and_store_acq(&lck->tas.lk.poll, 0, gtid + 1)) {   \
+      while (lck->tas.lk.poll != 0 || !__kmp_atomic_compare_store_acq(         \
+                                          &lck->tas.lk.poll, 0, gtid + 1)) {   \
         if (TCR_4(__kmp_nth) >                                                 \
             (__kmp_avail_proc ? __kmp_avail_proc : __kmp_xproc)) {             \
           KMP_YIELD(TRUE);                                                     \
         } else {                                                               \
           KMP_YIELD_SPIN(spins);                                               \
         }                                                                      \
       }                                                                        \
     }                                                                          \
if (__kmp_user_lock_kind == lk_tas) {
     if (__kmp_env_consistency_check) {
       char const *const func = "omp_test_lock";
       if ((sizeof(kmp_tas_lock_t) <= OMP_LOCK_T_SIZE) &&
           lck->tas.lk.depth_locked != -1) {
         KMP_FATAL(LockNestableUsedAsSimple, func);
       }
     }
     return ((lck->tas.lk.poll == 0) &&
-            __kmp_compare_and_store_acq(&lck->tas.lk.poll, 0, gtid + 1));
+            __kmp_atomic_compare_store_acq(&lck->tas.lk.poll, 0, gtid + 1));
   } else {
     KMP_DEBUG_ASSERT(__kmp_test_user_lock_with_checks_ != NULL);
     return (*__kmp_test_user_lock_with_checks_)(lck, gtid);
   }
 }
 #else
 static inline int __kmp_test_user_lock_with_checks(kmp_user_lock_p lck,
                                                    kmp_int32 gtid) {
if (__kmp_env_consistency_check) {                                         \
         KMP_FATAL(LockSimpleUsedAsNestable, func);                             \
       }                                                                        \
     }                                                                          \
     if (lck->tas.lk.poll - 1 == gtid) {                                        \
       lck->tas.lk.depth_locked += 1;                                           \
       *depth = KMP_LOCK_ACQUIRED_NEXT;                                         \
     } else {                                                                   \
       if ((lck->tas.lk.poll != 0) ||                                           \
-          !__kmp_compare_and_store_acq(&lck->tas.lk.poll, 0, gtid + 1)) {      \
+          !__kmp_atomic_compare_store_acq(&lck->tas.lk.poll, 0, gtid + 1)) {   \
         kmp_uint32 spins;                                                      \
         KMP_FSYNC_PREPARE(lck);                                                \
         KMP_INIT_YIELD(spins);                                                 \
         if (TCR_4(__kmp_nth) >                                                 \
             (__kmp_avail_proc ? __kmp_avail_proc : __kmp_xproc)) {             \
           KMP_YIELD(TRUE);                                                     \
         } else {                                                               \
           KMP_YIELD_SPIN(spins);                                               \
         }                                                                      \
-        while ((lck->tas.lk.poll != 0) ||                                      \
-               !__kmp_compare_and_store_acq(&lck->tas.lk.poll, 0, gtid + 1)) { \
+        while (                                                                \
+            (lck->tas.lk.poll != 0) ||                                         \
+            !__kmp_atomic_compare_store_acq(&lck->tas.lk.poll, 0, gtid + 1)) { \
           if (TCR_4(__kmp_nth) >                                               \
               (__kmp_avail_proc ? __kmp_avail_proc : __kmp_xproc)) {           \
             KMP_YIELD(TRUE);                                                   \
           } else {                                                             \
             KMP_YIELD_SPIN(spins);                                             \
           }                                                                    \
         }                                                                      \
       }                                                                        \
if (__kmp_env_consistency_check) {
       }
     }
     KMP_DEBUG_ASSERT(gtid >= 0);
     if (lck->tas.lk.poll - 1 ==
         gtid) { /* __kmp_get_tas_lock_owner( lck ) == gtid */
       return ++lck->tas.lk.depth_locked; /* same owner, depth increased */
     }
     retval = ((lck->tas.lk.poll == 0) &&
-              __kmp_compare_and_store_acq(&lck->tas.lk.poll, 0, gtid + 1));
+              __kmp_atomic_compare_store_acq(&lck->tas.lk.poll, 0, gtid + 1));
     if (retval) {
       KMP_MB();
       lck->tas.lk.depth_locked = 1;
     }
     return retval;
   } else {
     KMP_DEBUG_ASSERT(__kmp_test_nested_user_lock_with_checks_ != NULL);
     return (*__kmp_test_nested_user_lock_with_checks_)(lck, gtid);

openmp/trunk/runtime/src/kmp_lock.cpp

 }
 
 static void __kmp_init_nested_futex_lock_with_checks(kmp_futex_lock_t *lck) {
   __kmp_init_nested_futex_lock(lck);
 }
 #endif
 
 static int __kmp_is_ticket_lock_initialized(kmp_ticket_lock_t *lck) {
-  return lck == lck->lk.initialized;
+  return lck == lck->lk.self;
 }
 
 static void __kmp_init_ticket_lock_with_checks(kmp_ticket_lock_t *lck) {
   __kmp_init_ticket_lock(lck);
 }
 
 static void __kmp_init_nested_ticket_lock_with_checks(kmp_ticket_lock_t *lck) {
   __kmp_init_nested_ticket_lock(lck);

openmp/trunk/runtime/src/kmp_tasking.cpp

 // gtid: global thread ID for calling thread
 // task: task to be finished
 // resumed_task: task to be resumed.  (may be NULL if task is serialized)
 template <bool ompt>
 static void __kmp_task_finish(kmp_int32 gtid, kmp_task_t *task,
                               kmp_taskdata_t *resumed_task) {
   kmp_taskdata_t *taskdata = KMP_TASK_TO_TASKDATA(task);
   kmp_info_t *thread = __kmp_threads[gtid];
+#if OMP_45_ENABLED
   kmp_task_team_t *task_team =
       thread->th.th_task_team; // might be NULL for serial teams...
+#endif // OMP_45_ENABLED
   kmp_int32 children = 0;
 
   KA_TRACE(10, ("__kmp_task_finish(enter): T#%d finishing task %p and resuming "
                 "task %p\n",
                 gtid, taskdata, resumed_task));
 
   KMP_DEBUG_ASSERT(taskdata->td_flags.tasktype == TASK_EXPLICIT);
 

openmp/trunk/runtime/test/api/omp_alloc.c

 // RUN: %libomp-compile-and-run
+
+// REQUIRES: openmp-5.0
+
 #include <stdio.h>
 #include <stdint.h>
 #include <omp.h>
 #include "omp_testsuite.h"
 
 #define ARRAY_SIZE 10000
 
 int test_omp_alloc() {

openmp/trunk/runtime/test/lit.cfg

if config.has_ompt and config.test_filecheck == "":
     lit_config.note("Not testing OMPT because FileCheck was not found")
     config.has_ompt = False
 
 if config.has_ompt:
     config.available_features.add("ompt")
     # for callback.h
     config.test_flags += " -I " + config.test_source_root + "/ompt"
 
+if config.libomp_omp_version >= 50:
+    config.available_features.add("openmp-5.0")
+
+if config.libomp_omp_version >= 45:
+    config.available_features.add("openmp-4.5")
+
+if config.libomp_omp_version >= 40:
+    config.available_features.add("openmp-4.0")
+
 if 'Linux' in config.operating_system:
     config.available_features.add("linux")
 
 if config.operating_system in ['Linux', 'Windows']:
     config.available_features.add('affinity')
 
 # to run with icc INTEL_LICENSE_FILE must be set
 if 'INTEL_LICENSE_FILE' in os.environ:

openmp/trunk/runtime/test/lit.site.cfg.in

 @AUTO_GEN_COMMENT@
 
 config.test_c_compiler = "@OPENMP_TEST_C_COMPILER@"
 config.test_cxx_compiler = "@OPENMP_TEST_CXX_COMPILER@"
 config.test_compiler_features = @OPENMP_TEST_COMPILER_FEATURES@
 config.test_filecheck = "@OPENMP_FILECHECK_EXECUTABLE@"
 config.test_openmp_flags = "@OPENMP_TEST_OPENMP_FLAGS@"
 config.test_extra_flags = "@OPENMP_TEST_FLAGS@"
+config.libomp_omp_version = @LIBOMP_OMP_VERSION@
 config.libomp_obj_root = "@CMAKE_CURRENT_BINARY_DIR@"
 config.library_dir = "@LIBOMP_LIBRARY_DIR@"
 config.omp_header_directory = "@LIBOMP_BINARY_DIR@/src"
 config.operating_system = "@CMAKE_SYSTEM_NAME@"
 config.hwloc_library_dir = "@LIBOMP_HWLOC_LIBRARY_DIR@"
 config.using_hwloc = @LIBOMP_USE_HWLOC@
 config.has_ompt = @LIBOMP_OMPT_SUPPORT@ and @LIBOMP_OMPT_OPTIONAL@
 config.has_libm = @LIBOMP_HAVE_LIBM@
 config.has_libatomic = @LIBOMP_HAVE_LIBATOMIC@
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@LIBOMP_BASE_DIR@/test/lit.cfg")

openmp/trunk/runtime/test/ompt/misc/control_tool_no_ompt_support.c

 // RUN: %libomp-compile-and-run
+
+// REQUIRES: openmp-5.0
+
 #include <omp.h>
 
 int main()
 {
   #pragma omp parallel num_threads(1)
   {
     omp_control_tool(omp_control_tool_flush, 1, NULL);
   }
 
   return 0;
 }

openmp/trunk/runtime/test/tasking/bug_nested_proxy_task.c

 // RUN: %libomp-compile -lpthread && %libomp-run
+// REQUIRES: openmp-4.5
 // The runtime currently does not get dependency information from GCC.
 // UNSUPPORTED: gcc
 
 #include <stdio.h>
 #include <omp.h>
 #include <pthread.h>
 #include "omp_my_sleep.h"
 

openmp/trunk/runtime/test/tasking/bug_proxy_task_dep_waiting.c

 // RUN: %libomp-compile -lpthread && %libomp-run
+// REQUIRES: openmp-4.5
 // The runtime currently does not get dependency information from GCC.
 // UNSUPPORTED: gcc
 
 #include <stdio.h>
 #include <omp.h>
 #include <pthread.h>
 #include "omp_my_sleep.h"
 

openmp/trunk/runtime/test/tasking/kmp_task_reduction_nest.cpp

 // RUN: %libomp-cxx-compile-and-run
 // RUN: %libomp-cxx-compile -DFLG=1 && %libomp-run
+// REQUIRES: openmp-5.0
 // GCC-5 is needed for OpenMP 4.0 support (taskgroup)
 // XFAIL: gcc-4
 #include <cstdio>
 #include <cmath>
 #include <cassert>
 #include <omp.h>
 
 // Total number of loop iterations, should be multiple of T for this test

openmp/trunk/runtime/test/tasking/kmp_taskloop.c

 // RUN: %libomp-compile-and-run
 // RUN: %libomp-compile && env KMP_TASKLOOP_MIN_TASKS=1 %libomp-run
+// REQUIRES: openmp-4.5
 #include <stdio.h>
 #include <omp.h>
 #include "omp_my_sleep.h"
 
 #define N 4
 #define GRAIN 10
 #define STRIDE 3
 

openmp/trunk/runtime/test/tasking/omp_task_priority.c

 // RUN: %libomp-compile && env OMP_MAX_TASK_PRIORITY=42 %libomp-run
+// REQUIRES: openmp-4.5
 // Test OMP 4.5 task priorities
 // Currently only API function and envirable parsing implemented.
 // Test environment sets envirable: OMP_MAX_TASK_PRIORITY=42 as tested below.
 #include <stdio.h>
 #include <omp.h>
 
 int main (void) {
     int passed;

openmp/trunk/runtime/test/tasking/omp_taskloop_grainsize.c

 // RUN: %libomp-compile-and-run
 // RUN: %libomp-compile && env KMP_TASKLOOP_MIN_TASKS=1 %libomp-run
+// REQUIRES: openmp-4.5
 
 // These compilers don't support the taskloop construct
 // UNSUPPORTED: gcc-4, gcc-5, icc-16
 // GCC 6 has support for taskloops, but at least 6.3.0 is crashing on this test
 // UNSUPPORTED: gcc-6
 
 /*
  * Test for taskloop

openmp/trunk/runtime/test/tasking/omp_taskloop_num_tasks.c

 // RUN: %libomp-compile-and-run
 // RUN: %libomp-compile && env KMP_TASKLOOP_MIN_TASKS=1 %libomp-run
+// REQUIRES: openmp-4.5
 
 // These compilers don't support the taskloop construct
 // UNSUPPORTED: gcc-4, gcc-5, icc-16
 
 /*
  * Test for taskloop
  * Method: caculate how many times the iteration space is dispatched
  *     and judge if each dispatch has the requested grainsize

openmp/trunk/runtime/test/worksharing/for/kmp_doacross_check.c

 // RUN: %libomp-compile-and-run
+// REQUIRES: openmp-4.5
 // UNSUPPORTED: gcc
 // This test is incompatible with gcc because of the explicit call to
 // __kmpc_doacross_fini().  gcc relies on an implicit call to this function
 // when the last iteration is executed inside the GOMP_loop_*_next() functions.
 // Hence, in gcc, having the explicit call leads to __kmpc_doacross_fini()
 // being called twice.
 #include <stdio.h>
 

openmp/trunk/runtime/test/worksharing/for/kmp_sch_simd_guided.c

 // RUN: %libomp-compile-and-run
+// REQUIRES: openmp-4.5
 /*
   Test for the 'schedule(simd:guided)' clause.
   Compiler needs to generate a dynamic dispatching and pass the schedule
   value 46 to the OpenMP RTL. Test uses numerous loop parameter combinations.
 */
 #include <stdio.h>
 #include <omp.h>
 

openmp/trunk/runtime/test/worksharing/for/kmp_sch_simd_runtime_api.c

 // RUN: %libomp-compile-and-run
+// REQUIRES: openmp-4.5
 
 // The test checks schedule(simd:runtime)
 // in combination with omp_set_schedule()
 #include <stdio.h>
 #include <stdlib.h>
 #include <omp.h>
 
 #if defined(WIN32) || defined(_WIN32)

openmp/trunk/runtime/test/worksharing/for/kmp_sch_simd_runtime_guided.c

 // RUN: %libomp-compile
 // RUN: env OMP_SCHEDULE=guided    %libomp-run
 // RUN: env OMP_SCHEDULE=guided,1  %libomp-run 1
 // RUN: env OMP_SCHEDULE=guided,2  %libomp-run 2
 // RUN: env OMP_SCHEDULE=dynamic   %libomp-run
 // RUN: env OMP_SCHEDULE=dynamic,1 %libomp-run 1
 // RUN: env OMP_SCHEDULE=dynamic,2 %libomp-run 2
 // RUN: env OMP_SCHEDULE=auto      %libomp-run
+// REQUIRES: openmp-4.5
 
 // The test checks schedule(simd:runtime)
 // in combination with OMP_SCHEDULE=guided[,chunk]
 #include <stdio.h>
 #include <stdlib.h>
 #include <omp.h>
 
 #if defined(WIN32) || defined(_WIN32)

openmp/trunk/runtime/test/worksharing/for/kmp_sch_simd_runtime_static.c

 // RUN: %libomp-compile && %libomp-run
 // RUN: %libomp-run 1 && %libomp-run 2
+// REQUIRES: openmp-4.5
 
 // The test checks schedule(simd:runtime)
 // in combination with OMP_SCHEDULE=static[,chunk]
 #include <stdio.h>
 #include <stdlib.h>
 #include <omp.h>
 
 #if defined(WIN32) || defined(_WIN32)

openmp/trunk/runtime/test/worksharing/for/omp_doacross.c

 // RUN: %libomp-compile-and-run
+// REQUIRES: openmp-4.5
 // XFAIL: gcc-4, gcc-5, clang-3.7, clang-3.8, icc-15, icc-16
 #include <stdio.h>
 #include <stdlib.h>
 #include "omp_testsuite.h"
 
 #ifndef N
 #define N 750
 #endif