This is an archive of the discontinued LLVM Phabricator instance.

	Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
	createGpuToLLVMConversionPass(StringRef gpuBinaryAnnotation = {});			createGpuToLLVMConversionPass(StringRef gpuBinaryAnnotation = {});

	/// Collect a set of patterns to convert from the GPU dialect to LLVM.			/// Collect a set of patterns to convert from the GPU dialect to LLVM.
	///			///
	/// A non-empty gpuBinaryAnnotation overrides the pass' command line option.			/// A non-empty gpuBinaryAnnotation overrides the pass' command line option.
	void populateGpuToLLVMConversionPatterns(LLVMTypeConverter &converter,			void populateGpuToLLVMConversionPatterns(LLVMTypeConverter &converter,
	OwningRewritePatternList &patterns,			OwningRewritePatternList &patterns,
	StringRef gpuBinaryAnnotation = {});			StringRef gpuBinaryAnnotation = {});

	/// Creates a pass to convert kernel functions into GPU target object blobs.
	///
	/// This transformation takes the body of each function that is annotated with
	/// the 'gpu.kernel' attribute, copies it to a new LLVM module, compiles the
	/// module with help of the GPU backend to target object and then invokes
	/// the provided blobGenerator to produce a binary blob. Such blob is then
	/// attached as a string attribute to the kernel function.
	///
	/// Following callbacks are to be provided by user:
	/// - loweringCallback : lower the module to an LLVM module.
	/// - blobGenerator : build a blob executable on target GPU.
	///
	/// Information wrt LLVM backend are to be supplied by user:
	/// - triple : target triple to be used.
	/// - targetChip : mcpu to be used.
	/// - features : target-specific features to be used.
	///
	/// Information about result attribute is to be specified by user:
	/// - gpuBinaryAnnotation : the name of the attribute which contains the blob.
	///
	/// After the transformation, the body of the kernel function is removed (i.e.,
	/// it is turned into a declaration).
	///
	/// A non-empty gpuBinaryAnnotation overrides the pass' command line option.
	std::unique_ptr<OperationPass<gpu::GPUModuleOp>>
	createConvertGPUKernelToBlobPass(LoweringCallback loweringCallback,
	BlobGenerator blobGenerator, StringRef triple,
	StringRef targetChip, StringRef features,
	StringRef gpuBinaryAnnotation = {});

	} // namespace mlir			} // namespace mlir

	#endif // MLIR_CONVERSION_GPUCOMMON_GPUCOMMONPASS_H_			#endif // MLIR_CONVERSION_GPUCOMMON_GPUCOMMONPASS_H_

mlir/lib/Conversion/GPUCommon/CMakeLists.txt

Show All 10 Lines	set(AMDGPU_LIBS
AMDGPUCodeGen		AMDGPUCodeGen
AMDGPUDesc		AMDGPUDesc
AMDGPUInfo		AMDGPUInfo
)		)
endif()		endif()

add_mlir_conversion_library(MLIRGPUToGPURuntimeTransforms		add_mlir_conversion_library(MLIRGPUToGPURuntimeTransforms
ConvertLaunchFuncToRuntimeCalls.cpp		ConvertLaunchFuncToRuntimeCalls.cpp
ConvertKernelFuncToBlob.cpp
GPUOpsLowering.cpp		GPUOpsLowering.cpp

DEPENDS		DEPENDS
MLIRConversionPassIncGen		MLIRConversionPassIncGen
intrinsics_gen		intrinsics_gen

LINK_COMPONENTS		LINK_COMPONENTS
Core		Core
Show All 14 Lines

mlir/lib/Conversion/GPUCommon/ConvertKernelFuncToBlob.cpp

This file was deleted.

	//===- ConvertKernelFuncToBlob.cpp - MLIR GPU lowering passes -------------===//
	//
	// 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
	//
	//===----------------------------------------------------------------------===//
	//
	// This file implements a pass to convert gpu kernel functions into a
	// corresponding binary blob that can be executed on a GPU. Currently
	// only translates the function itself but no dependencies.
	//
	//===----------------------------------------------------------------------===//

	#include "mlir/Conversion/GPUCommon/GPUCommonPass.h"

	#include "mlir/Dialect/GPU/GPUDialect.h"
	#include "mlir/Dialect/GPU/Passes.h"
	#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
	#include "mlir/IR/Attributes.h"
	#include "mlir/IR/Builders.h"
	#include "mlir/IR/BuiltinOps.h"
	#include "mlir/Pass/Pass.h"
	#include "mlir/Pass/PassRegistry.h"
	#include "mlir/Support/LogicalResult.h"

	#include "llvm/ADT/Optional.h"
	#include "llvm/ADT/Twine.h"
	#include "llvm/Support/Error.h"
	#include "llvm/Support/Mutex.h"
	#include "llvm/Support/TargetRegistry.h"
	#include "llvm/Support/TargetSelect.h"

	using namespace mlir;

	namespace {

	/// A pass converting tagged kernel modules to a blob with target instructions.
	///
	/// If tagged as a kernel module, each contained function is translated to
	/// user-specified IR. A user provided BlobGenerator then compiles the IR to
	/// GPU binary code, which is then attached as an attribute to the function.
	/// The function body is erased.
	class GpuKernelToBlobPass
	: public PassWrapper<GpuKernelToBlobPass, gpu::SerializeToBlobPass> {
	public:
	GpuKernelToBlobPass(LoweringCallback loweringCallback,
	BlobGenerator blobGenerator, StringRef triple,
	StringRef targetChip, StringRef features,
	StringRef gpuBinaryAnnotation)
	: loweringCallback(loweringCallback), blobGenerator(blobGenerator) {
	if (!triple.empty())
	this->triple = triple.str();
	if (!targetChip.empty())
	this->chip = targetChip.str();
	if (!features.empty())
	this->features = features.str();
	if (!gpuBinaryAnnotation.empty())
	this->gpuBinaryAnnotation = gpuBinaryAnnotation.str();
	}

	private:
	// Translates the 'getOperation()' result to an LLVM module.
	// Note: when this class is removed, this function no longer needs to be
	// virtual.
	std::unique_ptr<llvm::Module>
	translateToLLVMIR(llvm::LLVMContext &llvmContext) override {
	return loweringCallback(getOperation(), llvmContext, "LLVMDialectModule");
	}

	// Serializes the target ISA to binary form.
	std::unique_ptr<std::vector<char>>
	serializeISA(const std::string &isa) override {
	return blobGenerator(isa, getOperation().getLoc(),
	getOperation().getName());
	}

	LoweringCallback loweringCallback;
	BlobGenerator blobGenerator;
	};

	} // anonymous namespace

	std::unique_ptr<OperationPass<gpu::GPUModuleOp>>
	mlir::createConvertGPUKernelToBlobPass(LoweringCallback loweringCallback,
	BlobGenerator blobGenerator,
	StringRef triple, StringRef targetChip,
	StringRef features,
	StringRef gpuBinaryAnnotation) {
	return std::make_unique<GpuKernelToBlobPass>(loweringCallback, blobGenerator,
	triple, targetChip, features,
	gpuBinaryAnnotation);
	}

This is an archive of the discontinued LLVM Phabricator instance.

[mlir] Remove ConvertKernelFuncToBlobClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 331793

mlir/include/mlir/Conversion/GPUCommon/GPUCommonPass.h

mlir/lib/Conversion/GPUCommon/CMakeLists.txt

mlir/lib/Conversion/GPUCommon/ConvertKernelFuncToBlob.cpp

[mlir] Remove ConvertKernelFuncToBlob
ClosedPublic