[OpenMP] Fix doacross testing for gcc

[jlpeyton]

Summary

This patch adds a test using the doacross clauses in OpenMP and removes gcc from testing kmp_doacross_check.c which is only testing the kmp rather than the gomp interface.

[Hahnfeld]

I'm not sure if this test works for all "supported" versions of compilers:

• I think Clang supports CodeGen for doacross since version 3.9 (landed in May 2016, see https://github.com/llvm-mirror/clang/commit/f2b5110519dc87a957877b8bdaf26717ff25abb5)
• GCC 6 supports "Version 4.5 of the OpenMP specification" which should include doacross (see https://gcc.gnu.org/gcc-6/changes.html)
• Looks like Intel Compiler 17.0 added support for doacross (see https://software.intel.com/en-us/articles/intel-visual-fortran-compiler-170-for-windows-release-notes-for-intel-parallel-studio-xe).

Please add corresponding XFAILs to the test so that the test suite doesn't regress for older compilers. IMO it would be good to support the last 3 major compiler releases of each compiler, maybe with the exception of GCC where we might want to make RHEL/CentOS' version 4.8.5 work. We should probably discuss this on the mailing list and document an official policy for that...

(Minor comment: Can you please clang-format the new test?)

[Hahnfeld]

runtime/test/worksharing/for/kmp_doacross_check.c

2 ↗

(On Diff #158075)

Could you add a comment explaining why this test is disabled for GCC? (As discussed in D49857, that's the only reasonable thing to do...)

[jlpeyton]

Added comment, clang-formatted test, added comp-major.minor to features in lit so i could xfail clang-3.8 and 3.7 and added other proper compiler versions for xfail of the new doacross test.

[Hahnfeld]

LGTM, we should have this backported before the first release candidate for 7.0

openmp/trunk/cmake/OpenMPTesting.cmake

if (NOT("${OPENMP_TEST_C_COMPILER_ID}" STREQUAL "${OPENMP_TEST_CXX_COMPILER_ID}" AND
     set(ENABLE_CHECK_TARGETS FALSE PARENT_SCOPE)
   else()
     set(OPENMP_TEST_COMPILER_ID "${OPENMP_TEST_C_COMPILER_ID}" PARENT_SCOPE)
     set(OPENMP_TEST_COMPILER_VERSION "${OPENMP_TEST_C_COMPILER_VERSION}" PARENT_SCOPE)
     set(OPENMP_TEST_COMPILER_OPENMP_FLAGS "${OPENMP_TEST_C_COMPILER_OPENMP_FLAGS}" PARENT_SCOPE)
 
     # Determine major version.
     string(REGEX MATCH "[0-9]+" major "${OPENMP_TEST_C_COMPILER_VERSION}")
+    string(REGEX MATCH "[0-9]+\\.[0-9]+" majorminor "${OPENMP_TEST_C_COMPILER_VERSION}")
     set(OPENMP_TEST_COMPILER_VERSION_MAJOR "${major}" PARENT_SCOPE)
+    set(OPENMP_TEST_COMPILER_VERSION_MAJOR_MINOR "${majorminor}" PARENT_SCOPE)
   endif()
 endfunction()
 
 if (${OPENMP_STANDALONE_BUILD})
   # Detect compiler that should be used for testing.
   # We cannot use ExternalProject_Add() because its configuration runs when this
   # project is built which is too late for detecting the compiler...
   file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/DetectTestCompiler)
else()
     set_test_compiler_information(${CMAKE_CURRENT_BINARY_DIR}/DetectTestCompiler)
   endif()
 else()
   # Set the information that we know.
   set(OPENMP_TEST_COMPILER_ID "Clang")
   # Cannot use CLANG_VERSION because we are not guaranteed that this is already set.
   set(OPENMP_TEST_COMPILER_VERSION "${LLVM_VERSION}")
   set(OPENMP_TEST_COMPILER_VERSION_MAJOR "${LLVM_MAJOR_VERSION}")
+  set(OPENMP_TEST_COMPILER_VERSION_MAJOR_MINOR "${LLVM_MAJOR_VERSION}.${LLVM_MINOR_VERSION}")
   # TODO: Implement blockaddress in GlobalISel and remove this flag!
   set(OPENMP_TEST_COMPILER_OPENMP_FLAGS "-fopenmp -fno-experimental-isel")
 endif()
 
 # Function to set compiler features for use in lit.
 function(set_test_compiler_features)
   if ("${OPENMP_TEST_COMPILER_ID}" STREQUAL "GNU")
     set(comp "gcc")
   elseif ("${OPENMP_TEST_COMPILER_ID}" STREQUAL "Intel")
     set(comp "icc")
   else()
     # Just use the lowercase of the compiler ID as fallback.
     string(TOLOWER "${OPENMP_TEST_COMPILER_ID}" comp)
   endif()
-  set(OPENMP_TEST_COMPILER_FEATURES "['${comp}', '${comp}-${OPENMP_TEST_COMPILER_VERSION_MAJOR}', '${comp}-${OPENMP_TEST_COMPILER_VERSION}']" PARENT_SCOPE)
+  set(OPENMP_TEST_COMPILER_FEATURES "['${comp}', '${comp}-${OPENMP_TEST_COMPILER_VERSION_MAJOR}', '${comp}-${OPENMP_TEST_COMPILER_VERSION_MAJOR_MINOR}', '${comp}-${OPENMP_TEST_COMPILER_VERSION}']" PARENT_SCOPE)
 endfunction()
 set_test_compiler_features()
 
 # Function to add a testsuite for an OpenMP runtime library.
 function(add_openmp_testsuite target comment)
   if (NOT ENABLE_CHECK_TARGETS)
     add_custom_target(${target}
       COMMAND ${CMAKE_COMMAND} -E echo "${target} does nothing, dependencies not found.")

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

 // RUN: %libomp-compile-and-run
+// 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>
 
 #define N   1000
 
 struct dim {
   long long lo; // lower
   long long up; // upper
   long long st; // stride

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

+// RUN: %libomp-compile-and-run
+// 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
+
+int test_doacross() {
+  int i, j;
+  // Allocate and zero out the matrix
+  int *m = (int *)malloc(sizeof(int) * N * N);
+  for (i = 0; i < N; ++i) {
+    for (j = 0; j < N; ++j) {
+      m[i * N + j] = 0;
+    }
+  }
+  // Have first row and column be 0, 1, 2, 3, etc.
+  for (i = 0; i < N; ++i)
+    m[i * N] = i;
+  for (j = 0; j < N; ++j)
+    m[j] = j;
+  // Perform wavefront which results in matrix:
+  // 0 1 2 3 4
+  // 1 2 3 4 5
+  // 2 3 4 5 6
+  // 3 4 5 6 7
+  // 4 5 6 7 8
+  #pragma omp parallel shared(m)
+  {
+    int row, col;
+    #pragma omp for ordered(2)
+    for (row = 1; row < N; ++row) {
+      for (col = 1; col < N; ++col) {
+        #pragma omp ordered depend(sink : row - 1, col) depend(sink : row, col - 1)
+        m[row * N + col] = m[(row - 1) * N + col] + m[row * N + (col - 1)] -
+                           m[(row - 1) * N + (col - 1)];
+        #pragma omp ordered depend(source)
+      }
+    }
+  }
+
+  // Check the bottom right element to see if iteration dependencies were held
+  int retval = (m[(N - 1) * N + N - 1] == 2 * (N - 1));
+  free(m);
+  return retval;
+}
+
+int main(int argc, char **argv) {
+  int i;
+  int num_failed = 0;
+  for (i = 0; i < REPETITIONS; i++) {
+    if (!test_doacross()) {
+      num_failed++;
+    }
+  }
+  return num_failed;
+}