ikra 0.0.1 → 0.0.2

data/lib/translator/block_translator.rb

@@ -1,12 +1,9 @@
 require_relative "../ast/nodes.rb"
 require_relative "../ast/builder.rb"
-require_relative "../ast/translator.rb"
-require_relative "../types/type_inference"
-require_relative "../types/primitive_type"
+require_relative "../types/types"
 require_relative "../parsing"
-require_relative "../scope"
 require_relative "../ast/printer"
-require_relative "../ast/method_definition"
+require_relative "variable_classifier_visitor"
 
 module Ikra
     module Translator
@@ -20,10 +17,11 @@ module Ikra
             # @return [UnionType] Return value type of method/block
             attr_accessor :result_type
 
-            # @return [String] Name of function in CUDA source code
+            # @return [String] Name of function of block in CUDA source code
             attr_accessor :function_name
 
-            # @return [Array<Ikra::AST::MethodDefinition>] Auxiliary methods that are called by this block (including transitive method calls)
+            # @return [String] Auxiliary methods that are called by this block 
+            # (including transitive method calls)
             attr_accessor :aux_methods
 
             def initialize(c_source:, result_type:, function_name:, aux_methods: [])
@@ -32,87 +30,145 @@ module Ikra
                 @function_name = function_name
                 @aux_methods = aux_methods
             end
-
-            def generated_source
-                @aux_methods.map do |meth|
-                    meth.to_c_source
-                end.join("\n\n") + @block_source
-            end
         end
 
         BlockSelectorDummy = :"<BLOCK>"
 
         class << self
             # Translates a Ruby block to CUDA source code.
-            # @param [AST::Node] ast abstract syntax tree of the block
-            # @param [EnvironmentBuilder] environment_builder environment builder instance collecting information about lexical variables (environment)
-            # @param [Hash{Symbol => UnionType}] block_parameter_types types of arguments passed to the block
-            # @param [Hash{Symbol => Object}] lexical_variables all lexical variables that are accessed within the block
+            # @param [AST::BlockDefNode] block_def_node AST (abstract syntax tree) of the block
+            # @param [EnvironmentBuilder] environment_builder environment builder instance 
+            # collecting information about lexical variables (environment)
+            # @param [Array{Variable}] block_parameters types and names of parameters 
+            # to the block
+            # @param [Hash{Symbol => Object}] lexical_variables all lexical variables that are 
+            # accessed within the block
             # @param [Fixnum] command_id a unique identifier of the block
+            # @param [String] pre_execution source code that should be run before executing the
+            # block
+            # @param [Array{Variable}] override_block_parameters overrides the the declaration of
+            # parameters that this block accepts.
+            # @param [EntireInputTranslationResult] entire_input_translation The result of 
+            # `translate_entire_input`
             # @return [BlockTranslationResult]
-            def translate_block(ast:, environment_builder:, command_id:, block_parameter_types: {}, lexical_variables: {})
+            def translate_block(
+                block_def_node:, 
+                environment_builder:, 
+                command_id:, 
+                lexical_variables: {}, 
+
+                # One one of the two following parameter configurations is valid:
+                # a) Either this parameter is given:
+                entire_input_translation: nil,
+
+                # b) or these parameters are given (some are optional):
+                pre_execution: nil, 
+                override_block_parameters: nil,
+                block_parameters: nil)
+
+                # Check and prepare arguments
+                if pre_execution != nil and entire_input_translation != nil
+                    raise ArgumentError.new("pre_execution and entire_input_translation given")
+                elsif entire_input_translation != nil
+                    pre_execution = entire_input_translation.pre_execution
+                elsif pre_execution == nil
+                    pre_execution = ""
+                end
+
+                if block_parameters != nil and entire_input_translation != nil
+                    raise ArgumentError.new("block_parameters and entire_input_translation given")
+                elsif entire_input_translation != nil
+                    block_parameters = entire_input_translation.block_parameters
+                elsif block_parameters == nil
+                    block_parameters = []
+                end
+
+                if override_block_parameters != nil and entire_input_translation != nil
+                    raise ArgumentError.new("override_block_parameters and entire_input_translation given")
+                elsif entire_input_translation != nil
+                    override_block_parameters = entire_input_translation.override_block_parameters
+                elsif override_block_parameters == nil
+                    override_block_parameters = block_parameters
+                end
+
+
+                # Build hash of parameter name -> type mappings
+                block_parameter_types = {}
+                for variable in block_parameters
+                    block_parameter_types[variable.name] = variable.type
+                end
+
                 parameter_types_string = "[" + block_parameter_types.map do |id, type| "#{id}: #{type}" end.join(", ") + "]"
                 Log.info("Translating block with input types #{parameter_types_string}")
 
