LLvm rebase (#65)

leizhenyuan · EikanWang · xiaolil1 · web-flow · commit 964b63916d27 · 2023-08-25T09:09:13.000+08:00
* Rebase to LLVM master - 57882fe76e1826593cd0e53f73484b184c5007c4

* add spirv ConvertUToPtrOp and ConvertptrToUOp

* add support for external call

* changes for std::optional

* fix for precommit

* intergrate with llvm

* using own llvm

* fix typo

* for preci and auto download

* add script for build llvm

* add TRITON_INTEL_LLVM

* fix precommit

* use TRITON_CODEGEN_INTEL_XPU_BACKEND

* change llvm version

* change to ubuntu 22.04

* remove unuse envs

---------

Co-authored-by: Wang, Eikan &lt;eikan.wang@intel.com&gt;
Co-authored-by: xiaolil1 &lt;xiaoli.liu@intel.com&gt;
Co-authored-by: Zhong, Ruijie &lt;ruijie.zhong@intel.com&gt;
Co-authored-by: Wang, Chuanqi &lt;chuanqi.wang@intel.com&gt;
diff --git a/.github/scripts/build_llvm.sh b/.github/scripts/build_llvm.sh
@@ -0,0 +1,90 @@
+set -e -x
+git clone https://github.com/leizhenyuan/llvm-project.git -b xpu_llvm_rebase ./private-llvm
+
+CURRENT_DIR="$(pwd)"
+
+SOURCE_DIR=$CURRENT_DIR/private-llvm
+install_prefix=""
+platform=""
+build_config=""
+arch="x86"
+num_jobs=8
+
+usage() {
+  echo "Usage: bash build_llvm.bash -o INSTALL_PREFIX -p PLATFORM -c CONFIG [-a ARCH] [-j NUM_JOBS]"
+  echo "Ex: bash build_llvm.bash -o llvm-16.0.0-x86_64-linux-gnu-ubuntu-18.04 -p docker_ubuntu-18.04 -c assert -j 16"
+  echo "INSTALL_PREFIX = <string> # \${INSTALL_PREFIX}.tar.xz is created"
+  echo "PLATFORM       = {local|docker_ubuntu_18.04|docker_centos7}"
+  echo "CONFIG         = {release|assert|debug}"
+  echo "ARCH           = {x86|arm64}"
+  echo "NUM_JOBS       = {1|2|3|...}"
+  exit 1;
+}
+
+while getopts "o:p:c:a:j:l" arg; do
+	case "$arg" in
+		o)
+			install_prefix="$OPTARG"
+			;;
+		p)
+			platform="$OPTARG"
+			;;
+		c)
+			build_config="$OPTARG"
+			;;
+		a)
+			arch="$OPTARG"
+			;;
+		j)
+			num_jobs="$OPTARG"
+			;;
+		*)
+			usage
+			;;
+
+	esac
+done
+
+if [ x"$install_prefix" == x ] || [ x"$platform" == x ] || [ x"$build_config" == x ]; then
+  usage
+fi
+
+# Set up CMake configurations
+CMAKE_CONFIGS="-DLLVM_ENABLE_PROJECTS=mlir -DLLVM_USE_LINKER=gold -DLLVM_ENABLE_LTO=OFF"
+if [ x"$arch" == x"arm64" ]; then
+  CMAKE_CONFIGS="${CMAKE_CONFIGS}"
+else
+  CMAKE_CONFIGS="${CMAKE_CONFIGS} -DLLVM_TARGETS_TO_BUILD=X86;NVPTX;AMDGPU"
+fi
+
+if [ x"$build_config" == x"release" ]; then
+  CMAKE_CONFIGS="${CMAKE_CONFIGS} -DCMAKE_BUILD_TYPE=Release"
+elif [ x"$build_config" == x"assert" ]; then
+  CMAKE_CONFIGS="${CMAKE_CONFIGS} -DCMAKE_BUILD_TYPE=MinSizeRel -DLLVM_ENABLE_ASSERTIONS=True"
+elif [ x"$build_config" == x"debug" ]; then
+  CMAKE_CONFIGS="${CMAKE_CONFIGS} -DCMAKE_BUILD_TYPE=Debug"
+else
+  usage
+fi
+
+
+# Create a temporary build directory
+BUILD_DIR="$(mktemp -d)"
+echo "Using a temporary directory for the build: $BUILD_DIR"
+rm -rf "$BUILD_DIR"
+mkdir -p "$BUILD_DIR"
+
+
+# Build LLVM locally
+pushd "$BUILD_DIR"
+echo ${CMAKE_CONFIGS}
+cmake "$SOURCE_DIR/llvm" -DCMAKE_INSTALL_PREFIX="$BUILD_DIR/$install_prefix" $CMAKE_CONFIGS
+make -j${num_jobs} install
+tar -cJf "${SOURCE_DIR}/${install_prefix}.tar.xz" "$install_prefix"
+popd
+
+mv $SOURCE_DIR/$install_prefix.tar.xz $(pwd)
+# Remove the temporary directory
+rm -rf "$BUILD_DIR"
+
+echo "Completed!"
diff --git a/.github/workflows/triton_xpu_backend_ci.yml b/.github/workflows/triton_xpu_backend_ci.yml
@@ -62,7 +62,6 @@ jobs:
         run:  |
           source ${HOME}/miniconda3/bin/activate triton-preci
           source ${HOME}/env_triton.sh
