ikra 0.0.1 → 0.0.2

data/lib/translator/kernel_launcher/for_loop_kernel_launcher.rb

@@ -0,0 +1,40 @@
+module Ikra
+    module Translator
+        class CommandTranslator
+            class ForLoopKernelLauncher < KernelLauncher
+                def initialize(
+                    kernel_builder:, 
+                    from_expr: "0", 
+                    to_expr:, 
+                    var_name: "i", 
+                    before_loop: "")
+
+                    super(kernel_builder)
+                    @from_expr = from_expr
+                    @to_expr = to_expr
+                    @var_name = var_name
+                    @before_loop = before_loop
+                end
+
+                attr_reader :from_expr
+                attr_reader :to_expr
+                attr_reader :var_name
+                attr_reader :before_loop
+
+                def build_kernel_launcher
+                    Log.info("Building for-loop kernel launcher")
+
+                    assert_ready_to_build
+
+                    result = before_loop + "\n"
+                    result = result + "for (int #{var_name} = #{from_expr}; #{var_name}  < #{to_expr}; #{var_name} ++)\n{"
+
+                    result = result + super
+                    result = result + "\n}\n"
+
+                    return result
+                end
+            end
+        end
+    end
+end

data/lib/translator/kernel_launcher/kernel_launcher.rb

