[SYCLomatic][CMake] Refine dpct.cmake file and migration of CUDA_VERSION and set_target_properties (#2792)

tomflinda · web-flow · commit 27f5cf0213c2 · 2025-04-24T17:15:45.000+08:00
Signed-off-by: chenwei.sun &lt;chenwei.sun@intel.com&gt;
diff --git a/clang/include/clang/Tooling/Core/Replacement.h b/clang/include/clang/Tooling/Core/Replacement.h
@@ -436,6 +436,8 @@ struct TranslationUnitReplacements {
 #ifdef SYCLomatic_CUSTOMIZATION
   std::vector<MainSourceFileInfo> MainSourceFilesDigest;
   std::string DpctVersion = "";
+  std::string SDKVersionMajor = "";
+  std::string SDKVersionMinor = "";
   std::string MainHelperFileName = "";
   std::string USMLevel = ""; // deprecated
 
diff --git a/clang/include/clang/Tooling/ReplacementsYaml.h b/clang/include/clang/Tooling/ReplacementsYaml.h
@@ -269,6 +269,8 @@ template <> struct MappingTraits<clang::tooling::TranslationUnitReplacements> {
 #ifdef SYCLomatic_CUSTOMIZATION
     Io.mapOptional("MainSourceFilesDigest", Doc.MainSourceFilesDigest);
     Io.mapOptional("DpctVersion", Doc.DpctVersion);
+    Io.mapOptional("SDKVersionMajor", Doc.SDKVersionMajor);
+    Io.mapOptional("SDKVersionMinor", Doc.SDKVersionMinor);
     Io.mapOptional("MainHelperFileName", Doc.MainHelperFileName);
     Io.mapOptional("USMLevel", Doc.USMLevel);
     // Keep here only for backward compatibility - begin
diff --git a/clang/lib/DPCT/DPCT.cpp b/clang/lib/DPCT/DPCT.cpp
@@ -463,6 +463,59 @@ void parseFormatStyle() {
   DpctGlobalInfo::setCodeFormatStyle(Style);
 }
 
+void updateCompatibilityVersionInfo(clang::tooling::UnifiedPath OutRoot,
+                                    std::string Major, std::string Minor) {
+  const std::string CmakeHelpFile =
+      appendPath(OutRoot.getCanonicalPath().str(), "dpct.cmake");
+  std::ifstream InFile(CmakeHelpFile);
+  if (!InFile) {
+    std::string ErrMsg = "Failed to open file: " + CmakeHelpFile;
+    ShowStatus(MigrationErrorReadWriteCMakeHelperFile, std::move(ErrMsg));
+    dpctExit(MigrationErrorReadWriteCMakeHelperFile);
+  }
+
+  const std::string VersionStr = Major + "." + Minor;
+  const int CompatibilityValue = std::stoi(Major) * 10 + std::stoi(Minor);
+  std::vector<std::string> Lines;
+  std::string Line;
+  bool Inserted = false;
+
+  // Constant block of content to insert
+  const std::vector<std::string> CompatibilityBlock = {
+      "set(COMPATIBILITY_VERSION " + VersionStr + ")",
+      "set(COMPATIBILITY_VALUE " + std::to_string(CompatibilityValue) + ")",
+      "set(COMPATIBILITY_VERSION_MAJOR " + Major + ")",
+      "set(COMPATIBILITY_VERSION_MINOR " + Minor + ")",
+      "" // Add an empty line for good format
+  };
+
+  auto isCommentOrEmpty = [](const std::string &Line) {
+    return Line.empty() || Line[0] == '#';
+  };
+
+  while (std::getline(InFile, Line)) {
+    // Insert the compatibility definition block after the first comment section
+    if (!Inserted && !isCommentOrEmpty(Line)) {
+      Lines.insert(Lines.end(), CompatibilityBlock.begin(),
+                   CompatibilityBlock.end());
+      Inserted = true;
+    }
+    Lines.push_back(Line);
+  }
+  InFile.close();
+
+  std::ofstream OutFile(CmakeHelpFile);
+  if (!OutFile) {
+    std::string ErrMsg = "Failed to write to file: " + CmakeHelpFile;
+    ShowStatus(MigrationErrorReadWriteCMakeHelperFile, std::move(ErrMsg));
+    dpctExit(MigrationErrorReadWriteCMakeHelperFile);
+  }
+  for (const auto &Line : Lines) {
+    OutFile << Line << "\n";
+  }
+  OutFile.close();
+}
+
 static void loadMainSrcFileInfo(clang::tooling::UnifiedPath OutRoot) {
   std::string YamlFilePath = appendPath(OutRoot.getCanonicalPath().str(),
                                         DpctGlobalInfo::getYamlFileName());
@@ -471,7 +524,16 @@ static void loadMainSrcFileInfo(clang::tooling::UnifiedPath OutRoot) {
     if (loadFromYaml(YamlFilePath, *PreTU) != 0) {
       llvm::errs() << getLoadYamlFailWarning(YamlFilePath);
     }
+
+    if (MigrateBuildScriptOnly || DpctGlobalInfo::migrateCMakeScripts()) {
+      std::string Major = PreTU->SDKVersionMajor;
+      std::string Minor = PreTU->SDKVersionMinor;
+      if (!Major.empty() && !Minor.empty()) {
+        updateCompatibilityVersionInfo(OutRoot, Major, Minor);
+      }
+    }
   }
+
   for (auto &Entry : PreTU->MainSourceFilesDigest) {
     if (Entry.HasCUDASyntax)
       MainSrcFilesHasCudaSyntex.insert(Entry.MainSourceFile);
diff --git a/clang/lib/DPCT/ErrorHandle/Error.cpp b/clang/lib/DPCT/ErrorHandle/Error.cpp
@@ -220,6 +220,10 @@ void ShowStatus(int Status, std::string Message) {
   case MigrationErrorInvalidInstallPath:
     StatusString = "Error: " + Message + " not found.";
     break;
+  case MigrationErrorReadWriteCMakeHelperFile:
+    StatusString =
+        "Error: " + Message + ". Please check the file access permission.";
+    break;
   default:
     DpctLog() << "Unknown error.\n";
     dpctExit(-1);
diff --git a/clang/lib/DPCT/ErrorHandle/Error.h b/clang/lib/DPCT/ErrorHandle/Error.h
@@ -67,6 +67,7 @@ enum ProcessStatus {
   MigrationErrorCannotWrite = -52,
   MigratePythonBuildScriptOnlyNotSpecifed = -53,
   MigratePythonBuildScriptSpecifiedButPythonRuleFileNotSpecified = -54,
+  MigrationErrorReadWriteCMakeHelperFile = -55,
 };
 
 namespace clang {
diff --git a/clang/lib/DPCT/IncMigration/ExternalReplacement.cpp b/clang/lib/DPCT/IncMigration/ExternalReplacement.cpp
@@ -62,6 +62,11 @@ int save2Yaml(
   }
 
   TUR.DpctVersion = clang::dpct::getDpctVersionStr();
+
+  auto Ver = clang::getCudaVersionPair(DpctGlobalInfo::getSDKVersion());
+  TUR.SDKVersionMajor = std::to_string(Ver.first);
+  TUR.SDKVersionMinor = std::to_string(Ver.second);
+
   TUR.OptionMap = clang::dpct::DpctGlobalInfo::getCurrentOptMap();
 
   YAMLOut << TUR;
diff --git a/clang/test/dpct/cmake_migration/case_015/expected.txt b/clang/test/dpct/cmake_migration/case_015/expected.txt
@@ -24,25 +24,23 @@ set_target_properties(target_one PROPERTIES CXX_Standard 14)
 set_target_properties(target_one PROPERTIES CXX_STANDARD 17)
 
 # Test CUDA_SEPARABLE_COMPILATION
-#[[
-set_target_properties(target_one PROPERTIES CUDA_SEPARABLE_COMPILATION Off)]]
+set_target_properties(target_one PROPERTIES "" "")
 
 # No change unless property matches exactly
 set_target_properties(target_one PROPERTIES Cuda_SEPARABLE_COMPILATION Off)
 
 # Test CUDA_ARCHITECHTURES
-#[[
-set_target_properties(target_one PROPERTIES CUDA_ARCHITECHTURES Auto)]]
+set_target_properties(target_one PROPERTIES "" "")
 
 # No change unless property matches exactly
 set_target_properties(target_one PROPERTIES cuda_architechtures All)
 
 add_library(target_two MODULE nosrc2.dp.cpp)
 
 # Test two target specs
-#[[
-set_target_properties(target_one target_two PROPERTIES CUDA_ARCHITECHTURES Kepler+Tesla)]]
+set_target_properties(target_one target_two PROPERTIES "" "")
 
 # Make sure other properties are intact
 set_target_properties(target_one PROPERTIES OTHER_PROPERTY 1)
 
+set_target_properties(target PROPERTIES "" "")
diff --git a/clang/test/dpct/cmake_migration/case_015/input.cmake b/clang/test/dpct/cmake_migration/case_015/input.cmake
@@ -64,3 +64,7 @@ set_target_properties(target_one
                       CUDA_ARCHITECHTURES Kepler+Tesla
                       OTHER_PROPERTY 1)
 
+set_target_properties(target
+    PROPERTIES
+        CUDA_SEPARABLE_COMPILATION ON
+   )
diff --git a/clang/test/dpct/cmake_migration/case_019/expected.txt b/clang/test/dpct/cmake_migration/case_019/expected.txt
@@ -1,12 +1,10 @@
-if (COMPATIBILITY_VERSION VERSION_LESS 10.2)
+if (COMPATIBILITY_VALUE VERSION_LESS 10.2)
 	message(FATAL_ERROR "low version!.")
 endif()
 
 string(REGEX REPLACE "([0-9]+)\\.([0-9]+).*" "\\1" VERSION_MAJOR "${COMPATIBILITY_VERSION}")
 
-list(APPEND LIBS ${CUDA_HOME}/${COMPATIBILITY_VERSION}/lib64)
-
-set(CMAKE_CUDA_VERSION ${COMPATIBILITY_VERSION})
+set(CMAKE_CUDA_VERSION ${COMPATIBILITY_VALUE})
 
 if (COMPATIBILITY_VERSION_STRING STRGREATER "9.0")
     find_package(Eigen3 3.3.5 REQUIRED NO_MODULE)
diff --git a/clang/test/dpct/cmake_migration/case_019/input.cmake b/clang/test/dpct/cmake_migration/case_019/input.cmake
@@ -2,9 +2,7 @@ if (CUDA_VERSION VERSION_LESS 10.2)
 	message(FATAL_ERROR "low version!.")
 endif()
 
-string(REGEX REPLACE "([0-9]+)\\.([0-9]+).*" "\\1" VERSION_MAJOR "${CUDA_VERSION}")
-
-list(APPEND LIBS ${CUDA_HOME}/${CUDA_VERSION}/lib64)
+string(REGEX REPLACE "([0-9]+)\\.([0-9]+).*" "\\1" VERSION_MAJOR "${CMAKE_CUDA_COMPILER_VERSION}")
 
 set(CMAKE_CUDA_VERSION ${CUDA_VERSION})
 
diff --git a/clang/test/dpct/cmake_migration/case_048/MainSourceFiles.yaml b/clang/test/dpct/cmake_migration/case_048/MainSourceFiles.yaml
@@ -46,6 +46,8 @@ MainSourceFilesDigest:
     Digest:          9f681b5a2cafa7dff67d7e4ac13d1302
     HasCUDASyntax:   false
 DpctVersion:     19.0.0
+SDKVersionMajor: '12'
+SDKVersionMinor: '0'
 MainHelperFileName: ''
 USMLevel:        ''
 FeatureMap:      {}
diff --git a/clang/test/dpct/cmake_migration/case_048/case_048_test_extension_name.cpp b/clang/test/dpct/cmake_migration/case_048/case_048_test_extension_name.cpp
@@ -5,3 +5,6 @@
 // RUN: cp %S/MainSourceFiles.yaml ./out/MainSourceFiles.yaml
 // RUN: dpct -in-root ./ -out-root out  ./input.cmake --migrate-build-script-only
 // RUN: diff --strip-trailing-cr %S/expected.txt %T/out/input.cmake >> %T/diff.txt
+
+// RUN: test  -f %T/out/input.cmake
+// RUN: diff --strip-trailing-cr %S/dpct_ref.cmake  %T/out/dpct.cmake >> %T/diff.txt
diff --git a/clang/test/dpct/cmake_migration/case_048/dpct_ref.cmake b/clang/test/dpct/cmake_migration/case_048/dpct_ref.cmake
@@ -0,0 +1,165 @@
+#==---- dpct.cmake --------------------------------- cmake script file ----==//
+#
+# Copyright (C) Intel Corporation
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+# See https://llvm.org/LICENSE.txt for license information.
+#
+#===----------------------------------------------------------------------===//
+
+set(COMPATIBILITY_VERSION 12.0)
+set(COMPATIBILITY_VALUE 120)
+set(COMPATIBILITY_VERSION_MAJOR 12)
+set(COMPATIBILITY_VERSION_MINOR 0)
+
+macro(_DPCT_GET_SOURCES _sources)
+  set( ${_sources} )
+  foreach(arg ${ARGN})
+    # Assume arg is a source file
+    list(APPEND ${_sources} ${arg})
+  endforeach()
+endmacro()
+
+macro(_DPCT_CREATE_BUILD_COMMAND sycl_target generated_files)
+  set(_argn_list "${ARGN}")
+  set(_generated_files "")
+  set(generated_extension ${CMAKE_CXX_OUTPUT_EXTENSION})
+
+  set(_counter 1) # use to unique the generated obj file name
+  set(_sycl_target "${sycl_target}")
+  set(options)
+  if (UNIX)
+    set(options -fPIC -shared)
+  else()
+    set(options -shared)
+  endif()
+
+  set(sources)
+
+  set(is_options FALSE)
+  foreach(arg ${_argn_list})
+    if (is_options)
+      list(APPEND options ${arg})
+    elseif (${arg} STREQUAL "OPTIONS")
+      set(is_options TRUE)
+      continue()
+    else()
+      list(APPEND sources ${arg})
+    endif()
+  endforeach()
+
+  # Iterate each macro arguments and create custom command for each cpp file
+  foreach(file ${sources})
+    if(${file} MATCHES "\\.cpp")
+        get_filename_component( basename ${file} NAME )
+    
+        set(generated_file_basename "${sycl_target}_${_counter}_generated_${basename}${generated_extension}")
+        set(generated_file "${CMAKE_CURRENT_BINARY_DIR}/${generated_file_basename}")
+
+        get_filename_component(file_path "${file}" PATH)
+        if(IS_ABSOLUTE "${file_path}")
+            set(source_file "${file}")
+        else()
+            set(source_file "${CMAKE_CURRENT_SOURCE_DIR}/${file}")
+        endif()
+
+        add_custom_command(
+          OUTPUT ${generated_file}
+          COMMAND icpx -fsycl  ${options} -o ${generated_file} ${source_file}
+          DEPENDS ${file}
+        )
+
+        list(APPEND _generated_files ${generated_file})
+    else()
+        message(FATAL_ERROR "Only support cpp file.")
+    endif()
+
+    math(EXPR _counter "${_counter} + 1")
+  endforeach()
+
+  set(${generated_files} ${_generated_files})
+endmacro()
+
+macro(_DPCT_COMPILE_SYCL_CODE_IMP sycl_target generated_files)
+  set(_sycl_target "${sycl_target}")
+  _DPCT_GET_SOURCES(_sources ${ARGN})
+
+  # Create custom command for each cpp source file
+  _DPCT_CREATE_BUILD_COMMAND( ${_sycl_target} _generated_files ${_sources})
+
+  set( ${generated_files} ${_generated_files})
+endmacro()
+
+# Return generated device code files from input SYCL source files
+macro(DPCT_HELPER_COMPILE_SYCL_CODE generated_files)
+  _DPCT_COMPILE_SYCL_CODE_IMP(sycl_device ${generated_files} ${ARGN})
+endmacro()
+
+# Always set SYCL_HAS_FP16 to true to assume SYCL device to support float16
+message("dpct.cmake: SYCL_HAS_FP16 is set true by default.")
+set(SYCL_HAS_FP16 TRUE)
+
+# Return the list of object file paths generated for the given SYCL source files
+macro(DPCT_HELPER_SYCL_COMPILE generated_files)
+  _DPCT_GET_SOURCES(_sources ${ARGN})
+
+  # can't continue without list of source files
+  if("${_sources}" STREQUAL "")
+    message(FATAL "Failed to find the source files while running the macro 'DPCT_HELPER_SYCL_COMPILE'")
+  endif()
+
+  _DPCT_CREATE_BUILD_COMMAND("sycl_device" ${generated_files} ${_sources})
+endmacro()
+
+if(WIN32)
+    set(DNN_LIB "dnnl.lib")
+    set(MKL_LIB "-Qmkl")
+else()
+    set(DNN_LIB "dnnl")
+    set(MKL_LIB "-qmkl")
+endif()
+
+# Link MKL library to target
+macro(DPCT_HELPER_ADD_MKL_TO_TARGET target)
+  if(WIN32)
+    target_compile_options(${target} PUBLIC -fsycl /DMKL_ILP64 /Qmkl:parallel /Qtbb /MD)
+    target_link_libraries(${target} PUBLIC -fsycl OpenCL.lib)
+  elseif(UNIX AND NOT APPLE)
+    target_compile_options(${target} PUBLIC -fsycl -DMKL_ILP64 -qmkl=parallel -qtbb)
+    target_link_libraries(${target} PUBLIC -qmkl=parallel -qtbb -fsycl)
+  else()
+    message(FATAL_ERROR "Unsupported platform")
+  endif()
+endmacro()
+
+set(CMAKE_SYCL_COMPILER "icpx")
+set(CMAKE_SYCL_ARCHITECTURES "")
+set(CMAKE_SYCL_FLAGS "")
+
+if(NOT DEFINED COMPATIBILITY_VERSION)
+  set(COMPATIBILITY_VERSION 99.9)
+endif()
+
+if(NOT DEFINED COMPATIBILITY_VALUE)
+  set(COMPATIBILITY_VALUE 999)
+endif()
+
+if(NOT DEFINED COMPATIBILITY_VERSION_MAJOR)
+  set(COMPATIBILITY_VERSION_MAJOR 99)
+endif()
+
+if(NOT DEFINED COMPATIBILITY_VERSION_MINOR)
+  set(COMPATIBILITY_VERSION_MINOR 99)
+endif()
+
+set(COMPATIBILITY_VERSION_STRING "${COMPATIBILITY_VERSION}")
+set(SYCL_TOOLKIT_ROOT_DIR "${ONEAPI_ROOT}")
+set(SYCL_TOOLKIT_INCLUDE "${SYCL_INCLUDE_DIR}")
+# The SYCL runtime library is auto-loaded when option `-fsycl` is specified. So we can
+# safely set the CUDAToolkit_LIBRARY_DIR to ""
+set(SYCLToolkit_LIBRARY_DIR "${SYCL_INCLUDE_DIR}/../lib")
+set(SYCL_HOST_COMPILER "icpx")
+set(SYCL_HOST_FLAGS "")
+
+# 'SYCL_COMPILER_EXECUTABLE' is used to specify the path to the SYCL Compiler (icpx).
+set(SYCL_COMPILER_EXECUTABLE "${SYCL_INCLUDE_DIR}/../bin/icpx")
+set(SYCL_PROPAGATE_HOST_FLAGS "")
diff --git a/clang/tools/dpct/cmake/dpct.cmake b/clang/tools/dpct/cmake/dpct.cmake
@@ -129,9 +129,23 @@ endmacro()
 set(CMAKE_SYCL_COMPILER "icpx")
 set(CMAKE_SYCL_ARCHITECTURES "")
 set(CMAKE_SYCL_FLAGS "")
-set(COMPATIBILITY_VERSION 99.9)
-set(COMPATIBILITY_VERSION_MAJOR 99)
-set(COMPATIBILITY_VERSION_MINOR 9)
+
+if(NOT DEFINED COMPATIBILITY_VERSION)
+  set(COMPATIBILITY_VERSION 99.9)
+endif()
+
+if(NOT DEFINED COMPATIBILITY_VALUE)
+  set(COMPATIBILITY_VALUE 999)
+endif()
+
+if(NOT DEFINED COMPATIBILITY_VERSION_MAJOR)
+  set(COMPATIBILITY_VERSION_MAJOR 99)
+endif()
+
+if(NOT DEFINED COMPATIBILITY_VERSION_MINOR)
+  set(COMPATIBILITY_VERSION_MINOR 99)
+endif()
+
 set(COMPATIBILITY_VERSION_STRING "${COMPATIBILITY_VERSION}")
 set(SYCL_TOOLKIT_ROOT_DIR "${ONEAPI_ROOT}")
 set(SYCL_TOOLKIT_INCLUDE "${SYCL_INCLUDE_DIR}")
diff --git a/clang/tools/dpct/extensions/cmake_rules/cmake_script_migration_rule.yaml b/clang/tools/dpct/extensions/cmake_rules/cmake_script_migration_rule.yaml
