[mlir] Move cuda tests

[csigg]

Summary

Move test inputs to test/Integration directory.
Move runtime wrappers to ExecutionEngine.

[csigg]

Conditionally add mlir_cuda_runtime to test dependencies.

[csigg]

I have no idea why clang-tidy flags code in ADT that I didn't touch.

[mehdi_amini]

Can you double check that the mlir-nvidia buildbot is configured to activate the integration tests first?

[csigg]

In D97463#2588265, @mehdi_amini wrote:

Can you double check that the mlir-nvidia buildbot is configured to activate the integration tests first?

Thanks for reminding me. It looks like it isn't:
https://github.com/llvm/llvm-zorg/blob/c816513763961852ae753378e0525dd8e508d168/buildbot/osuosl/master/config/builders.py#L1086

I will send a patch. I hope it's OK for the mlir-nvidia bot to run all integration tests?

[csigg]

Rebase.

[csigg]

Fix clang-tidy, hopefully.

[csigg]

Needs C++14, not C++11.

mlir/lib/ExecutionEngine/CMakeLists.txt

 # Exclude these from libMLIR.so because the JIT infrastructure
 # is a big dependency which most don't need.
 
 set(LLVM_OPTIONAL_SOURCES
   AsyncRuntime.cpp
   CRunnerUtils.cpp
+  CudaRuntimeWrappers.cpp
   SparseUtils.cpp
   ExecutionEngine.cpp
   RunnerUtils.cpp
   OptUtils.cpp
   JitRunner.cpp
   )
 
 add_mlir_library(MLIRExecutionEngine
add_mlir_library(mlir_async_runtime
   EXCLUDE_FROM_LIBMLIR
 
   LINK_LIBS PUBLIC
   ${LLVM_PTHREAD_LIB}
 )
 set_property(TARGET mlir_async_runtime PROPERTY CXX_VISIBILITY_PRESET hidden)
 target_compile_definitions(mlir_async_runtime PRIVATE mlir_async_runtime_EXPORTS)
 
+if(MLIR_CUDA_RUNNER_ENABLED)
+  # Configure CUDA support. Using check_language first allows us to give a
+  # custom error message.
+  include(CheckLanguage)
+  check_language(CUDA)
+  if (CMAKE_CUDA_COMPILER)
+    enable_language(CUDA)
+  else()
+    message(SEND_ERROR
+      "Building the mlir cuda runner requires a working CUDA install")
+  endif()
+
+  # We need the libcuda.so library.
+  find_library(CUDA_RUNTIME_LIBRARY cuda)
+
+  add_mlir_library(mlir_cuda_runtime
+    SHARED
+    CudaRuntimeWrappers.cpp
+
+    EXCLUDE_FROM_LIBMLIR
+  )
+  set_property(TARGET mlir_cuda_runtime PROPERTY CXX_STANDARD 14)
+  target_include_directories(mlir_cuda_runtime
+    PRIVATE
+    ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES}
+  )
+  target_link_libraries(mlir_cuda_runtime
+    PRIVATE
+    ${CUDA_RUNTIME_LIBRARY}
+  )
+endif()

mlir/lib/ExecutionEngine/CudaRuntimeWrappers.cpp

-//===- cuda-runtime-wrappers.cpp - MLIR CUDA runner wrapper library -------===//
+//===- CudaRuntimeWrappers.cpp - MLIR CUDA API wrapper library ------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Implements C wrappers around the CUDA library for easy linking in ORC jit.

mlir/test/CMakeLists.txt

