ikra 0.0.1 → 0.0.2

data/lib/translator/commands/array_stencil_command.rb

@@ -0,0 +1,129 @@
+module Ikra
+    module Translator
+        class CommandTranslator < Symbolic::Visitor
+            def visit_array_stencil_command(command)
+                Log.info("Translating ArrayStencilCommand [#{command.unique_id}]")
+
+                super
+
+                num_dims = command.dimensions.size
+
+                # Process dependent computation (receiver), returns [InputTranslationResult]
+                input = translate_entire_input(command)
+
+                # Count number of parameters
+                num_parameters = command.offsets.size
+
+                # All variables accessed by this block should be prefixed with the unique ID
+                # of the command in the environment.
+                env_builder = @environment_builder[command.unique_id]
+
+                block_translation_result = Translator.translate_block(
+                    block_def_node: command.block_def_node,
+                    environment_builder: env_builder,
+                    lexical_variables: command.lexical_externals,
+                    command_id: command.unique_id,
+                    entire_input_translation: input)
+
+                kernel_builder.add_methods(block_translation_result.aux_methods)
+                kernel_builder.add_block(block_translation_result.block_source)
+
+                # Compute indices in all dimensions
+                index_generators = (0...num_dims).map do |dim_index|
+                    index_div = command.dimensions.drop(dim_index + 1).reduce(1, :*)
+                    index_mod = command.dimensions[dim_index]
+
+                    if dim_index > 0
+                         "(_tid_ / #{index_div}) % #{index_mod}"
+                    else
+                        # No modulo required for first dimension
+                        "_tid_ / #{index_div}"
+                    end
+                end
+
+                compute_indices = index_generators.map.with_index do |gen, dim_index|
+                    "int temp_stencil_dim_#{dim_index} = #{gen};"
+                end.join("\n")
+
+                # Check if an index is out of bounds in any dimension
+                out_of_bounds_check = Array.new(num_dims) do |dim_index|
+                    min_in_dim = command.offsets.map do |offset|
+                        offset[dim_index]
+                    end.min
+                    max_in_dim = command.offsets.map do |offset|
+                        offset[dim_index]
+                    end.max
+                    
+                    dim_size = command.dimensions[dim_index]
+
+                    if dim_size.is_a?(String)
+                        # This is not a compile-time constant. Pass dimension size as argument
+                        # to the kernel.
+
+                        dim_size_expr = "dim_size_#{dim_index}"
+                        kernel_builder.add_additional_parameters("int #{dim_size_expr}")
+                        kernel_launcher.add_additional_arguments(dim_size)
+                    else
+                        dim_size_expr = dim_size
+                    end
+
+                    "temp_stencil_dim_#{dim_index} + #{min_in_dim} >= 0 && temp_stencil_dim_#{dim_index} + #{max_in_dim} < #{dim_size_expr}"
+                end.join(" && ")
+
+                # `previous_result` should be an expression returning the array containing the
+                # result of the previous computation.
+                previous_result = input.result(0)
+
+                arguments = ["_env_"]
+
+                # Pass values from previous computation that are required by this thread.
+                # Reconstruct actual indices from indices for each dimension.
+                for i in 0...num_parameters
+                    multiplier = 1
+                    global_index = []
+
+                    for dim_index in (num_dims - 1).downto(0)
+                        global_index.push("(temp_stencil_dim_#{dim_index} + #{command.offsets[i][dim_index]}) * #{multiplier}")
+
+                        next_dim_size = command.dimensions[dim_index]
+
+                        if next_dim_size.is_a?(String)
+                            Log.warn("Cannot handle multi-dimensional stencil computations in host sections yet.")
+                        else
+                            multiplier = multiplier * next_dim_size
+                        end
+                    end
+
+                    arguments.push("#{previous_result}[#{global_index.join(" + ")}]")
+                end
+
+                # Push additional arguments (e.g., index)
+                arguments.push(*input.result(1..-1))
+                argument_str = arguments.join(", ")
+                stencil_computation = block_translation_result.function_name + "(#{argument_str})"
+
+                temp_var_name = "temp_stencil_#{CommandTranslator.next_unique_id}"
+
+                # The following template checks if there is at least one index out of bounds. If
+                # so, the fallback value is used. Otherwise, the block is executed.
+                command_execution = Translator.read_file(file_name: "stencil_body.cpp", replacements: {
+                    "execution" => input.execution,
+                    "temp_var" => temp_var_name,
+                    "result_type" => command.result_type.to_c_type,
+                    "compute_indices" => compute_indices,
+                    "out_of_bounds_check" => out_of_bounds_check,
+                    "out_of_bounds_fallback" => command.out_of_range_value.to_s,
+                    "stencil_computation" => stencil_computation})
+
+                command_translation = build_command_translation_result(
+                    execution: command_execution,
+                    result: temp_var_name,
+                    command: command)
+
+                Log.info("DONE translating ArrayStencilCommand [#{command.unique_id}]")
+
+                return command_translation
+            end
+        end
+    end
+end