-          export LLVM_SYSPATH=${HOME}/triton-preci/llvm/build/
           pip install pybind11
           pip uninstall -y triton
           cd triton/python
diff --git a/.github/workflows/triton_xpu_backend_e2e_ci.yml b/.github/workflows/triton_xpu_backend_e2e_ci.yml
@@ -57,7 +57,6 @@ jobs:
         run:  |
           source ${HOME}/miniconda3/bin/activate triton-preci
           source ${HOME}/env_triton.sh
-          export LLVM_SYSPATH=${HOME}/triton-preci/llvm/build/
           pip uninstall -y triton
           sudo update-ca-certificates --fresh
           export SSL_CERT_DIR=/etc/ssl/certs
diff --git a/.github/workflows/triton_xpu_backend_e2e_nightly.yml b/.github/workflows/triton_xpu_backend_e2e_nightly.yml
@@ -54,7 +54,6 @@ jobs:
         run:  |
           source ${HOME}/miniconda3/bin/activate triton-nightly-test
           source ${HOME}/env_triton.sh
-          export LLVM_SYSPATH=${HOME}/triton-nightly/llvm/build/
           pip uninstall -y triton
           sudo update-ca-certificates --fresh
           export SSL_CERT_DIR=/etc/ssl/certs
diff --git a/.github/workflows/triton_xpu_backend_nightly.yml b/.github/workflows/triton_xpu_backend_nightly.yml
@@ -56,7 +56,6 @@ jobs:
         run:  |
           source ${HOME}/miniconda3/bin/activate triton-nightly-test
           source ${HOME}/env_triton.sh
