/// <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()); }); }