@@ -0,0 +1,259 @@
+module Ikra
+    module Translator
+        class CommandTranslator
+
+            # Builds the launch of the kernel. This class is responsible for generating the 
+            # invocation of the kernel.
+            #
+            # For example:
+            # kernel<<<..., ...>>>(env, result, d_a, ...);
+            class KernelLauncher
+                class << self
+                    # Debug flag only: Frees all input after launching kernel. This causes an
+                    # error if data is used twice or kept (using the `keep` flag)
+                    attr_accessor :debug_free_previous_input_immediately
+                end
+
+                attr_accessor :kernel_builder
+
+                # Additional parameters that this kernel should accept (to access the result
+                # of previous kernels)
+                attr_accessor :previous_kernel_input
+
+                # Additional parameters that this kernel should accept (to access the result
+                # of previous kernels)
+                attr_accessor :additional_arguments
+
+                # Number of threads (elements to be processed)
+                attr_accessor :num_threads
+
+                # Block/grid dimensions (should be 1D)
+                attr_accessor :grid_dim
+                attr_accessor :block_dim
+
+                # Whether the launch allocates new memory beforehand or uses previous memory
+                attr_accessor :reuse_memory
+
+                # Pointer to the resulting array (device memory)
+                attr_reader :kernel_result_var_name
+
+                # IDs and types of commands whose results are kept on the GPU
+                attr_accessor :cached_results
+
+                # IDs and types of commands that were previously computed and shall now be used in this kernel as input
+                attr_reader :previously_cached_results
+
+                def initialize(kernel_builder)
+                    @kernel_builder = kernel_builder
+                    @additional_arguments = []
+                    @previous_kernel_input = []
+                    @reuse_memory = false
+                    @kernel_result_var_name = "_kernel_result_" + CommandTranslator.next_unique_id.to_s
+                    @cached_results = {}
+                    @previously_cached_results = {}
+                end
+
+                # Some of the values stored in `@additional_arguments` might be blocks, because
+                # not all information was known when adding something to that list. This method
+                # replaces those blocks (evaluates them) with actual strings, based on the command
+                # that is being launched.
+                def prepare_additional_args_for_launch(command)
+                    @additional_arguments = @additional_arguments.map do |arg|
+                        if arg.is_a?(String)
+                            arg
+                        else
+                            arg.call(command)
+                        end
+                    end
+                end
+
+                def kernel_builders
+                    # The program builder accesses kernel builders via kernel launchers through
+                    # this method, because some specialized launchers might have multiple kernel 
+                    # builders.
+                    return [kernel_builder]
+                end
+
+                # Adds command whose result will be kept on GPU
+                def add_cached_result(result_id, type)
+                    @cached_results[result_id] = type
+                end
+
+                # Adds a previously computed result which will be used in this launche as input
+                def use_cached_result(result_id, type)
+                    @previously_cached_results[result_id] = type
+                end
+
+                def reuse_memory!(parameter_name)
+                    @reuse_memory = true
+                    @kernel_result_var_name = parameter_name
+                end
+
+                def reuse_memory?
+                    return @reuse_memory
+                end
+
+                def add_previous_kernel_parameter(parameter)
+                    kernel_builder.add_previous_kernel_parameter(parameter)
+                end
+
+                # Add additional arguments to the kernel function that might be needed for some computations
+                def add_additional_arguments(*arguments)
+                    @additional_arguments.push(*arguments)
+                end
+
+                # The result type of this kernel launcher. Same as the result type of its kernel 
+                # builder.
+                def result_type
+                    return kernel_builder.result_type
+                end
+
+                # The size of the result array is the number of threads.
+                def result_size
+                    return num_threads
+                end
+
+                # Configures grid size and block size. Also sets number of threads.
+                def configure_grid(size, block_size: 256)
+                    if block_size == nil
+                        block_size = 256
+                    end
+                    
+                    if size.is_a?(Fixnum)
+                        # Precompute constants
+                        @grid_dim = [size.fdiv(block_size).ceil, 1].max.to_s
+                        @block_dim = (size >= block_size ? block_size : size).to_s
+                        @num_threads = size
+                    else
+                        if !size.is_a?(String)
+                            raise AssertionError.new("Fixnum or String expected")
+                        end
+
+                        # Source code string determines the size
+                        @grid_dim = "max((int) ceil(((float) #{size}) / #{block_size}), 1)"
+                        @block_dim = "(#{size} >= #{block_size} ? #{block_size} : #{size})"
+                        @num_threads = size
+                    end
+                end
+
+                def assert_ready_to_build
+                    required_values = [:num_threads, :grid_dim, :block_dim]
+
+                    for selector in required_values
+                        if send(selector) == nil
+                            raise AssertionError.new(
+                                "Not ready to build (KernelBuilder): #{selector} is not set")
+                        end
+                    end
+                end
+
+
+                # Build the code that launches this kernel. The generated code performs the
+                # following steps:
+                #
+                # 1. Allocate device memory for the result.
+                # 2. If result should be written back: Allocate host memory for the result.
+                # 3. Launch the kernel (+ error checking, synchronization)
+                # 4. If result should be written back: Copy result back to host memory.
+                def build_kernel_launcher
+                    
+                    Log.info("Building kernel launcher")
+
+                    assert_ready_to_build
+
+                    result = ""
+                    if !reuse_memory
+                        # Allocate device memory for kernel result
+                        result = result + Translator.read_file(file_name: "allocate_device_memory.cpp", replacements: {
+                            "name" => kernel_result_var_name,
+                            "bytes" => "(sizeof(#{kernel_builder.result_type.to_c_type}) * #{num_threads})",
+                            "type" => kernel_builder.result_type.to_c_type})
+                    end
+
+                    previously_cached_results.each do |result_id, type|
+                        result = result + "    #{type.to_c_type} *prev_" + result_id.to_s + " = (#{type.to_c_type} *) " + Constants::ENV_HOST_IDENTIFIER + "->prev_" + result_id.to_s + ";\n"
+                    end 
+
+                    # Allocate device memory for cached results
+                    cached_results.each do |result_id, type|
+                        result = result + Translator.read_file(file_name: "allocate_device_memory.cpp", replacements: {
+                            "name" => Constants::RESULT_IDENTIFIER + result_id,
+                            "bytes" => "(#{type.c_size} * #{num_threads})",
+                            "type" => type.to_c_type})
+                    end
+
+                    # Build arguments
+                    a_env = Constants::ENV_DEVICE_IDENTIFIER
+                    a_result = kernel_result_var_name
+
+                    previous_kernel_args = []
+                    for var in kernel_builder.previous_kernel_input
+                        previous_kernel_args.push(var.name.to_s)
+                    end
+
+                    a_cached_results = cached_results.map do |result_id, type|
+                        Constants::RESULT_IDENTIFIER + result_id
+                    end
+
+                    if reuse_memory
+                        previous_kernel_args[0] = a_result
+                    end
+
+                    arguments = ([a_env, num_threads, a_result] + a_cached_results + previous_kernel_args + additional_arguments).join(", ")
+
+                    # Launch kernel
+                    result = result + Translator.read_file(file_name: "launch_kernel.cpp", replacements: {
+                        "kernel_name" => kernel_builder.kernel_name,
+                        "arguments" => arguments,
+                        "grid_dim" => grid_dim,
+                        "block_dim" => block_dim})
+
+                    # ---- DEBUG ONLY: Free input after computation so that we can process larger
+                    #                  data sets in benchmarks without running out of memory
+                    # TODO: Implement analysis and do this automatically
+                    if KernelLauncher.debug_free_previous_input_immediately == true
+                        for var in kernel_builder.previous_kernel_input
+                            result = result + Translator.read_file(file_name: "free_device_memory.cpp", replacements: {
+                                "name" => var.name.to_s})
+                        end 
+                    end
+                    # ---- END DEBUG ONLY
+
+                    cached_results.each do |result_id, type|
+                        result = result + "    " + Constants::ENV_HOST_IDENTIFIER + "->prev_" + result_id + " = " + Constants::RESULT_IDENTIFIER + result_id + ";\n"
+                    end
+
+                    return result
+                end
+                
+                def build_device_memory_free
+                    Log.info("Building kernel post-launch CUDA free")
+
+                    assert_ready_to_build
+
+                    if KernelLauncher.debug_free_previous_input_immediately == true
+                        Log.warn("Debug flag set... Freeing input memory immediately and some memory not at all!")
+                        return ""
+                    end
+
+                    return Translator.read_file(file_name: "free_device_memory.cpp", replacements: {
+                        "name" => kernel_result_var_name})
+                end
+
+                # Same as above, but also removes item from the list of allocated memory chunks.
+                def build_device_memory_free_in_host_section
+                    Log.info("Building kernel post-launch CUDA free (host section")
+
+                    assert_ready_to_build
+
+                    return Translator.read_file(file_name: "host_section_free_device_memory.cpp", replacements: {
+                        "name" => kernel_result_var_name})
+                end
+            end
+        end
+    end
+end
+
+require_relative "../kernel_builder"
+require_relative "for_loop_kernel_launcher"
+require_relative "while_loop_kernel_launcher"

