ikra 0.0.1 → 0.0.2

data/lib/translator/host_section/ast_translator.rb

@@ -0,0 +1,14 @@
+require_relative "../ast_translator"
+
+module Ikra
+    module Translator
+        class HostSectionASTTranslator < ASTTranslator
+            attr_reader :command_translator
+
+            def initialize(command_translator:)
+                super()
+                @command_translator = command_translator
+            end
+        end
+    end
+end

data/lib/translator/host_section/parallel_section_invocation_visitor.rb

@@ -0,0 +1,20 @@
+require_relative "../../ast/nodes"
+require_relative "../../ast/visitor"
+
+module Ikra
+    module Translator
+
+        # This visitor inserts a synthetic method call whenever a parallel section should be
+        # invoked, i.e.:
+        # - The return value of the host section (must be an ArrayCommand-typed expression)
+        # - When the content of an ArrayCommand-typed expression is accessed
+        class ParallelSectionInvocationVisitor < AST::Visitor
+            def visit_return_node(node)
+                node.replace_child(
+                    node.value,
+                    AST::SendNode.new(receiver: node.value, selector: :__call__))
+            end
+        end
+
+    end
+end

data/lib/translator/host_section/program_builder.rb

@@ -0,0 +1,89 @@
+require "set"
+
+require_relative "../program_builder"
+
+module Ikra
+    module Translator
+        class CommandTranslator
+            class HostSectionProgramBuilder < ProgramBuilder
+                # A host C++ function containing the source code of the host section.
+                attr_accessor :host_section_source
+
+                # The type of the result (not an array type, just the inner type).
+                attr_accessor :result_type
+
+                # An expression that returns the final result, as an `variable_size_array_t` object
+                # pointing to an array in the host memory.
+                attr_accessor :host_result_expression
+
+                def initialize(environment_builder:, root_command:)
+                    super
+
+                    @kernel_builders = Set.new
+                end
+
+                def assert_ready_to_build
+                    if host_section_source == nil
+                        raise AssertionError.new("Not ready to build (HostSectionProgramBuilder): No host section source code defined")
+                    end
+
+                    if result_type == nil
+                        raise AssertionError.new("Not ready to build (HostSectionProgramBuilder): No result type defined")
+                    end
+
+                    if host_result_expression == nil
+                        raise AssertionError.new("Not ready to build (HostSectionProgramBuilder): No host result expression defined")
+                    end
+                end
+
+                def clear_kernel_launchers
+                    @kernel_launchers.clear
+                end
+
+                def add_kernel_launcher(launcher)
+                    super
+
+                    # Let's keep track of kernels here by ourselves
+                    @kernel_builders.merge(launcher.kernel_builders)
+                end
+
+                def all_kernel_builders
+                    return @kernel_builders
+                end
+
+                def prepare_additional_args_for_launch(command)
+                    kernel_launchers.each do |launcher|
+                        launcher.prepare_additional_args_for_launch(command)
+                    end
+                end
+
+                def build_memory_free_except_last
+                    result = ""
+
+                    for launcher in kernel_launchers[0...-1]
+                        if !launcher.reuse_memory?
+                            result = result + launcher.build_device_memory_free_in_host_section
+                        end
+                    end
+
+                    return result
+                end
+
+                # Builds the CUDA program. Returns the source code string.
+                def build_program
+                    assert_ready_to_build
+
+                    result = build_header + build_struct_types + build_header_structs + 
+                        build_array_command_struct_types + build_environment_struct + 
+                        build_kernels + host_section_source
+
+                    # Build program entry point
+                    return result + Translator.read_file(file_name: "host_section_entry_point.cpp", replacements: {
+                        "prepare_environment" => environment_builder.build_environment_variable,
+                        "host_env_var_name" => Constants::ENV_HOST_IDENTIFIER,
+                        "host_result_array" => host_result_expression})
+                end
+            end
+        end
+    end
+end

data/lib/translator/input_translator.rb