-          export LLVM_SYSPATH=${HOME}/triton-nightly/llvm/build/
           pip install pybind11
           pip uninstall -y triton
           cd triton/python
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,9 +1,101 @@
 
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
+if (DEFINED ENV{TRITON_INTEL_LLVM_DIR})
+MESSAGE(STATUS "[intel_xpu_backend]: using user provide llvm path")
+else ()
+
+if (DEFINED ENV{TRITON_CODEGEN_INTEL_XPU_BACKEND})
+MESSAGE(STATUS "[intel_xpu_backend]: using intel_llvm")
+
+SET(TRITON_INTEL_LLVM_DIR $ENV{HOME}/.triton/intel_llvm)
+MESSAGE(STATUS "[intel_xpu_backend]: set intel llvm path ${TRITON_INTEL_LLVM_DIR}")
+if (EXISTS ${TRITON_INTEL_LLVM_DIR})
+MESSAGE(STATUS "[intel_xpu_backend]: using previous exists llvm")
+else()
+include(FetchContent)
+function(download_file url)
+
+FetchContent_Declare(intel-llvm
+URL ${url}
+SOURCE_DIR ${TRITON_INTEL_LLVM_DIR}
+)
+
+FetchContent_Populate(intel-llvm)
+endfunction(download_file)
+
+MESSAGE(STATUS "[intel_xpu_backend]: downloading intel llvm for intel_xpu_backend, path ${TRITON_INTEL_LLVM_DIR}")
+download_file(
+    https://github.com/intel/intel-xpu-backend-for-triton/releases/download/llvm_pkg_v0.1/llvm+mlir-17.0.0-x86_64-linux-gnu-ubuntu-22.04-release.tar.xz
+)
+endif()
+MESSAGE(STATUS "[intel_xpu_backend]:Triton uses LLVM version ${LLVM_PACKAGE_VERSION} with revision ${LLVM_GIT_REVISION}")
+MESSAGE(STATUS "[intel_xpu_backend]:Use the LLVM version with revision to re-config for the intel_xpu_backend")
+
+# hints from https://stackoverflow.com/questions/10205986/how-to-capture-cmake-command-line-arguments
+# Propagate the CMake vars to the intel xpu backend
+
+set(CMAKE_ARGS "${CMAKE_ARGS};-DLLVM_DIR=${TRITON_INTEL_LLVM_DIR}")
+set(CMAKE_ARGS "${CMAKE_ARGS};-DLLVM_INCLUDE_DIRS=${TRITON_INTEL_LLVM_DIR}/include")
+set(CMAKE_ARGS "${CMAKE_ARGS};-DLLVM_LIBRARY_DIR=${TRITON_INTEL_LLVM_DIR}/lib")
+
+
+else ()
+MESSAGE(STATUS "[intel_xpu_backend]: using original llvm ")
+
+set(XPU_BACKEND_RECURSIVE ON)
+endif()
+endif()
+
+if(XPU_BACKEND_RECURSIVE)
+set(TRITON_BUILD_PYTHON_MODULE ON)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/include) # Tablegen'd files
 
 add_subdirectory(include)
 add_subdirectory(lib)
 add_subdirectory(python)
+else()
+
+
+
+get_cmake_property(CACHE_VARS CACHE_VARIABLES)
+foreach(CACHE_VAR ${CACHE_VARS})
+    get_property(CACHE_VAR_HELPSTRING CACHE ${CACHE_VAR} PROPERTY HELPSTRING)
+    get_property(CACHE_VAR_TYPE CACHE ${CACHE_VAR} PROPERTY TYPE)
+    if(CACHE_VAR_TYPE STREQUAL "UNINITIALIZED")
+        set(CACHE_VAR_TYPE)
+    else()
+        set(CACHE_VAR_TYPE :${CACHE_VAR_TYPE})
+    endif()
+
+    if(CACHE_VAR STREQUAL "TRITON_BUILD_TUTORIALS")
+        set(CMAKE_ARGS "${CMAKE_ARGS};-D${CACHE_VAR}${CACHE_VAR_TYPE}=OFF")
+    elseif(CACHE_VAR STREQUAL "TRITON_BUILD_PYTHON_MODULE")
+        set(CMAKE_ARGS "${CMAKE_ARGS};-D${CACHE_VAR}${CACHE_VAR_TYPE}=OFF")
+    elseif(CACHE_VAR STREQUAL "LLVM_LIBRARY_DIR")
+        continue()
+    elseif(CACHE_VAR STREQUAL "LLVM_DIR")
+        continue()
+    elseif(CACHE_VAR STREQUAL "LLVM_INCLUDE_DIRS")
+        continue()
+    else()
+        set(CMAKE_ARGS "${CMAKE_ARGS};-D${CACHE_VAR}${CACHE_VAR_TYPE}=${${CACHE_VAR}}")
+    endif()
+endforeach()
+
+execute_process(COMMAND ${CMAKE_COMMAND}
+        ${CMAKE_ARGS}
+        -DXPU_BACKEND_RECURSIVE=ON
+        -S ${PROJECT_SOURCE_DIR}
+        -B ${CMAKE_CURRENT_BINARY_DIR}/triton)
+
+add_custom_target(intel_xpu_backend_for_triton ALL
+        COMMAND
+        ${CMAKE_COMMAND} --build . --config ${CMAKE_BUILD_TYPE} --target intel_xpu_backend_for_triton
+        WORKING_DIRECTORY  ${CMAKE_CURRENT_BINARY_DIR}/triton
+        COMMENT "Building intel_xpu_backend_for_triton"
+        VERBATIM
+        USES_TERMINAL)
+
+endif()
diff --git a/lib/Conversion/TritonGPUToSPIRV/ElementwiseOpToSPIRV.cpp b/lib/Conversion/TritonGPUToSPIRV/ElementwiseOpToSPIRV.cpp
@@ -394,12 +394,11 @@ struct FpToFpOpSPIRVConversion
     NamedAttrList attributes(extraAttrs);
     attributes.set("libname", StringAttr::get(v.getContext(), libName));
     attributes.set("libpath", StringAttr::get(v.getContext(), ""));