data/lib/translator/kernel_launcher/while_loop_kernel_launcher.rb

@@ -0,0 +1,38 @@
+module Ikra
+    module Translator
+        class CommandTranslator
+            class WhileLoopKernelLauncher < KernelLauncher
+                def initialize(
+                    kernel_builder:,
+                    condition:,
+                    before_loop: "",
+                    post_iteration: "")
+
+                    super(kernel_builder)
+                    @condition = condition
+                    @before_loop = before_loop
+                    @post_iteration = post_iteration
+                end
+
+                attr_reader :condition
+                attr_reader :before_loop
+                attr_reader :post_iteration
+
+                def build_kernel_launcher
+                    Log.info("Building for-loop kernel launcher")
+
+                    assert_ready_to_build
+
+                    result = ""
+                    result = result + before_loop + "\n"
+                    result = result + "while (#{condition}) {\n"
+                    result = result + super
+                    result = result + "\n" + post_iteration
+                    result = result + "\n}\n"
+
+                    return result
+                end
+            end
+        end
+    end
+end

data/lib/translator/last_returns_visitor.rb

@@ -3,37 +3,42 @@ require_relative "../ast/visitor"
 
 module Ikra
     module Translator
+        # Visitor that replaces implicit returns with explicit ones
         class LastStatementReturnsVisitor < AST::Visitor
             def visit_root_node(node)