@@ -0,0 +1,226 @@
+module Ikra
+    module Symbolic
+        class Input
+            def translate_input(**kwargs)
+                raise NotImplementedError.new
+            end
+        end
+
+        class SingleInput < Input
+            def translate_input(parent_command:, command_translator:, start_eat_params_offset: 0)
+                # Translate input using visitor
+                input_command_translation_result = command_translator.translate_input(self)
+
+                parameters = [Translator::Variable.new(
+                    name: parent_command.block_parameter_names[start_eat_params_offset],
+                    type: input_command_translation_result.result_type)]
+
+                return Translator::InputTranslationResult.new(
+                    parameters: parameters,
+                    command_translation_result: input_command_translation_result)
+            end
+        end
+
+        class ReduceInput < SingleInput
+            def translate_input(parent_command:, command_translator:, start_eat_params_offset: 0)
+                # Translate input using visitor
+                input_command_translation_result = command_translator.translate_input(self)
+
+                # TODO: Fix type inference (sometimes type has to be expanded)
+                parameters = [
+                    Translator::Variable.new(
+                        name: parent_command.block_parameter_names[start_eat_params_offset],
+                        type: input_command_translation_result.result_type),
+                    Translator::Variable.new(
+                        name: parent_command.block_parameter_names[start_eat_params_offset + 1],
+                        type: input_command_translation_result.result_type)]
+
+                return Translator::InputTranslationResult.new(
+                    parameters: parameters,
+                    command_translation_result: input_command_translation_result)
+            end
+        end
+
+        class StencilArrayInput < Input
+            def translate_input(parent_command:, command_translator:, start_eat_params_offset: 0)
+                # Parameters are allocated in a constant-sized array
+
+                # Count number of parameters
+                num_parameters = parent_command.offsets.size
+
+                # Get single parameter name
+                block_param_name = parent_command.block_parameter_names[start_eat_params_offset]
+
+                # Translate input using visitor
+                input_command_translation_result = command_translator.translate_input(self)
+
+                # Take return type from previous computation
+                parameters = [Translator::Variable.new(
+                    name: block_param_name,
+                    type: input_command_translation_result.result_type.to_array_type)]
+
+
+                # Allocate and fill array of parameters
+                actual_parameter_names = (0...num_parameters).map do |param_index| 
+                    "_#{block_param_name}_#{param_index}"
+                end
+
+                param_array_init = "{ " + actual_parameter_names.join(", ") + " }"
+
+                pre_execution = Translator.read_file(file_name: "stencil_array_reconstruction.cpp", replacements: {
+                    "type" => input_command_translation_result.result_type.to_c_type,
+                    "name" => block_param_name.to_s,
+                    "initializer" => param_array_init})
+
+                # Pass multiple single values instead of array
+                override_block_parameters  = actual_parameter_names.map do |param_name|
+                    Translator::Variable.new(
+                        name: param_name,
+                        type: input_command_translation_result.result_type)
+                end
+
+                return Translator::InputTranslationResult.new(
+                    pre_execution: pre_execution,
+                    parameters: parameters,
+                    override_block_parameters: override_block_parameters,
+                    command_translation_result: input_command_translation_result)
+            end
+        end
+
+        class StencilSingleInput < Input
+            def translate_input(parent_command:, command_translator:, start_eat_params_offset: 0)
+                # Pass separate parameters
+
+                # Translate input using visitor
+                input_command_translation_result = command_translator.translate_input(self)
+
+                # Count number of parameters
+                num_parameters = parent_command.offsets.size
+
+                # Take return type from previous computation
+                parameters = []
+                for index in start_eat_params_offset...(start_eat_params_offset + num_parameters)
+                    parameters.push(Translator::Variable.new(
+                        name: parent_command.block_parameter_names[index],
+                        type: input_command_translation_result.result_type))
+                end
+
+                return Translator::InputTranslationResult.new(
+                    parameters: parameters,
+                    command_translation_result: input_command_translation_result)
+            end
+        end
+    end
+
+    module Translator
+        class InputTranslationResult
+            # Code to be executed before the actual execution of the block begins (but inside the
+            # block function)
+            attr_reader :pre_execution
+
+            # Parameter names and types of the block (for type inference)
+            attr_reader :parameters
+
+            # Change (override) parameters of the block (to actually pass different parameters).
+            # This does not affect type inference.
+            attr_reader :override_block_parameters
+
+            attr_reader :command_translation_result
+
+            def initialize(
+                pre_execution: "", 
+                parameters:, 
+                override_block_parameters: nil, 
+                command_translation_result:)
+            
+                @pre_execution = pre_execution
+                @parameters = parameters
+                @override_block_parameters = override_block_parameters
+                @command_translation_result = command_translation_result
+            end
+        end
+
+        # Instance of this class store the result of translation of multiple input commands.
+        # Instance methods can be used to access the values of the translated commands. Most
+        # methods support access by index and access by range, in which case values are 
+        # aggregated, if meaningful.
+        class EntireInputTranslationResult
+            def initialize(input_translation_results)
+                @input = input_translation_results
+            end
+
+            def block_parameters(index = 0..-1)
+                if index.is_a?(Fixnum)
+                    return @input[index].parameters
+                elsif index.is_a?(Range)
+                    return @input[index].reduce([]) do |acc, n|
+                        acc + n.parameters
+                    end
+                else
+                    raise ArgumentError.new("Expected Fixnum or Range")
+                end
+            end
+
+            def pre_execution(index = 0..-1)
+                if index.is_a?(Fixnum)
+                    return @input[index].pre_execution
+                elsif index.is_a?(Range)
+                    return @input[index].reduce("") do |acc, n|
+                        acc + "\n" + n.pre_execution
+                    end
+                else
+                    raise ArgumentError.new("Expected Fixnum or Range")
+                end
+            end
+
+            def override_block_parameters(index = 0..-1)
+                if index.is_a?(Fixnum)
+                    if @input[index].override_block_parameters == nil
+                        # No override specified
+                        return @input[index].parameters
+                    else
+                        return @input[index].override_block_parameters
+                    end
+                elsif index.is_a?(Range)
+                    return @input[index].reduce([]) do |acc, n|
+                        if n.override_block_parameters == nil
+                            acc + n.parameters
+                        else
+                            acc + n.override_block_parameters
+                        end
+                    end
+                else
+                    raise ArgumentError.new("Expected Fixnum or Range")
+                end
+            end
+
+            def execution(index = 0..-1)
+                if index.is_a?(Fixnum)
+                     return @input[index].command_translation_result.execution
+                elsif index.is_a?(Range)
+                    return @input[index].reduce("") do |acc, n|
+                        acc + n.command_translation_result.execution
+                    end
+                else
+                    raise ArgumentError.new("Expected Fixnum or Range")
+                end
+            end
+
+            def result(index = 0..-1)
+                if index.is_a?(Fixnum)
+                     return @input[index].command_translation_result.result
+                elsif index.is_a?(Range)
+                    return @input[index].map do |n|
+                        n.command_translation_result.result
+                    end
+                else
+                    raise ArgumentError.new("Expected Fixnum or Range")
+                end
+            end
+
+            def command_translation_result(index)
+                return @input[index].command_translation_result
+            end
+        end
+    end
+end