-                # Define MethodDefinition for block
-                block_def = AST::MethodDefinition.new(
-                    type: Types::UnionType.new,        # TODO: what to pass in here?
-                    selector: BlockSelectorDummy,
-                    parameter_variables: block_parameter_types,
-                    return_type: Types::UnionType.new,
-                    ast: ast)
+                # Add information to block_def_node
+                block_def_node.parameters_names_and_types = block_parameter_types
 
                 # Lexical variables
                 lexical_variables.each do |name, value|
-                    block_def.lexical_variables[name] = Types::UnionType.new(value.class.to_ikra_type)
+                    block_def_node.lexical_variables_names_and_types[name] = value.ikra_type.to_union_type
                 end
 
                 # Type inference
                 type_inference_visitor = TypeInference::Visitor.new
-                return_type = type_inference_visitor.process_method(block_def)
-                # The following method returns nested dictionaries, but we only need the values
-                aux_methods = type_inference_visitor.methods.values.map do |hash|
-                    hash.values
-                end.flatten
+                return_type = type_inference_visitor.process_block(block_def_node)
+                
+                # Translation to source code
+                ast_translator = ASTTranslator.new
+
+                # Auxiliary methods are instance methods that are called by the block
+                aux_methods = type_inference_visitor.all_methods.map do |method|
+                    ast_translator.translate_method(method)
+                end
+
+                # Generate method predeclarations
+                aux_methods_predecl = type_inference_visitor.all_methods.map do |method|
+                    ast_translator.translate_method_predecl(method)
+                end
+
+                # Start with predeclarations
+                aux_methods = aux_methods_predecl + aux_methods
+
+                # Classify variables (lexical or local)
+                block_def_node.accept(VariableClassifier.new(
+                    lexical_variable_names: lexical_variables.keys))
 
                 # Translate to CUDA/C++ code
-                translation_result = ast.translate_statement
+                translation_result = ast_translator.translate_block(block_def_node)
 
                 # Load environment variables
                 lexical_variables.each do |name, value|
-                    type = value.class.to_ikra_type
+                    type = value.ikra_type
                     mangled_name = environment_builder.add_object(name, value)
-                    translation_result.prepend("#{type.to_c_type} #{name} = #{Constants::ENV_IDENTIFIER}->#{mangled_name};\n")
+                    translation_result.prepend("#{type.to_c_type} #{Constants::LEXICAL_VAR_PREFIX}#{name} = #{Constants::ENV_IDENTIFIER}->#{mangled_name};\n")
                 end
 
                 # Declare local variables
-                block_def.local_variables.each do |name, types|
-                    translation_result.prepend("#{types.singleton_type.to_c_type} #{name};\n")
+                block_def_node.local_variables_names_and_types.each do |name, type|
+                    translation_result.prepend("#{type.to_c_type} #{name};\n")
                 end
 
                 # Function signature
                 mangled_name = "_block_k_#{command_id}_"
 
-                if not return_type.is_singleton?
-                    raise "Cannot handle polymorphic return types yet"
-                end
-
                 function_parameters = ["environment_t *#{Constants::ENV_IDENTIFIER}"]
-                block_parameter_types.each do |param|
-                    function_parameters.push("#{param[1].to_c_type} #{param[0].to_s}")
+
+                parameter_decls = override_block_parameters.map do |variable|
+                    "#{variable.type.to_c_type} #{variable.name}"
                 end
 
-                function_head = Translator.read_file(
+                function_parameters.push(*parameter_decls)
+
+                translation_result = Translator.read_file(
                     file_name: "block_function_head.cpp",
                     replacements: { 
                         "name" => mangled_name, 
-                        "return_type" => return_type.singleton_type.to_c_type,
-                        "parameters" => function_parameters.join(", ")})
-
-                translation_result = function_head + wrap_in_c_block(translation_result)
+                        "result_type" => return_type.to_c_type,
+                        "parameters" => function_parameters.join(", "),
+                        "body" => wrap_in_c_block(pre_execution + "\n" + translation_result)})
 
                 # TODO: handle more than one result type