data/lib/translator/commands/array_zip_command.rb

@@ -0,0 +1,30 @@
+module Ikra
+    module Translator
+        class CommandTranslator < Symbolic::Visitor
+            def visit_array_zip_command(command)
+                Log.info("Translating ArrayZipCommand [#{command.unique_id}]")
+                
+                super
+
+                # Process dependent computation (receiver), returns [InputTranslationResult]
+                input = translate_entire_input(command)
+
+                # Get Ikra struct type
+                zipped_type_singleton = command.result_type.singleton_type
+
+                # Add struct type to program builder, so that we can generate the source code
+                # for its definition.
+                program_builder.structs.add(zipped_type_singleton)
+
+                command_translation = CommandTranslationResult.new(
+                    execution: input.execution,
+                    result: zipped_type_singleton.generate_inline_initialization(input.result),
+                    command: command)
+
+                Log.info("DONE translating ArrayZipCommand [#{command.unique_id}]")
+
+                return command_translation
+            end
+        end
+    end
+end

data/lib/translator/commands/command_translator.rb

@@ -0,0 +1,264 @@
+require_relative "../translator"
+require_relative "../../config/configuration"
+require_relative "../../config/os_configuration"
+require_relative "../../symbolic/symbolic"
+require_relative "../../symbolic/visitor"
+require_relative "../../types/types"
+require_relative "../input_translator"
+
+module Ikra
+    module Translator
+        class CommandTranslator < Symbolic::Visitor
+            @@unique_id = 0
+
+            def self.next_unique_id
+                @@unique_id = @@unique_id + 1
+                return @@unique_id
+            end
+
+            class CommandTranslationResult
+                # Source code that performs the computation of this command for one thread. May 
+                # consist of multiple statement. Optional.
+                attr_reader :execution
+
+                # Source code that returns the result of the computation. If the computation can
+                # be expressed in a single expression, this string can contain the entire
+                # computation and `execution` should then be empty.
+                attr_reader :result
+
+                attr_reader :command
+
+                def initialize(execution: "", result:, command:)
+                    @execution = execution
+                    @command = command
+                    @result = result;
+                end
+
+                def result_type
+                    return command.result_type
+                end
+            end
+
+            # Entry point for translator. Returns a [ProgramBuilder], which contains all
+            # required information for compiling and executing the CUDA program.
+            def self.translate_command(command)
+                command_translator = self.new(root_command: command)
+                command_translator.start_translation
+                return command_translator.program_builder
+            end
+
+            attr_reader :environment_builder
+            attr_reader :kernel_launcher_stack
+            attr_reader :program_builder
+            attr_reader :object_tracer
+            attr_reader :root_command
+
+            def initialize(root_command:)
+                @kernel_launcher_stack = []
+                @environment_builder = EnvironmentBuilder.new
+
+                # Select correct program builder based on command type
+                @program_builder = ProgramBuilder.new(
+                    environment_builder: environment_builder, 
+                    root_command: root_command)
+
+                @root_command = root_command
+            end
+
+            def start_translation
+                Log.info("CommandTranslator: Starting translation...")
+
+                # Trace all objects
+                @object_tracer = TypeInference::ObjectTracer.new(root_command)
+                all_objects = object_tracer.trace_all
+
+
+                # --- Translate ---
+
+                # Create new kernel launcher
+                push_kernel_launcher
+
+                # Translate the command (might create additional kernels)
+                result = root_command.accept(self)
+
+                # Add kernel builder to ProgramBuilder
+                pop_kernel_launcher(result)
+
+                # --- End of Translation ---
+
+
+                # Add SoA arrays to environment
+                object_tracer.register_soa_arrays(environment_builder)
+            end
+
+            def kernel_launcher
+                return kernel_launcher_stack.last
+            end
+
+            def kernel_builder
+                return kernel_launcher_stack.last.kernel_builder
+            end
+
+
+            # --- Actual Visitor parts stars here ---
+
+            def visit_array_command(command)
+                if command.keep && !command.has_previous_result?
+                    # Create slot for result pointer on GPU in env
+                    environment_builder.allocate_previous_pointer(command.unique_id)
+                end
+            end
+
+            def push_kernel_launcher(kernel_builder: nil, kernel_launcher: nil)
+                if kernel_builder != nil && kernel_launcher == nil
+                    @kernel_launcher_stack.push(KernelLauncher.new(kernel_builder))
+                elsif kernel_builder == nil && kernel_launcher != nil
+                    @kernel_launcher_stack.push(kernel_launcher)
+                elsif kernel_builder == nil && kernel_launcher == nil
+                    # Default: add new kernel builder
+                    @kernel_launcher_stack.push(KernelLauncher.new(KernelBuilder.new))
+                else
+                    raise ArgumentError.new("kernel_builder and kernel_laucher given but only expected one")
+                end
+            end
+
+            # Pops a KernelBuilder from the kernel builder stack. This method is called when all
+            # blocks (parallel sections) for that kernel have been translated, i.e., the kernel
+            # is fully built.
+            def pop_kernel_launcher(command_translation_result)
+                previous_launcher = kernel_launcher_stack.pop
+
+                kernel_builder = previous_launcher.kernel_builder
+                kernel_builder.block_invocation = command_translation_result.result
+                kernel_builder.execution = command_translation_result.execution
+                kernel_builder.result_type = command_translation_result.result_type
+
+                if previous_launcher == nil
+                    raise AssertionError.new("Attempt to pop kernel launcher, but stack is empty")
+                end
+
+                program_builder.add_kernel_launcher(previous_launcher)
+
+                return previous_launcher
+            end
+
+            def translate_entire_input(command)
+                input_translated = command.input.each_with_index.map do |input, index|
+                    input.translate_input(
+                        parent_command: command,
+                        command_translator: self,
+                        # Assuming that every input consumes exactly one parameter
+                        start_eat_params_offset: index)
+                end
+
+                return EntireInputTranslationResult.new(input_translated)
+            end
+
+            # Processes a [Symbolic::Input] objects, which contains a reference to a command
+            # object and information about how elements are accessed. If elements are only
+            # accessed according to the current thread ID, this input can be fused. Otherwise,
+            # a new kernel will be built.
+            def translate_input(input)
+                previous_result = ""
+
+                if input.command.has_previous_result?
+                    # Read previously computed (cached) value
+                    Log.info("Reusing kept result for command #{input.command.unique_id}: #{input.command.gpu_result_pointer}")
+
+                    environment_builder.add_previous_result(
+                        input.command.unique_id, input.command.gpu_result_pointer)
+                    environment_builder.add_previous_result_type(
+                        input.command.unique_id, input.command.result_type)
+
+                    cell_access = ""
+                    if input.pattern == :tid
+                        cell_access = "[_tid_]"
+                    end
+
+                    kernel_launcher.configure_grid(input.command.size)
+                    previous_result = CommandTranslationResult.new(
+                        execution: "",
+                        result: "((#{input.command.result_type.to_c_type} *)(_env_->" + "prev_#{input.command.unique_id}))#{cell_access}",
+                        command: input.command)
+
+                    if input.pattern == :tid
+                        return previous_result
+                    else
+                    end
+                end
+
+                if input.pattern == :tid
+                    # Stay in current kernel                    
+                    return input.command.accept(self)
+                elsif input.pattern == :entire
+                    if !input.command.has_previous_result?
+                        # Create new kernel
+                        push_kernel_launcher
+
+                        previous_result = input.command.accept(self)
+                        previous_result_kernel_var = kernel_launcher.kernel_result_var_name
+                        
+                        pop_kernel_launcher(previous_result)
+                    else
+                        kernel_launcher.use_cached_result(
+                            input.command.unique_id, input.command.result_type) 
+                        previous_result_kernel_var = "prev_" + input.command.unique_id.to_s
+                    end
+
+                    # Add parameter for previous input to this kernel
+                    kernel_launcher.add_previous_kernel_parameter(Variable.new(
+                        name: previous_result_kernel_var,
+                        type: previous_result.result_type))
+
+                    # This is a root command for this kernel, determine grid/block dimensions
+                    kernel_launcher.configure_grid(input.command.size, block_size: input.command.block_size)
+
+                    kernel_translation = CommandTranslationResult.new(
+                        result: previous_result_kernel_var,
+                        command: input.command)
+
+                    return kernel_translation
+                else
+                    raise NotImplementedError.new("Unknown input pattern: #{input.pattern}")
+                end
+            end
+
+            def build_command_translation_result(
+                execution: "", result:, command:)
+
+                result_type = command.result_type
+                unique_id = command.unique_id
+
+                if command.keep
+                    # Store result in global array
+                    # TODO: Remove DEBUG
+                    command_result = Constants::TEMP_RESULT_IDENTIFIER + unique_id.to_s
+                    command_execution = execution + "\n        " + result_type.to_c_type + " " + command_result + " = " + result + ";"
+
+                    kernel_builder.add_cached_result(unique_id.to_s, result_type)
+                    kernel_launcher.add_cached_result(unique_id.to_s, result_type)
+                    environment_builder.add_previous_result_type(unique_id, result_type)
+                else
+                    command_result = result
+                    command_execution = execution
+                end
+
+                command_translation = CommandTranslationResult.new(
+                    execution: command_execution,
+                    result: command_result,
+                    command: command)
+            end
+        end
+    end
+end
+
+require_relative "array_combine_command"
+require_relative "array_index_command"
+require_relative "array_identity_command"
+require_relative "array_reduce_command"
+require_relative "array_stencil_command"
+require_relative "array_zip_command"
+require_relative "../host_section/array_host_section_command"
+
+require_relative "../program_builder"
+require_relative "../kernel_launcher/kernel_launcher"

data/lib/translator/cuda_errors.rb

@@ -0,0 +1,32 @@
+module Ikra
+    module Errors
+        class CudaError < Exception
+
+        end
+
+        class CudaErrorIllegalAddress < CudaError
+        
+        end
+
+        class CudaUnknownError < CudaError
+            attr_reader :error_code
+
+            def initialize(error_code)
+                @error_code = error_code
+            end
+
+            def to_s
+                "CudaUnknownError (#{error_code})"
+            end
+        end
+
+        def self.raiseCudaError(error_code)
+            case error_code
+            when 77
+                raise CudaErrorIllegalAddress.new
+            else
+                raise CudaUnknownError.new(error_code)
+            end
+        end
+    end
+end