-    attributes.set("linkage_attributes",
-                   ArrayAttr::get(v.getContext(),
-                                  {
-                                      StringAttr::get(v.getContext(), funcName),
-                                      StringAttr::get(v.getContext(), "Import"),
-                                  }));
+    auto linkageTypeAttr =
+        b.getAttr<::mlir::spirv::LinkageTypeAttr>(spirv::LinkageType::Import);
+    auto linkageAttr = b.getAttr<::mlir::spirv::LinkageAttributesAttr>(
+        funcName.lower(), linkageTypeAttr);
+    attributes.set("linkage_attributes", linkageAttr);
     auto ret =
         b.create<spirv::FuncOp>(v.getLoc(), funcName, funcType,
                                 spirv::FunctionControl::Inline, attributes);
@@ -655,13 +654,11 @@ struct ExternElementwiseSPIRVConversion
         "libname", StringAttr::get(op->getContext(), op.getLibname()));
     ret.getOperation()->setAttr(
         "libpath", StringAttr::get(op->getContext(), op.getLibpath()));
-    ret.getOperation()->setAttr(
-        "linkage_attributes",
-        ArrayAttr::get(op->getContext(),
-                       {
-                           StringAttr::get(op->getContext(), funcName),
-                           StringAttr::get(op->getContext(), "Import"),
-                       }));
+    auto linkageTypeAttr =
+        b.getAttr<::mlir::spirv::LinkageTypeAttr>(spirv::LinkageType::Import);
+    auto linkageAttr = b.getAttr<::mlir::spirv::LinkageAttributesAttr>(
+        funcName.lower(), linkageTypeAttr);
+    ret.getOperation()->setAttr("linkage_attributes", linkageAttr);
     return ret;
   }
 };