-                BlockTranslationResult.new(
+                return BlockTranslationResult.new(
                     c_source: translation_result, 
                     result_type: return_type,
                     function_name: mangled_name,

data/lib/translator/commands/array_combine_command.rb

@@ -0,0 +1,41 @@
+module Ikra
+    module Translator
+        class CommandTranslator < Symbolic::Visitor
+            def visit_array_combine_command(command)
+                Log.info("Translating ArrayCombineCommand [#{command.unique_id}]")
+
+                super
+
+                # Process dependent computation (receiver), returns [InputTranslationResult]
+                input = translate_entire_input(command)
+
+                # 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)
+
+                # Build command invocation string
+                result = block_translation_result.function_name + "(" + 
+                    (["_env_"] + input.result).join(", ") + ")"
+
+                command_translation = build_command_translation_result(
+                    execution: input.execution,
+                    result: result,
+                    command: command)
+
+                Log.info("DONE translating ArrayCombineCommand [#{command.unique_id}]")
+
+                return command_translation
+            end
+        end
+    end
+end

data/lib/translator/commands/array_identity_command.rb

@@ -0,0 +1,28 @@
+module Ikra
+    module Translator
+        class CommandTranslator < Symbolic::Visitor
+            def visit_array_identity_command(command)
+                Log.info("Translating ArrayIdentityCommand [#{command.unique_id}]")
+
+                super
+
+                # This is a root command, determine grid/block dimensions
+                kernel_launcher.configure_grid(command.size, block_size: command.block_size)
+
+                # Add base array to environment
+                need_union_type = !command.base_type.is_singleton?
+                transformed_base_array = object_tracer.convert_base_array(
+                    command.input.first.command, need_union_type)
+                environment_builder.add_base_array(command.unique_id, transformed_base_array)
+
+                command_translation = build_command_translation_result(
+                    result: "#{Constants::ENV_IDENTIFIER}->#{EnvironmentBuilder.base_identifier(command.unique_id)}[_tid_]",
+                    command: command)
+
+                Log.info("DONE translating ArrayIdentityCommand [#{command.unique_id}]")
+
+                return command_translation
+            end
+        end
+    end
+end

data/lib/translator/commands/array_index_command.rb

@@ -0,0 +1,52 @@
+module Ikra
+    module Translator
+        class CommandTranslator < Symbolic::Visitor
+            # Translate the block of an `Array.pnew` section.
+            def visit_array_index_command(command)
+                Log.info("Translating ArrayIndexCommand [#{command.unique_id}]")
+
+                super
+
+                # This is a root command, determine grid/block dimensions
+                kernel_launcher.configure_grid(command.size, block_size: command.block_size)
+
+                num_dims = command.dimensions.size
+
+                # This is a root command, determine grid/block dimensions
+                kernel_launcher.configure_grid(command.size, block_size: command.block_size)
+
+                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
+
+                if num_dims > 1
+                    # Retrieve type that was generated earlier
+                    zipped_type_singleton = command.result_type.singleton_type
+                    result = zipped_type_singleton.generate_inline_initialization(index_generators)
+
+                    # Add struct type to program builder, so that we can generate the source code
+                    # for its definition.
+                    program_builder.structs.add(zipped_type_singleton)
+                else
+                    result = "_tid_"
+                end
+
+                command_translation = CommandTranslationResult.new(
+                    result: result,
+                    command: command)
+
+                Log.info("DONE translating ArrayIndexCommand [#{command.unique_id}]")
+
+                return command_translation
+            end
+        end
+    end
+end

data/lib/translator/commands/array_reduce_command.rb

@@ -0,0 +1,135 @@
+module Ikra
+    module Translator
+        class CommandTranslator < Symbolic::Visitor
+            def visit_array_reduce_command(command)
+                Log.info("Translating ArrayReduceCommand [#{command.unique_id}]")
+
+                super
+
+                if command.input.size != 1
+                    raise AssertionError.new("Expected exactly one input for ArrayReduceCommand")
+                end
+
+                # Process dependent computation (receiver)
+                input = translate_entire_input(command)
+
+                block_size = command.block_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)
+
+                # Add "odd" parameter to the kernel which is needed for reduction
+                kernel_builder.add_additional_parameters(Constants::ODD_TYPE + " " + Constants::ODD_IDENTIFIER)
+
+                # Number of elements that will be reduced
+                num_threads = command.input_size
+
+                if num_threads.is_a?(Fixnum)
+                    # Easy case: Number of required reductions known statically
+
+                    odd = (num_threads % 2 == 1).to_s
+
+                    # Number of threads needed for reduction
+                    num_threads = num_threads.fdiv(2).ceil
+
+                    previous_result_kernel_var = input.result.first
+                    first_launch = true
+                    
+                    # While more kernel launches than one are needed to finish reduction
+                    while num_threads >= block_size + 1
+                        # Launch new kernel (with same kernel builder)
+                        push_kernel_launcher(kernel_builder: kernel_builder)
+                        # Configure kernel with correct arguments and grid
+                        kernel_launcher.add_additional_arguments(odd)
+                        kernel_launcher.configure_grid(num_threads, block_size: block_size)
+                        
+                        # First launch of kernel is supposed to allocate new memory, so only reuse memory after first launch 
+                        if first_launch
+                            first_launch = false
+                        else
+                            kernel_launcher.reuse_memory!(previous_result_kernel_var)
+                        end
+
+                        previous_result_kernel_var = kernel_launcher.kernel_result_var_name
+
+                        pop_kernel_launcher(input.command_translation_result(0))
+
+                        # Update number of threads needed
+                        num_threads = num_threads.fdiv(block_size).ceil
+                        odd = (num_threads % 2 == 1).to_s
+                        num_threads = num_threads.fdiv(2).ceil
+                    end
+
+                    # Configuration for last launch of kernel
+                    kernel_launcher.add_additional_arguments(odd)
+                    kernel_launcher.configure_grid(num_threads, block_size: block_size)
+                else
+                    # More difficult case: Have to generate loop for reductions
+
+                    # Add one regular kernel launcher for setting up the memory etc.
+                    odd_first = "(#{num_threads} % 2 == 1)"
+                    num_threads_first = "((int) ceil(#{num_threads} / 2.0))"
+                    push_kernel_launcher(kernel_builder: kernel_builder)
+                    kernel_launcher.add_additional_arguments(odd_first)
+                    kernel_launcher.configure_grid(num_threads_first, block_size: block_size)
+                    previous_result_kernel_var = kernel_launcher.kernel_result_var_name
+                    pop_kernel_launcher(input.command_translation_result(0))
+
+                    # Add loop
+                    # Set up state (variables that are updated inside the loop)
+                    # 1. Calculate number of elements from previous computation
+                    # 2. Check if odd number
+                    # 3. Calculate number of threads that we need
+                    loop_setup = "int _num_elements = ceil(#{num_threads_first} / (double) #{block_size});\nbool _next_odd = _num_elements % 2 == 1;\nint _next_threads = ceil(_num_elements / 2.0);\n"
+
+                    # Update loop state after iteration
+                    update_loop = "_num_elements = ceil(_next_threads / (double) #{block_size});\nbool _next_odd = _num_elements % 2 == 0;\n_next_threads = ceil(_num_elements / 2.0);\n"
+
+                    push_kernel_launcher(kernel_launcher: WhileLoopKernelLauncher.new(
+                        kernel_builder: kernel_builder,
+                        condition: "_num_elements > 1",
+                        before_loop: loop_setup,
+                        post_iteration: update_loop))
+
+                    kernel_launcher.add_additional_arguments("_next_odd")
+                    kernel_launcher.configure_grid("_next_threads", block_size: block_size)
+                    #pop_kernel_launcher(input.command_translation_result(0))
+                end
+
+                if !first_launch
+                    kernel_launcher.reuse_memory!(previous_result_kernel_var)
+                end
+
+                command_execution = Translator.read_file(file_name: "reduce_body.cpp", replacements: {
+                    "previous_result" => input.result.first,
+                    "block_name" => block_translation_result.function_name,
+                    "arguments" => Constants::ENV_IDENTIFIER,
+                    "block_size" => block_size.to_s,
+                    "temp_result" => Constants::TEMP_RESULT_IDENTIFIER,
+                    "odd" => Constants::ODD_IDENTIFIER,
+                    "type" => command.result_type.to_c_type,
+                    "num_threads" => Constants::NUM_THREADS_IDENTIFIER})
+
+                command_translation = CommandTranslationResult.new(
+                    execution: command_execution,
+                    result:  Constants::TEMP_RESULT_IDENTIFIER,
+                    command: command)
+
+                Log.info("DONE translating ArrayReduceCommand [#{command.unique_id}]")
+
+                return command_translation
+            end
+        end
+    end
+end