[test-suite, CUDA] Filter out long-running redundant SIMD tests.

[tra]

Summary

The tests do not depend on C++ library or C++ dialect.

We only need SIMD tests on CUDA-8.0 and 9.2. First one is to verify our
reference implementation against CUDA-provided one. The second one actually
tests clang-provided implementation of these functions.

[tra]

Use [] to escape special characters in the regex.
Otherwise I have to use "\\\\" which is way too many characters for my taste.

[jlebar]

External/CUDA/CMakeLists.txt

97 ↗

(On Diff #157609)

, and on

test-suite/trunk/External/CUDA/CMakeLists.txt

macro(cuda_glob Var)
   foreach(File IN LISTS FileList)
     if(${File} MATCHES ".*\.cu$")
       set_source_files_properties(${File} PROPERTIES LANGUAGE CXX)
     endif()
   endforeach()
   set(${Var} ${FileList})
 endmacro(cuda_glob)
 
-macro(create_one_local_test Name FileGlob)
+macro(create_one_local_test_f Name FileGlob FilterRegex)
+  if (${VariantSuffix} MATCHES ${FilterRegex})
     cuda_glob(_sources ${FileGlob})
     set(_executable ${Name}-${VariantSuffix})
     set(_executable_path ${CMAKE_CURRENT_BINARY_DIR}/${_executable})
     # Verify reference output if it exists.
     if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${Name}.reference_output)
       set(NO_REFERENCE_OUTPUT 1)
       set(REFERENCE_OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/${Name}.reference_output)
       llvm_test_traditional(${_executable})
     else()
       # otherwise just run the executable.
       llvm_test_run()
     endif()
     llvm_test_executable(${_executable} ${_sources})
     target_compile_options(${_executable} PUBLIC ${VariantCPPFLAGS})
     if(VariantLibs)
       target_link_libraries(${_executable} ${VariantLibs})
     endif()
     add_dependencies(cuda-tests-simple-${VariantSuffix} ${_executable})
     # Local tests are presumed to be fast.
     list(APPEND CUDA_SIMPLE_TEST_TARGETS ${_executable}.test)
+  endif()
+endmacro()
+
+macro(create_one_local_test Name FileGlob)
+  create_one_local_test_f(${Name} ${FileGlob} ".*")
 endmacro()
 
 # Create targets for CUDA tests that are part of the test suite.
 macro(create_local_cuda_tests VariantSuffix)
   create_one_local_test(assert assert.cu)
   create_one_local_test(axpy axpy.cu)
   create_one_local_test(algorithm algorithm.cu)
   create_one_local_test(cmath cmath.cu)
   create_one_local_test(complex complex.cu)
   create_one_local_test(math_h math_h.cu)
   create_one_local_test(new new.cu)
   create_one_local_test(empty empty.cu)
   create_one_local_test(printf printf.cu)
   create_one_local_test(future future.cu)
-  create_one_local_test(simd simd.cu)
+  # We only need SIMD tests on CUDA-8.0 to verivy that our reference is correct
+  # and matches NVIDIA-provided one.  and on CUDA-9.2 to verify that clang's
+  # implementation matches the reference.  This test also happens to be the
+  # longest one, so by not running unnecessary instances we speed up cuda
+  # buildbot a lot.
+  create_one_local_test_f(simd simd.cu
+                          "cuda-(8[.]0|9[.]2)-c[+][+]11-libc[+][+]")
 endmacro()
 
 macro(thrust_make_test_name TestName TestSourcePath)
   string(REPLACE "${THRUST_PATH}/testing/" "" _tmp ${TestSourcePath})
   string(REPLACE "/" "-" _tmp ${_tmp})
   string(REPLACE "<" "_" _tmp ${_tmp})
   string(REPLACE ">" "_" _tmp ${_tmp})
   string(REGEX REPLACE "\.(cpp|cu)$" "" _tmp ${_tmp})