llvm_canonicalize_cmake_booleans(
   )
 
 # Passed to lit.site.cfg.py.in to set up the path where to find the libraries
 # for linalg integration tests.
 set(MLIR_DIALECT_LINALG_INTEGRATION_TEST_LIB_DIR ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
 set(MLIR_RUNNER_UTILS_DIR ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
 
 # Passed to lit.site.cfg.py.in to set up the path where to find the libraries
-# for the mlir cuda / rocm / spirv / vulkan runner tests.
-set(MLIR_CUDA_WRAPPER_LIBRARY_DIR ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
+# for the mlir rocm / spirv / vulkan runner tests.
 set(MLIR_ROCM_WRAPPER_LIBRARY_DIR ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
 set(MLIR_SPIRV_WRAPPER_LIBRARY_DIR ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
 set(MLIR_VULKAN_WRAPPER_LIBRARY_DIR ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
 
 if (MLIR_INCLUDE_INTEGRATION_TESTS)
   set(INTEL_SDE_EXECUTABLE "" CACHE STRING
       "If set, arch-specific integration tests are run with Intel SDE.")
   option(MLIR_RUN_AVX512_TESTS "Run AVX512 tests.")
set(MLIR_TEST_DEPENDS
   mlir-sdbm-api-test
   mlir-tblgen
   mlir-translate
   mlir_runner_utils
   mlir_c_runner_utils
   mlir_async_runtime
   )
 
+if(MLIR_CUDA_RUNNER_ENABLED)
+  list(APPEND MLIR_TEST_DEPENDS mlir_cuda_runtime)
+endif()
+
 list(APPEND MLIR_TEST_DEPENDS MLIRUnitTests)
 
 if(LLVM_BUILD_EXAMPLES)
   list(APPEND MLIR_TEST_DEPENDS
     toyc-ch1
     toyc-ch2
     toyc-ch3
     toyc-ch4

mlir/test/Integration/GPU/CUDA/all-reduce-and.mlir

 // RUN: mlir-cuda-runner %s \
 // RUN:   -gpu-to-cubin="gpu-binary-annotation=nvvm.cubin" \
 // RUN:   -gpu-to-llvm="gpu-binary-annotation=nvvm.cubin" \
-// RUN:   --shared-libs=%cuda_wrapper_library_dir/libcuda-runtime-wrappers%shlibext \
+// RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_cuda_runtime%shlibext \
 // RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
 // RUN:   --entry-point-result=void \
 // RUN: | FileCheck %s
 
 func @main() {
   %data = alloc() : memref<2x6xi32>
   %sum = alloc() : memref<2xi32>
   %cst0 = constant 0 : i32

mlir/test/Integration/GPU/CUDA/all-reduce-max.mlir

 // RUN: mlir-cuda-runner %s \
 // RUN:   -gpu-to-cubin="gpu-binary-annotation=nvvm.cubin" \
 // RUN:   -gpu-to-llvm="gpu-binary-annotation=nvvm.cubin" \
-// RUN:   --shared-libs=%cuda_wrapper_library_dir/libcuda-runtime-wrappers%shlibext \
+// RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_cuda_runtime%shlibext \
 // RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
 // RUN:   --entry-point-result=void \
 // RUN: | FileCheck %s
 
 func @main() {
   %data = alloc() : memref<2x6xi32>
   %sum = alloc() : memref<2xi32>
   %cst0 = constant 0 : i32

mlir/test/Integration/GPU/CUDA/all-reduce-min.mlir

 // RUN: mlir-cuda-runner %s \
 // RUN:   -gpu-to-cubin="gpu-binary-annotation=nvvm.cubin" \
 // RUN:   -gpu-to-llvm="gpu-binary-annotation=nvvm.cubin" \
-// RUN:   --shared-libs=%cuda_wrapper_library_dir/libcuda-runtime-wrappers%shlibext \
+// RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_cuda_runtime%shlibext \
 // RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
 // RUN:   --entry-point-result=void \
 // RUN: | FileCheck %s
 
 func @main() {
   %data = alloc() : memref<2x6xi32>
   %sum = alloc() : memref<2xi32>
   %cst0 = constant 0 : i32

mlir/test/Integration/GPU/CUDA/all-reduce-op.mlir

 // RUN: mlir-cuda-runner %s \
 // RUN:   -gpu-to-cubin="gpu-binary-annotation=nvvm.cubin" \
 // RUN:   -gpu-to-llvm="gpu-binary-annotation=nvvm.cubin" \
-// RUN:   --shared-libs=%cuda_wrapper_library_dir/libcuda-runtime-wrappers%shlibext \
+// RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_cuda_runtime%shlibext \
 // RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
 // RUN:   --entry-point-result=void \
 // RUN: | FileCheck %s
 
 // CHECK-COUNT-8: [{{(5356, ){12}5356}}]
 func @main() {
   %arg = alloc() : memref<2x4x13xf32>
   %dst = memref_cast %arg : memref<2x4x13xf32> to memref<?x?x?xf32>

mlir/test/Integration/GPU/CUDA/all-reduce-or.mlir

 // RUN: mlir-cuda-runner %s \
 // RUN:   -gpu-to-cubin="gpu-binary-annotation=nvvm.cubin" \
 // RUN:   -gpu-to-llvm="gpu-binary-annotation=nvvm.cubin" \
-// RUN:   --shared-libs=%cuda_wrapper_library_dir/libcuda-runtime-wrappers%shlibext \
+// RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_cuda_runtime%shlibext \
 // RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
 // RUN:   --entry-point-result=void \
 // RUN: | FileCheck %s
 
 func @main() {
   %data = alloc() : memref<2x6xi32>
   %sum = alloc() : memref<2xi32>
   %cst0 = constant 0 : i32

mlir/test/Integration/GPU/CUDA/all-reduce-region.mlir

 // RUN: mlir-cuda-runner %s \
 // RUN:   -gpu-to-cubin="gpu-binary-annotation=nvvm.cubin" \
 // RUN:   -gpu-to-llvm="gpu-binary-annotation=nvvm.cubin" \
-// RUN:   --shared-libs=%cuda_wrapper_library_dir/libcuda-runtime-wrappers%shlibext \
+// RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_cuda_runtime%shlibext \
 // RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
 // RUN:   --entry-point-result=void \
 // RUN: | FileCheck %s
 
 // CHECK: [{{(35, ){34}35}}]
 func @main() {
   %arg = alloc() : memref<35xf32>
   %dst = memref_cast %arg : memref<35xf32> to memref<?xf32>

mlir/test/Integration/GPU/CUDA/all-reduce-xor.mlir

 // RUN: mlir-cuda-runner %s \
 // RUN:   -gpu-to-cubin="gpu-binary-annotation=nvvm.cubin" \
 // RUN:   -gpu-to-llvm="gpu-binary-annotation=nvvm.cubin" \
-// RUN:   --shared-libs=%cuda_wrapper_library_dir/libcuda-runtime-wrappers%shlibext \
+// RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_cuda_runtime%shlibext \
 // RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
 // RUN:   --entry-point-result=void \
 // RUN: | FileCheck %s
 
 func @main() {
   %data = alloc() : memref<2x6xi32>
   %sum = alloc() : memref<2xi32>
   %cst0 = constant 0 : i32

mlir/test/Integration/GPU/CUDA/async.mlir

 // RUN: mlir-cuda-runner %s \
 // RUN:   -gpu-to-cubin="gpu-binary-annotation=nvvm.cubin" \
 // RUN:   -gpu-async-region -async-ref-counting \
 // RUN:   -gpu-to-llvm="gpu-binary-annotation=nvvm.cubin" \
 // RUN:   -async-to-async-runtime -convert-async-to-llvm -convert-std-to-llvm \
-// RUN:   --shared-libs=%cuda_wrapper_library_dir/libcuda-runtime-wrappers%shlibext \
+// RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_cuda_runtime%shlibext \
 // RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_async_runtime%shlibext \
 // RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
 // RUN:   --entry-point-result=void -O0 \
 // RUN: | FileCheck %s
 
 func @main() {
   %c0    = constant 0 : index
   %c1    = constant 1 : index

mlir/test/Integration/GPU/CUDA/gpu-to-cubin.mlir

 // RUN: mlir-cuda-runner %s \
 // RUN:   -gpu-to-cubin="gpu-binary-annotation=nvvm.cubin" \
 // RUN:   -gpu-to-llvm="gpu-binary-annotation=nvvm.cubin" \
-// RUN:   --shared-libs=%cuda_wrapper_library_dir/libcuda-runtime-wrappers%shlibext \
+// RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_cuda_runtime%shlibext \
 // RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
 // RUN:   --entry-point-result=void \
 // RUN: | FileCheck %s
 
 func @other_func(%arg0 : f32, %arg1 : memref<?xf32>) {
   %cst = constant 1 : index
   %c0 = constant 0 : index
   %cst2 = dim %arg1, %c0 : memref<?xf32>

mlir/test/Integration/GPU/CUDA/multiple-all-reduce.mlir

 // RUN: mlir-cuda-runner %s \
 // RUN:   -gpu-to-cubin="gpu-binary-annotation=nvvm.cubin" \
 // RUN:   -gpu-to-llvm="gpu-binary-annotation=nvvm.cubin" \
-// RUN:   --shared-libs=%cuda_wrapper_library_dir/libcuda-runtime-wrappers%shlibext \
+// RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_cuda_runtime%shlibext \
 // RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
 // RUN:   --entry-point-result=void \
 // RUN: | FileCheck %s
 
 func @main() {
   %data = alloc() : memref<2x6xf32>
   %sum = alloc() : memref<2xf32>
   %mul = alloc() : memref<2xf32>

mlir/test/Integration/GPU/CUDA/shuffle.mlir

 // RUN: mlir-cuda-runner %s \
 // RUN:   -gpu-to-cubin="gpu-binary-annotation=nvvm.cubin" \
 // RUN:   -gpu-to-llvm="gpu-binary-annotation=nvvm.cubin" \
-// RUN:   --shared-libs=%cuda_wrapper_library_dir/libcuda-runtime-wrappers%shlibext \
+// RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_cuda_runtime%shlibext \
 // RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
 // RUN:   --entry-point-result=void \
 // RUN: | FileCheck %s
 
 // CHECK: [4, 5, 6, 7, 0, 1, 2, 3, 12, -1, -1, -1, 8]
 func @main() {
   %arg = alloc() : memref<13xf32>
   %dst = memref_cast %arg : memref<13xf32> to memref<?xf32>

mlir/test/Integration/GPU/CUDA/two-modules.mlir

 // RUN: mlir-cuda-runner %s \
 // RUN:   -gpu-to-cubin="gpu-binary-annotation=nvvm.cubin" \
 // RUN:   -gpu-to-llvm="gpu-binary-annotation=nvvm.cubin" \
-// RUN:   --shared-libs=%cuda_wrapper_library_dir/libcuda-runtime-wrappers%shlibext \
+// RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_cuda_runtime%shlibext \
 // RUN:   --shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
 // RUN:   --entry-point-result=void \
 // RUN: | FileCheck %s
 
 // CHECK: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
 func @main() {
   %arg = alloc() : memref<13xi32>
   %dst = memref_cast %arg : memref<13xi32> to memref<?xi32>

mlir/test/lit.cfg.py

 # The following tools are optional
 tools.extend([
     ToolSubst('%PYTHON', config.python_executable, unresolved='ignore'),
     ToolSubst('toy-ch1', unresolved='ignore'),
     ToolSubst('toy-ch2', unresolved='ignore'),
     ToolSubst('toy-ch3', unresolved='ignore'),
     ToolSubst('toy-ch4', unresolved='ignore'),
     ToolSubst('toy-ch5', unresolved='ignore'),
-    ToolSubst('%cuda_wrapper_library_dir', config.cuda_wrapper_library_dir, unresolved='ignore'),
     ToolSubst('%linalg_test_lib_dir', config.linalg_test_lib_dir, unresolved='ignore'),
     ToolSubst('%mlir_runner_utils_dir', config.mlir_runner_utils_dir, unresolved='ignore'),
     ToolSubst('%rocm_wrapper_library_dir', config.rocm_wrapper_library_dir, unresolved='ignore'),
     ToolSubst('%spirv_wrapper_library_dir', config.spirv_wrapper_library_dir, unresolved='ignore'),
     ToolSubst('%vulkan_wrapper_library_dir', config.vulkan_wrapper_library_dir, unresolved='ignore'),
     ToolSubst('%mlir_integration_test_dir', config.mlir_integration_test_dir, unresolved='ignore'),
 ])
 llvm_config.add_tool_substitutions(tools, tool_dirs)

mlir/test/lit.site.cfg.py.in

 config.host_arch = "@HOST_ARCH@"
 config.mlir_src_root = "@MLIR_SOURCE_DIR@"
 config.mlir_obj_root = "@MLIR_BINARY_DIR@"
 config.mlir_runner_utils_dir = "@MLIR_RUNNER_UTILS_DIR@"
 config.mlir_tools_dir = "@MLIR_TOOLS_DIR@"
 config.linalg_test_lib_dir = "@MLIR_DIALECT_LINALG_INTEGRATION_TEST_LIB_DIR@"
 config.build_examples = @LLVM_BUILD_EXAMPLES@
 config.run_cuda_tests = @MLIR_CUDA_CONVERSIONS_ENABLED@
-config.cuda_wrapper_library_dir = "@MLIR_CUDA_WRAPPER_LIBRARY_DIR@"
 config.enable_cuda_runner = @MLIR_CUDA_RUNNER_ENABLED@
 config.run_rocm_tests = @MLIR_ROCM_CONVERSIONS_ENABLED@
 config.rocm_wrapper_library_dir = "@MLIR_ROCM_WRAPPER_LIBRARY_DIR@"
 config.enable_rocm_runner = @MLIR_ROCM_RUNNER_ENABLED@
 config.spirv_wrapper_library_dir = "@MLIR_SPIRV_WRAPPER_LIBRARY_DIR@"
 config.enable_spirv_cpu_runner = @MLIR_SPIRV_CPU_RUNNER_ENABLED@
 config.vulkan_wrapper_library_dir = "@MLIR_VULKAN_WRAPPER_LIBRARY_DIR@"
 config.enable_vulkan_runner = @MLIR_VULKAN_RUNNER_ENABLED@

mlir/tools/mlir-cuda-runner/CMakeLists.txt

 set(LLVM_OPTIONAL_SOURCES
-  cuda-runtime-wrappers.cpp
   mlir-cuda-runner.cpp
   )
 set(LLVM_LINK_COMPONENTS
   Core
   Support
 )
 
 if(MLIR_CUDA_RUNNER_ENABLED)
if(MLIR_CUDA_RUNNER_ENABLED)
   else()
     message(SEND_ERROR
       "Building the mlir cuda runner requires a working CUDA install")
   endif()
 
   # We need the libcuda.so library.
   find_library(CUDA_RUNTIME_LIBRARY cuda)
 
-  add_mlir_library(cuda-runtime-wrappers
-    SHARED
-    cuda-runtime-wrappers.cpp
-
-    EXCLUDE_FROM_LIBMLIR
-  )
-  target_include_directories(cuda-runtime-wrappers
-    PRIVATE
-    ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES}
-  )
-  target_link_libraries(cuda-runtime-wrappers
-    PRIVATE
-    ${CUDA_RUNTIME_LIBRARY}
-  )
-
   get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS)
   set(LIBS
     ${conversion_libs}
     MLIRJitRunner
     MLIRAnalysis
     MLIRAsync
     MLIREDSC
     MLIRExecutionEngine
if(MLIR_CUDA_RUNNER_ENABLED)
   FOREACH(t ${TARGET_LIBS})
     LIST(APPEND targets_to_link "LLVM${t}")
   ENDFOREACH(t)
 
   add_llvm_tool(mlir-cuda-runner
     mlir-cuda-runner.cpp
 
     DEPENDS
-    cuda-runtime-wrappers
+    mlir_cuda_runtime
     )
   target_include_directories(mlir-cuda-runner
     PRIVATE ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES}
   )
   llvm_update_compile_flags(mlir-cuda-runner)
   target_link_libraries(mlir-cuda-runner PRIVATE ${LIBS} ${targets_to_link})
 
 endif()