/// <summary>
/// Creates the final kernel transformer for PTX kernels.
/// </summary>
/// <param name="context">The current context.</param>
/// <param name="abi">The current ABI.</param>
/// <param name="builder">The target builder.</param>
private static void CreateKernelTransformers(
Context context,
ABI abi,
ImmutableArray <Transformer> .Builder builder)
{
var specializerConfiguration = new SpecializerConfiguration(
context.Flags,
abi,
context.PTXContextData);
builder.Add(Transformer.Create(
TransformerConfiguration.Empty,
new IntrinsicSpecializer <SpecializerConfiguration>(
specializerConfiguration)));
// Append further backend specific transformations in release mode
var transformerBuilder = Transformer.CreateBuilder(TransformerConfiguration.Empty);
if (!context.HasFlags(ContextFlags.NoInlining))
{
transformerBuilder.Add(new Inliner());
}
if (context.OptimizationLevel == OptimizationLevel.Release)
{
transformerBuilder.Add(new SimplifyControlFlow());
}
var transformations = transformerBuilder.ToTransformer();
if (transformations.Length > 0)
{
builder.Add(transformerBuilder.ToTransformer());
}
}
/// <summary>
/// Constructs a new Cuda backend.
/// </summary>
/// <param name="context">The context to use.</param>
/// <param name="architecture">The target GPU architecture.</param>
/// <param name="instructionSet">The target GPU instruction set.</param>
public PTXBackend(
Context context,
PTXArchitecture architecture,
PTXInstructionSet instructionSet)
: base(
context,
BackendType.PTX,
BackendFlags.None,
new PTXArgumentMapper(context))
{
Architecture = architecture;
InstructionSet = instructionSet;
InitializeKernelTransformers(
Context.HasFlags(ContextFlags.EnableAssertions) ?
IntrinsicSpecializerFlags.EnableAssertions :
IntrinsicSpecializerFlags.None,
builder =>
{
var transformerBuilder = Transformer.CreateBuilder(
TransformerConfiguration.Empty);
transformerBuilder.AddBackendOptimizations(
new PTXAcceleratorSpecializer(),
context.OptimizationLevel);
builder.Add(transformerBuilder.ToTransformer());
});
}
/// <summary>
/// Constructs a new Cuda backend.
/// </summary>
/// <param name="context">The context to use.</param>
/// <param name="architecture">The target gpu architecture.</param>
/// <param name="instructionSet">The target gpu instruction set.</param>
/// <param name="platform">The target platform.</param>
public PTXBackend(
Context context,
PTXArchitecture architecture,
PTXInstructionSet instructionSet,
TargetPlatform platform)
: base(
context,
BackendType.PTX,
BackendFlags.RequiresIntrinsicImplementations,
new PTXABI(context.TypeContext, platform),
_ => new PTXArgumentMapper(context))
{
Architecture = architecture;
InstructionSet = instructionSet;
InitializeKernelTransformers(
new IntrinsicSpecializerConfiguration(context.Flags),
builder =>
{
// Append further backend specific transformations in release mode
var transformerBuilder = Transformer.CreateBuilder(TransformerConfiguration.Empty);
if (context.OptimizationLevel == OptimizationLevel.Release)
{
var acceleratorConfiguration = new AcceleratorSpecializerConfiguration(ABI);
transformerBuilder.Add(
new AcceleratorSpecializer <AcceleratorSpecializerConfiguration>(
acceleratorConfiguration));
}
if (!context.HasFlags(ContextFlags.NoInlining))
{
transformerBuilder.Add(new Inliner());
}
if (context.OptimizationLevel == OptimizationLevel.Release)
{
transformerBuilder.Add(new SimplifyControlFlow());
}
var transformer = transformerBuilder.ToTransformer();
if (transformer.Length > 0)
{
builder.Add(transformer);
}
});
}
/// <summary>
/// Constructs a new OpenCL source backend.
/// </summary>
/// <param name="context">The context to use.</param>
/// <param name="vendor">The associated major vendor.</param>
public CLBackend(Context context, CLAcceleratorVendor vendor)
: base(
context,
BackendType.OpenCL,
BackendFlags.None,
new CLArgumentMapper(context))
{
Vendor = vendor;
InitializeKernelTransformers(
IntrinsicSpecializerFlags.None,
builder =>
{
var transformerBuilder = Transformer.CreateBuilder(
TransformerConfiguration.Empty);
transformerBuilder.AddBackendOptimizations(
new CLAcceleratorSpecializer(),
context.OptimizationLevel);
builder.Add(transformerBuilder.ToTransformer());
});
}
/// <summary>
/// Constructs a new OpenCL source backend.
/// </summary>
/// <param name="context">The context to use.</param>
/// <param name="capabilities">The supported capabilities.</param>
/// <param name="vendor">The associated major vendor.</param>
/// <param name="clStdVersion">The OpenCL C version passed to -cl-std.</param>
public CLBackend(
Context context,
CLCapabilityContext capabilities,
CLDeviceVendor vendor,
CLCVersion clStdVersion)
: base(
context,
capabilities,
BackendType.OpenCL,
new CLArgumentMapper(context))
{
Vendor = vendor;
CLStdVersion = clStdVersion;
InitIntrinsicProvider();
InitializeKernelTransformers(builder =>
{
var transformerBuilder = Transformer.CreateBuilder(
TransformerConfiguration.Empty);
transformerBuilder.AddBackendOptimizations <CodePlacement.GroupOperands>(
new CLAcceleratorSpecializer(
PointerType,
Context.Properties.EnableIOOperations),
context.Properties.InliningMode,
context.Properties.OptimizationLevel);
builder.Add(transformerBuilder.ToTransformer());
});
// Build a list of extensions to enable for each OpenCL kernel.
var extensionBuilder = new StringBuilder();
foreach (var extensionName in Capabilities.Extensions)
{
extensionBuilder.Append("#pragma OPENCL EXTENSION ");
extensionBuilder.Append(extensionName);
extensionBuilder.AppendLine(" : enable");
}
extensions = extensionBuilder.ToString();
}
/// <summary>
/// Constructs a new Cuda backend.
/// </summary>
/// <param name="context">The context to use.</param>
/// <param name="capabilities">The supported capabilities.</param>
/// <param name="architecture">The target GPU architecture.</param>
/// <param name="instructionSet">The target GPU instruction set.</param>
public PTXBackend(
Context context,
CudaCapabilityContext capabilities,
PTXArchitecture architecture,
PTXInstructionSet instructionSet)
: base(
context,
capabilities,
BackendType.PTX,
BackendFlags.None,
new PTXArgumentMapper(context))
{
Architecture = architecture;
InstructionSet = instructionSet;
InitIntrinsicProvider();
InitializeKernelTransformers(
Context.HasFlags(ContextFlags.EnableAssertions) ?
IntrinsicSpecializerFlags.EnableAssertions :
IntrinsicSpecializerFlags.None,
builder =>
{
var transformerBuilder = Transformer.CreateBuilder(
TransformerConfiguration.Empty);
transformerBuilder.AddBackendOptimizations(
new PTXAcceleratorSpecializer(PointerType),
context.Flags,
context.OptimizationLevel);
if (Context.HasFlags(ContextFlags.EnhancedPTXBackendFeatures))
{
// Create an optimized PTX assembler block schedule
transformerBuilder.Add(new PTXBlockScheduling());
transformerBuilder.Add(new DeadCodeElimination());
}
builder.Add(transformerBuilder.ToTransformer());
});
}
/// <summary>
/// Constructs a new Cuda backend.
/// </summary>
/// <param name="context">The context to use.</param>
/// <param name="capabilities">The supported capabilities.</param>
/// <param name="architecture">The target GPU architecture.</param>
/// <param name="instructionSet">The target GPU instruction set.</param>
/// <param name="nvvmAPI">Optional NVVM API instance.</param>
public PTXBackend(
Context context,
CudaCapabilityContext capabilities,
CudaArchitecture architecture,
CudaInstructionSet instructionSet,
NvvmAPI nvvmAPI)
: base(
context,
capabilities,
BackendType.PTX,
new PTXArgumentMapper(context))
{
Architecture = architecture;
InstructionSet = instructionSet;
NvvmAPI = nvvmAPI;
InitIntrinsicProvider();
InitializeKernelTransformers(builder =>
{
var transformerBuilder = Transformer.CreateBuilder(
TransformerConfiguration.Empty);
transformerBuilder.AddBackendOptimizations <CodePlacement.GroupOperands>(
new PTXAcceleratorSpecializer(
PointerType,
Context.Properties.EnableAssertions,
Context.Properties.EnableIOOperations),
context.Properties.InliningMode,
context.Properties.OptimizationLevel);
if (Context.Properties.GetPTXBackendMode() == PTXBackendMode.Enhanced)
{
// Create an optimized PTX assembler block schedule
transformerBuilder.Add(new PTXBlockScheduling());
transformerBuilder.Add(new DeadCodeElimination());
}
builder.Add(transformerBuilder.ToTransformer());
});
}
/// <summary>
/// Constructs a new OpenCL source backend.
/// </summary>
/// <param name="context">The context to use.</param>
/// <param name="capabilities">The supported capabilities.</param>
/// <param name="vendor">The associated major vendor.</param>
public CLBackend(
Context context,
CLCapabilityContext capabilities,
CLAcceleratorVendor vendor)
: base(
context,
capabilities,
BackendType.OpenCL,
BackendFlags.None,
new CLArgumentMapper(context))
{
Vendor = vendor;
InitIntrinsicProvider();
InitializeKernelTransformers(
IntrinsicSpecializerFlags.None,
builder =>
{
var transformerBuilder = Transformer.CreateBuilder(
TransformerConfiguration.Empty);
transformerBuilder.AddBackendOptimizations(
new CLAcceleratorSpecializer(PointerType),
context.Flags,
context.OptimizationLevel);
builder.Add(transformerBuilder.ToTransformer());
});
// Build a list of extensions to enable for each OpenCL kernel.
var extensionBuilder = new StringBuilder();
foreach (var extensionName in Capabilities.Extensions)
{
extensionBuilder.Append("#pragma OPENCL EXTENSION ");
extensionBuilder.Append(extensionName);
extensionBuilder.AppendLine(" : enable");
}
extensions = extensionBuilder.ToString();
}
/// <summary>
/// Constructs a new Cuda backend.
/// </summary>
/// <param name="context">The context to use.</param>
/// <param name="architecture">The target GPU architecture.</param>
/// <param name="instructionSet">The target GPU instruction set.</param>
public PTXBackend(
Context context,
PTXArchitecture architecture,
PTXInstructionSet instructionSet)
: base(
context,
BackendType.PTX,
BackendFlags.None,
new PTXArgumentMapper(context))
{
Architecture = architecture;
InstructionSet = instructionSet;
InitializeKernelTransformers(
Context.HasFlags(ContextFlags.EnableAssertions) ?
IntrinsicSpecializerFlags.EnableAssertions :
IntrinsicSpecializerFlags.None,
builder =>
{
var transformerBuilder = Transformer.CreateBuilder(
TransformerConfiguration.Empty);
transformerBuilder.AddBackendOptimizations(
new PTXAcceleratorSpecializer(),
context.OptimizationLevel);
// Append further backend specific transformations in release mode
if (!context.HasFlags(ContextFlags.NoInlining))
{
transformerBuilder.Add(new Inliner());
}
if (context.OptimizationLevel > OptimizationLevel.O0)
{
transformerBuilder.Add(new SimplifyControlFlow());
}
builder.Add(transformerBuilder.ToTransformer());
});
}
