/// <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> /// Resolves the minimum CUDA driver version for the PTX instruction set /// </summary> /// <param name="instructionSet">The PTX instruction set</param> /// <returns>The minimum driver version</returns> public static CudaDriverVersion GetMinimumDriverVersion(PTXInstructionSet instructionSet) { if (!InstructionSetLookup.TryGetValue(instructionSet, out var result)) { throw new NotSupportedException(RuntimeErrorMessages.NotSupportedPTXInstructionSet); } return(result); }
/// <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 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="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()); }); }