@@ -1019,8 +1016,8 @@ void populateElementwiseOpToSPIRVPatterns(
   POPULATE_UNARY_OP(math::SqrtOp, math::SqrtOp)
   POPULATE_UNARY_OP(math::ExpOp, math::ExpOp)
   POPULATE_UNARY_OP(triton::BitcastOp, spirv::BitcastOp)
-  POPULATE_UNARY_OP(triton::IntToPtrOp, spirv::BitcastOp)
-  POPULATE_UNARY_OP(triton::PtrToIntOp, spirv::BitcastOp)
+  POPULATE_UNARY_OP(triton::IntToPtrOp, spirv::ConvertUToPtrOp)
+  POPULATE_UNARY_OP(triton::PtrToIntOp, spirv::ConvertPtrToUOp)
 #undef POPULATE_UNARY_OP
 
   patterns.add<CmpIOpSPIRVConversion>(typeConverter, context, benefit);
diff --git a/lib/Conversion/TritonGPUToSPIRV/TypeConverter.cpp b/lib/Conversion/TritonGPUToSPIRV/TypeConverter.cpp
@@ -47,7 +47,8 @@ MAP_FN(spirv::StorageClass::StorageBuffer, 0)                                \
   MAP_FN(spirv::StorageClass::HostOnlyINTEL, 23)
 #endif
 
-Optional<spirv::StorageClass> getStorageClassForMemorySpace(unsigned space) {
+std::optional<spirv::StorageClass>
+getStorageClassForMemorySpace(unsigned space) {
 #define STORAGE_SPACE_MAP_FN(storage, space)                                   \
   case space:                                                                  \
     return storage;
@@ -63,38 +64,38 @@ Optional<spirv::StorageClass> getStorageClassForMemorySpace(unsigned space) {
 TritonGPUToSPIRVTypeConverter::TritonGPUToSPIRVTypeConverter(
     spirv::TargetEnvAttr &targetAttr, SPIRVConversionOptions &option)
     : SPIRVTypeConverter(targetAttr, option) {
-  addConversion([&](triton::PointerType type) -> llvm::Optional<Type> {
+  addConversion([&](triton::PointerType type) -> std::optional<Type> {
     return convertTritonPointerType(type);
   });
-  addConversion([&](RankedTensorType type) -> llvm::Optional<Type> {
+  addConversion([&](RankedTensorType type) -> std::optional<Type> {
     return convertTritonTensorType(type);
   });
-  addConversion([&](mlir::VectorType type) -> llvm::Optional<Type> {
+  addConversion([&](mlir::VectorType type) -> std::optional<Type> {
     // Recursively translate vector type
     return mlir::VectorType::get(type.getShape(),
                                  convertType(type.getElementType()));
   });
   // Internally store float8 as int8
-  addConversion([&](mlir::Float8E4M3FNType type) -> llvm::Optional<Type> {
+  addConversion([&](mlir::Float8E4M3FNType type) -> std::optional<Type> {
     llvm::report_fatal_error("SPIRV doesn't support fp8 type");
     return IntegerType::get(type.getContext(), 8);
   });
-  addConversion([&](mlir::Float8E5M2Type type) -> llvm::Optional<Type> {
+  addConversion([&](mlir::Float8E5M2Type type) -> std::optional<Type> {
     llvm::report_fatal_error("SPIRV doesn't support fp8 type");
     return IntegerType::get(type.getContext(), 8);
   });
   // Internally store bfloat16 as int16
-  addConversion([&](BFloat16Type type) -> llvm::Optional<Type> {
+  addConversion([&](BFloat16Type type) -> std::optional<Type> {
     return IntegerType::get(type.getContext(), 16);
   });
   addConversion(
-      [&](IndexType type) -> llvm::Optional<Type> { return getIndexType(); });
+      [&](IndexType type) -> std::optional<Type> { return getIndexType(); });
 
   // Add generic source and target materializations to handle cases where
   // non-SPIRV types persist after an SPIRV conversion.
   addSourceMaterialization([&](OpBuilder &builder, Type resultType,
                                ValueRange inputs,
-                               Location loc) -> Optional<Value> {
+                               Location loc) -> std::optional<Value> {
     if (inputs.size() != 1)
       return std::nullopt;
 
@@ -103,7 +104,7 @@ TritonGPUToSPIRVTypeConverter::TritonGPUToSPIRVTypeConverter(
   });
   addTargetMaterialization([&](OpBuilder &builder, Type resultType,
                                ValueRange inputs,
-                               Location loc) -> Optional<Value> {
+                               Location loc) -> std::optional<Value> {
     if (inputs.size() != 1)
       return std::nullopt;
 
@@ -115,7 +116,7 @@ TritonGPUToSPIRVTypeConverter::TritonGPUToSPIRVTypeConverter(
 Type TritonGPUToSPIRVTypeConverter::convertTritonPointerType(
     triton::PointerType type) {
   // Recursively translate pointee type
-  Optional<spirv::StorageClass> storageClass =
+  std::optional<spirv::StorageClass> storageClass =
       getStorageClassForMemorySpace(type.getAddressSpace());
   assert(storageClass && "uncompatible pointer address type in SPIRV");
   return spirv::PointerType::get(convertType(type.getPointeeType()),
diff --git a/lib/Target/CMakeLists.txt b/lib/Target/CMakeLists.txt
@@ -1 +1,3 @@
 add_subdirectory(SPIRV)
+
+set_target_properties(SPIRV-Tools-shared PROPERTIES EXCLUDE_FROM_ALL ON)

Original file line number	Diff line number	Diff line change
`@@ -1 +1,3 @@`
`1`	`1`	`add_subdirectory(SPIRV)`
	`2`	`+`
	`3`	`+set_target_properties(SPIRV-Tools-shared PROPERTIES EXCLUDE_FROM_ALL ON)`