-                node.child.accept(self)
+                node.single_child.accept(self)
             end
 
             def visit_lvar_read_node(node)
-                node.parent.replace_child(node, AST::ReturnNode.new(value: node))
+                process_node(node)
             end
             
             def visit_lvar_write_node(node)
-                node.parent.replace_child(node, AST::ReturnNode.new(value: node))
+                process_node(node)
             end
             
             def visit_int_node(node)
-                node.parent.replace_child(node, AST::ReturnNode.new(value: node))
+                process_node(node)
             end
             
             def visit_float_node(node)
-                node.parent.replace_child(node, AST::ReturnNode.new(value: node))
+                process_node(node)
             end
             
             def visit_bool_node(node)
-                node.parent.replace_child(node, AST::ReturnNode.new(value: node))
+                process_node(node)
+            end
+            
+            def visit_nil_node(node)
+                process_node(node)
             end
             
             def visit_for_node(node)
-                raise "Cannot handle for loop as return value"
+                raise NotImplementedError.new("Cannot handle for loop as return value")
             end
             
             def visit_break_node(node)
-                raise "Break must not be a return value"
+                raise AssertionError.new("Break must not be a return value")
             end
             
             def visit_if_node(node)
@@ -46,11 +51,15 @@ module Ikra
             end
             
             def visit_send_node(node)
-                node.parent.replace_child(node, AST::ReturnNode.new(value: node))
+                process_node(node)
             end
 
             def visit_return_node(node)
-                raise "Function returns already"
+                # Do nothing
+            end
+
+            def process_node(node)
+                node.parent.replace_child(node, AST::ReturnNode.new(value: node))
             end
         end
     end

data/lib/translator/program_builder.rb