data/lib/translator/kernel_builder.rb

@@ -0,0 +1,137 @@
+module Ikra
+    module Translator
+        class CommandTranslator
+
+            # Builds a CUDA kernel. This class is responsible for generating the kernel function
+            # itself (not the block functions/methods though).
+            #
+            # For example:
+            # __global__ void kernel(env_t *_env_, int *_result_, int *_previous_1_*, ...) { ... }
+            
+            class KernelBuilder
+                attr_accessor :kernel_name
+
+                # --- Optional fields ---
+
+                # An array of all methods that should be translated
+                attr_accessor :methods
+
+                # An array of all blocks that should be translated
+                attr_accessor :blocks
+
+                # Additional parameters that this kernel should accept (to access the result
+                # of previous kernels)
+                attr_accessor :previous_kernel_input
+
+                # --- Required fields ---
+
+                # A string returning the result of this kernel for one thread
+                attr_accessor :block_invocation
+
+                # A string containing the statements that execute the body of the kernel
+                attr_accessor :execution
+
+                # The result type of this kernel
+                attr_accessor :result_type
+
+                # Additional Parameters for certain commands that are attached to the kernel
+                attr_accessor :additional_parameters
+
+                # IDs of commands that whose results are kept on the GPU
+                attr_accessor :cached_results
+
+                def initialize
+                    @methods = []
+                    @blocks = []
+                    @previous_kernel_input = []
+                    @block_invocation = nil
+                    @num_threads = nil
+                    @additional_parameters = []
+                    @kernel_name = "kernel_" + CommandTranslator.next_unique_id.to_s
+                    @cached_results = {}
+                    @execution = ""
+                end
+                
+                # --- Prepare kernel ---
+
+                # Adds one or multiple methods (source code strings) to this builder.
+                def add_methods(*method)
+                    @methods.push(*method)
+                end
+
+                # Adds a block (source code string) to this builder.
+                def add_block(block)
+                    @blocks.push(block)
+                end
+
+                def add_previous_kernel_parameter(parameter)
+                    @previous_kernel_input.push(parameter)
+                end
+
+                # Add additional parameters to the kernel function that might be needed for some computations
+                def add_additional_parameters(parameter)
+                    @additional_parameters.push(parameter)
+                end
+
+                # Adds a result that has to be kept on GPU. Therefore additional memory allocations will be made
+                def add_cached_result(result_id, type)
+                    @cached_results[result_id] = type
+                end
+
+                def assert_ready_to_build
+                    required_values = [:block_invocation, :result_type]
+
+                    for selector in required_values
+                        if send(selector) == nil
+                            raise AssertionError.new(
+                                "Not ready to build (KernelBuilder): #{selector} is not set")
+                        end
+                    end
+                end
+
+
+                # --- Constructor source code ---
+
+                def build_methods
+                    return @methods.join("\n\n")
+                end
+
+                def build_blocks
+                    return @blocks.join("\n\n")
+                end
+
+                def build_kernel
+                    Log.info("Building kernel (num_blocks=#{@blocks.size})")
+                    assert_ready_to_build
+
+                    # Build parameters
+                    p_env = Constants::ENV_TYPE + " *" + Constants::ENV_IDENTIFIER
+                    p_num_threads = Constants::NUM_THREADS_TYPE + " " + Constants::NUM_THREADS_IDENTIFIER
+                    p_result = result_type.to_c_type + " *" + Constants::RESULT_IDENTIFIER
+                    p_cached_results = cached_results.map do |result_id, type|
+                        type.to_c_type + " *" + Constants::RESULT_IDENTIFIER + result_id
+                    end
+
+                    cached_results.each do |result_id, type|
+                        @execution = execution + "\n" + "        " + Constants::RESULT_IDENTIFIER + result_id + "[_tid_] = " + Constants::TEMP_RESULT_IDENTIFIER + result_id + ";"
+                    end
+
+                    previous_kernel_params = []
+                    for var in previous_kernel_input
+                        previous_kernel_params.push(var.type.to_c_type + " *" + var.name.to_s)
+                    end
+
+                    parameters = ([p_env, p_num_threads, p_result] + p_cached_results + previous_kernel_params + additional_parameters).join(", ")
+
+                    # Build kernel
+                    return Translator.read_file(file_name: "kernel.cpp", replacements: {
+                        "block_invocation" => block_invocation,
+                        "execution" => execution,
+                        "kernel_name" => kernel_name,
+                        "parameters" => parameters,
+                        "num_threads" => Constants::NUM_THREADS_IDENTIFIER})
+                end
+            end
+        end
+    end
+end