@@ -0,0 +1,197 @@
+require "tempfile"
+require "set"
+
+module Ikra
+    module Translator
+        class CommandTranslator
+
+            # Builds the entire CUDA program. A CUDA program may consist of multiple kernels, but
+            # has at least one kernel. The generated code performs the following steps:
+            #
+            # 1. Insert header of CUDA file.
+            # 2. For every kernel: Build all methods, blocks, and kernels.
+            # 3. Build the program entry point (including kernel launchers).
+            class ProgramBuilder
+                attr_reader :environment_builder
+                attr_reader :kernel_launchers
+                attr_reader :kernels
+                attr_reader :root_command
+
+                # An array of structs definitions ([Types::StructType] instances) that should be 
+                # generated for this program.
+                attr_reader :structs
+
+                # An array of array command structs.
+                attr_reader :array_command_structs
+
+                def initialize(environment_builder:, root_command:)
+                    @kernel_launchers = []
+                    @kernels = Set.new([])
+                    @environment_builder = environment_builder
+                    @root_command = root_command
+
+                    # The collection of structs is a [Set]. Struct types are unique, i.e., there
+                    # are never two equal struct types with different object identity.  
+                    @structs = Set.new
+                    @array_command_structs = Set.new
+                end
+
+                def add_array_command_struct(*structs)
+                    for struct in structs
+                        array_command_structs.add(struct)
+                    end
+                end
+
+                def add_kernel_launcher(launcher)
+                    @kernel_launchers.push(launcher)
+                end
+
+                # Generates the source code for the CUDA program, compiles it with nvcc and
+                # executes the program.
+                def execute
+                    source = build_program
+
+                    launcher = Launcher.new(
+                        source: source,
+                        environment_builder: environment_builder,
+                        result_type: result_type,
+                        root_command: root_command)
+
+                    launcher.compile
+                    return launcher.execute
+                end
+
+                # Build kernel invocations
+                def build_kernel_launchers
+                    return kernel_launchers.map do |launcher|
+                        launcher.build_kernel_launcher
+                    end.join("")
+                end
+
+                protected
+
+                def assert_ready_to_build
+                    if kernel_launchers.size == 0
+                        raise AssertionError.new(
+                            "Not ready to build (ProgramBuilder): No kernel launcher defined")
+                    end
+                end
+
+                # Build header of CUDA source code file
+                def build_header
+                    return Translator.read_file(file_name: "header.cpp")
+                end
+
+                # Build environment struct definition
+                def build_environment_struct
+                    return environment_builder.build_environment_struct
+                end
+
+                # Generate all struct types (except for array command struct types).
+                def build_struct_types
+                    return structs.map do |struct_type|
+                            struct_type.generate_definition
+                        end.join("\n") + "\n"
+                end
+
+                def build_array_command_struct_types
+                    return array_command_structs.to_a.join("\n") + "\n"
+                end
+
+                def all_kernel_builders
+                    return kernel_launchers.map do |launcher|
+                        launcher.kernel_builders
+                    end.flatten
+                end
+
+                # Build methods, blocks and kernels
+                def build_kernels
+                    result = ""
+
+                    for builder in all_kernel_builders
+                        # Check whether kernel was already build before
+                        if kernels.include?(builder)
+                            next
+                        else
+                            kernels.add(builder)
+                        end
+
+                        result = result + builder.build_methods
+                        result = result + builder.build_blocks
+                        result = result + builder.build_kernel
+                    end
+
+                    return result
+                end
+
+                def host_result_expression
+                    # Read some fields from last kernel launch configuration
+                    result_device_ptr = kernel_launchers.last.kernel_result_var_name
+                    result_c_type = kernel_launchers.last.result_type.to_c_type
+                    result_size = root_command.size
+
+                    if result_device_ptr == nil
+                        raise AssertionError.new(
+                            "Result variable name of final kernel launcher not set")
+                    end
+
+                    # Build result values: `variable_size_array_t` struct. This struct contains a
+                    # pointer to the result array and stores the size of the result.
+                    result_device_variable_array_t = "variable_size_array_t((void *) #{result_device_ptr}, #{result_size})"
+
+                    return Translator.read_file(file_name: "memcpy_device_to_host_expr.cpp", replacements: {
+                        "type" => result_c_type,
+                        "device_array" => result_device_variable_array_t})
+                end
+
+                # Returns the result type of this program. The result type must always be a
+                # union type that includes a [Types::LocationAwareArrayType] object, 
+                # because this way we can support return types where the inner type of an array
+                # is unknown at compile time.
+                def result_type
+                    return Types::LocationAwareVariableSizeArrayType.new(
+                        kernel_launchers.last.result_type,
+                        location: :host).to_union_type
+                end
+
+                # Free device memory
+                def build_memory_free
+                    result = ""
+
+                    for launcher in kernel_launchers
+                        if !launcher.reuse_memory?
+                            result = result + launcher.build_device_memory_free
+                        end
+                    end
+
+                    return result
+                end
+
+                # Build the struct type for `result_t`.
+                def build_header_structs
+                    header_structs = Translator.read_file(file_name: "header_structs.cpp",
+                        replacements: {"result_type" => result_type.to_c_type})
+                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
+
+                    # Build program entry point
+                    return result + Translator.read_file(file_name: "entry_point.cpp", replacements: {
+                        "prepare_environment" => environment_builder.build_environment_variable,
+                        "launch_all_kernels" => build_kernel_launchers,
+                        "free_device_memory" => build_memory_free,
+                        "host_env_var_name" => Constants::ENV_HOST_IDENTIFIER,
+                        "host_result_array" => host_result_expression})
+                end
+            end
+        end
+    end
+end
+
+require_relative "program_launcher"