ikra 0.0.1 → 0.0.2

data/lib/translator/environment_builder.rb

@@ -0,0 +1,263 @@
+module Ikra
+    module Translator
+
+        # Interface for transferring data to the CUDA side using FFI. Builds a struct containing all required objects (including lexical variables). Traces objects.
+        class EnvironmentBuilder
+
+            class UnionTypeStruct < FFI::Struct
+                layout :class_id, :int32, :object_id, :int32
+            end
+
+            attr_accessor :objects
+
+            attr_accessor :device_struct_allocation
+            attr_accessor :ffi_struct
+
+            def initialize
+                @objects = {}
+                @previous_results = {}
+                @previous_results_types = {}
+                @device_struct_allocation = ""
+                @ffi_struct = {}
+            end
+
+            # Hash that maps the unique_id of a command on the adress of its result on the GPU.
+            # Returns a sorted version of the hash. 
+            def previous_results
+                return Hash[@previous_results.sort]
+            end
+
+            # Hash that maps the unique_id of a command on the type of its result.
+            # Returns a sorted version of the hash. 
+            def previous_results_types
+                return Hash[@previous_results_types.sort]
+            end
+
+            # Adds an objects as a lexical variable.
+            def add_object(command_id, identifier, object)
+                cuda_id = "l#{command_id}_#{identifier}"
+
+                if objects[cuda_id].object_id != object.object_id
+                    # Don't add the object multiple times
+                    objects[cuda_id] = object
+                    update_dev_struct_allocation(cuda_id, object)
+                end
+
+                return cuda_id
+            end
+
+            # Adds object to the ffi_struct which is of type unique_id => pointer in GPU
+            def add_previous_result(previous_command_id, pointer_to_result)
+                cuda_id = "prev_#{previous_command_id}"
+                @previous_results[cuda_id] = pointer_to_result
+                
+                update_dev_struct_allocation(cuda_id, pointer_to_result)
+
+                cuda_id
+            end
+
+            # Adds object to the ffi_struct which is of type unique_id => 0
+            def allocate_previous_pointer(previous_command_id)
+                add_previous_result(previous_command_id, 0)
+            end
+
+            # Adds object to the ffi_struct which is of type unique_id => type of command with unique_id
+            def add_previous_result_type(previous_command_id, type)
+                cuda_id = "prev_#{previous_command_id}"
+                @previous_results_types[cuda_id] = type
+
+                cuda_id
+            end
+
+            # Adds an object as a base array
+            def add_base_array(command_id, object)
+                cuda_id = "b#{command_id}_base"
+
+                if objects.include?(cuda_id)
+                    # Object already present
+
+                    if !objects[cuda_id].equal?(object)
+                        raise AssertionError.new("Adding different base array under different name")
+                    end
+
+                    return cuda_id
+                end
+
+                objects[cuda_id] = object
+
+                cuda_id_size = "b#{command_id}_size"
+                if object.class == FFI::MemoryPointer
+                    objects[cuda_id_size] = object.size / UnionTypeStruct.size
+                else
+                    objects[cuda_id_size] = object.size
+                end
+
+                # Generate code for copying data to global memory
+                update_dev_struct_allocation(cuda_id, object)
+
+                return cuda_id
+            end
+
+            # Add an array for the Structure of Arrays object layout
+            def add_soa_array(name, object)
+                objects[name] = object
+                objects["#{name}_size"] = object.size
+
+                update_dev_struct_allocation(name, object)
+            end
+
+            def update_dev_struct_allocation(field, object)
+                if object.class == Array
+                    # Allocate new array
+                    @device_struct_allocation += Translator.read_file(
+                        file_name: "env_builder_copy_array.cpp",
+                        replacements: { 
+                            "field" => field, 
+                            "host_env" => Constants::ENV_HOST_IDENTIFIER,
+                            "dev_env" => Constants::ENV_DEVICE_IDENTIFIER,
+                            "size_bytes" => (object.first.class.to_ikra_type.c_size * object.size).to_s})
+                elsif object.class == FFI::MemoryPointer
+                    # This is an array of union type structs
+                    # Allocate new array
+                    @device_struct_allocation += Translator.read_file(
+                        file_name: "env_builder_copy_array.cpp",
+                        replacements: { 
+                            "field" => field, 
+                            "host_env" => Constants::ENV_HOST_IDENTIFIER,
+                            "dev_env" => Constants::ENV_DEVICE_IDENTIFIER,
+                            "size_bytes" => object.size.to_s})   
+                else
+                    # Nothing to do, this case is handled by mem-copying the struct
+                end
+            end
+
+            # Returns the name of the field containing the base array for a certain identity command.
+            def self.base_identifier(command_id)
+                return "b#{command_id}_base"
+            end
+
+            def build_environment_variable
+                # Copy arrays to device side
+                result = @device_struct_allocation
+
+                # Allocate and copy over environment to device
+                result = result + Translator.read_file(
+                    file_name: "allocate_memcpy_environment_to_device.cpp",
+                    replacements: {
+                        "dev_env" => Constants::ENV_DEVICE_IDENTIFIER,
+                        "host_env" => Constants::ENV_HOST_IDENTIFIER})
+
+                return result
+            end
+
+            def build_environment_struct
+                @objects.freeze
+
+                struct_def = "struct environment_struct\n{\n"
+                @objects.each do |key, value|
+                    if value.class == FFI::MemoryPointer
+                        # TODO: can this be an extension method of FFI::MemoryPointer?
+                        struct_def += "    union_t * #{key};\n"
+                    else
+                        struct_def += "    #{value.ikra_type.to_c_type} #{key};\n"
+                    end
+                end
+
+                previous_results_types.each do |key, value|
+                    struct_def += "    #{value.to_c_type} *#{key};\n"
+                end
+
+                struct_def += "};\n"
+
+                return struct_def
+            end
+
+            def build_ffi_type
+                struct_layout = []
+                @objects.each do |key, value|
+                    if value.class == FFI::MemoryPointer
+                        # TODO: can this be an extension method of FFI::MemoryPointer?
+                        struct_layout += [key.to_sym, :pointer]
+                    else
+                        struct_layout += [key.to_sym, value.ikra_type.to_ffi_type]
+                    end
+                end
+
+                previous_results.each do |key, value|
+                    struct_layout += [key.to_sym, :pointer]
+                end
+
+                # Add dummy at the end of layout, because layouts cannot be empty
+                struct_layout += [:dummy, :int]
+
+                struct_type = Class.new(FFI::Struct)
+                struct_type.layout(*struct_layout)
+
+                struct_type
+            end
+
+            def build_ffi_object
+                struct_type = build_ffi_type
+                struct = struct_type.new
+
+                @objects.each do |key, value|
+                    # TODO: need proper Array handling
+                    if value.class == Array
+                        # Check first element to determine type of array
+                        # TODO: check for polymorphic
+                        inner_type = value.first.class.to_ikra_type
+                        array_ptr = FFI::MemoryPointer.new(value.size * inner_type.c_size)
+
+                        if inner_type == Types::PrimitiveType::Int
+                            array_ptr.put_array_of_int(0, value)
+                        elsif inner_type == Types::PrimitiveType::Float
+                            array_ptr.put_array_of_float(0, value)
+                        else
+                            raise NotImplementedError
+                        end
+
+                        struct[key.to_sym] = array_ptr
+                    else
+                        struct[key.to_sym] = value
+                    end
+                end
+
+                previous_results.each do |key, value|
+                    struct[key.to_sym] = value
+                end
+
+                struct[:dummy] = 0
+                
+                @ffi_struct = struct
+                
+                struct.to_ptr
+            end
+
+            def [](command_id)
+                CurriedBuilder.new(self, command_id)
+            end
+
+            class CurriedBuilder
+                def initialize(builder, command_id)
+                    @builder = builder
+                    @command_id = command_id
+                end
+
+                def add_object(identifier, object)
+                    @builder.add_object(@command_id, identifier, object)
+                end
+
+                def add_base_array(object)
+                    @builder.add_base_array(@command_id, object)
+                end
+            end
+
+            def clone
+                result = self.class.new
+                result.objects = @objects.clone
+                result.device_struct_allocation = @device_struct_allocation
+                result
+            end
+        end
+    end
+end

data/lib/translator/host_section/array_host_section_command.rb

@@ -0,0 +1,150 @@
+require_relative "parallel_section_invocation_visitor"
+require_relative "program_builder"
+require_relative "ast_translator"
+require_relative "../../ast/ssa_generator"
+
+module Ikra
+    module Translator
+        class HostSectionCommandTranslator < CommandTranslator
+            def initialize(root_command:)
+                super
+
+                # Use a different program builder
+                @program_builder = HostSectionProgramBuilder.new(
+                    environment_builder: environment_builder, 
+                    root_command: root_command)
+            end
+
+            def start_translation
+                Log.info("HostSectionCommandTranslator: Starting translation...")
+
+                # Trace all objects
+                @object_tracer = TypeInference::ObjectTracer.new(root_command)
+                all_objects = object_tracer.trace_all
+
+                # Translate the command (might create additional kernels)
+                root_command.accept(self)
+
+                # Add SoA arrays to environment
+                object_tracer.register_soa_arrays(environment_builder)
+            end
+
+            def visit_array_host_section_command(command)
+                Log.info("Translating ArrayHostSectionCommand [#{command.unique_id}]")
+
+                super
+
+                # A host section must be a top-level (root) command. It uses a special
+                # [HostSectionProgramBuilder].
+
+                block_def_node = command.block_def_node
+
+                # Cannot use the normal `translate_block` method here, this is special!
+                # TODO: There's some duplication here with [BlockTranslator]
+
+                # Build hash of parameter name -> type mappings
+                block_parameter_types = {}
+                command.block_parameter_names.each_with_index do |name, index|
+                    block_parameter_types[name] = command.section_input[index].ikra_type.to_union_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}")
+
+                # Add information to block_def_node
+                block_def_node.parameters_names_and_types = block_parameter_types
+
+                # Insert return statements (also done by type inference visitor, but we need
+                # it now)
+                block_def_node.accept(LastStatementReturnsVisitor.new)
+
+                # Insert synthetic __call__ send nodes for return values
+                block_def_node.accept(ParallelSectionInvocationVisitor.new)
+
+                # Concert to SSA form
+                AST::SSAGenerator.transform_to_ssa!(block_def_node)
+
+                # Type inference
+                type_inference_visitor = TypeInference::Visitor.new
+                result_type = type_inference_visitor.process_block(block_def_node)
+
+                for singleton_type in result_type
+                    if !singleton_type.is_a?(Types::LocationAwareArrayType)
+                        raise AssertionError.new("Return value of host section must be a LocationAwareArrayType. Found a code path with #{singleton_type}.")
+                    end
+                end
+
+                # C++/CUDA code generation
+                ast_translator = HostSectionASTTranslator.new(command_translator: self)
+
+                # Auxiliary methods are instance methods that are called by the host section
+                aux_methods = type_inference_visitor.all_methods.map do |method|
+                    ast_translator.translate_method(method)
+                end
+
+                # Build C++ function
+                function_translation = ast_translator.translate_block(block_def_node)
+
+                # Declare local variables
+                block_def_node.local_variables_names_and_types.each do |name, type|
+                    function_translation.prepend("#{type.to_c_type} #{name};\n")
+                end
+
+                mangled_name = "_host_section_#{command.unique_id}_"
+                function_parameters = [
+                    "#{Constants::ENV_TYPE} *#{Constants::ENV_HOST_IDENTIFIER}",
+                    "#{Constants::ENV_TYPE} *#{Constants::ENV_DEVICE_IDENTIFIER}",
+                    "#{Constants::PROGRAM_RESULT_TYPE} *#{Constants::PROGRAM_RESULT_IDENTIFIER}"]
+
+                # Define incoming values (parameters). These must all be array commands for now.
+                parameter_def = block_parameter_types.map do |name, type|
+                    if type.singleton_type.is_a?(Symbolic::ArrayCommand)
+                        # Should be initialized with new array command struct
+                        "#{type.singleton_type.to_c_type} #{name} = new #{type.singleton_type.to_c_type[0...-2]}();"
+                    else
+                        "#{type.singleton_type.to_c_type} #{name};"
+                    end
+                end.join("\n") + "\n"
+
+                translation_result = Translator.read_file(
+                    file_name: "host_section_block_function_head.cpp",
+                    replacements: { 
+                        "name" => mangled_name, 
+                        "result_type" => result_type.to_c_type,
+                        "parameters" => function_parameters.join(", "),
+                        "body" => Translator.wrap_in_c_block(parameter_def + function_translation)})
+
+                program_builder.host_section_source = translation_result
+
+                # Build function invocation
+                args = [
+                    Constants::ENV_HOST_IDENTIFIER, 
+                    Constants::ENV_DEVICE_IDENTIFIER,
+                    Constants::PROGRAM_RESULT_IDENTIFIER]
+
+                # Generate code that transfers data back to host. By creating a synthetic send
+                # node here, we can let the compiler generate a switch statement if the type of
+                # the return value (array) cannot be determined uniquely at compile time.
+                host_section_invocation = AST::SourceCodeExprNode.new(
+                    code: "#{mangled_name}(#{args.join(", ")})")
+                host_section_invocation.merge_union_type(result_type)
+                device_to_host_transfer_node = AST::SendNode.new(
+                    receiver: host_section_invocation,
+                    selector: :__to_host_array__)
+
+                # Type inference is a prerequisite for code generation
+                type_inference_visitor.visit_send_node(device_to_host_transfer_node)
+
+                program_builder.host_result_expression = device_to_host_transfer_node.accept(
+                    ast_translator.expression_translator)
+                program_builder.result_type = device_to_host_transfer_node.get_type
+
+                Log.info("DONE translating ArrayHostSectionCommand [#{command.unique_id}]")
+
+                # This method has no return value (for the moment)
+            end
+        end
+    end
+end
+
+require_relative "array_in_host_section_command"

data/lib/translator/host_section/array_in_host_section_command.rb

@@ -0,0 +1,41 @@
+module Ikra
+    module Translator
+        class HostSectionCommandTranslator < CommandTranslator
+            def visit_array_in_host_section_command(command)
+                Log.info("Translating ArrayInHostSectionCommand [#{command.unique_id}]")
+
+                super
+
+                # This is a root command, determine grid/block dimensions
+                kernel_launcher.configure_grid(command.size, block_size: command.block_size)
+
+                array_input_id = "_array_#{self.class.next_unique_id}_"
+                kernel_builder.add_additional_parameters("#{command.base_type.to_c_type} *#{array_input_id}")
+
+                # Add placeholder for argument (input array). This should be done here to preserve
+                # the order or arguments.
+                kernel_launcher.add_additional_arguments(proc do |cmd|
+                    # `cmd` is a reference to the command being launched (which might be merged
+                    # with other commands). Based on that information, we can generate an 
+                    # expression that returns the input array.
+                    arg = Translator::KernelLaunchArgumentGenerator.generate_arg(
+                        command, cmd, "cmd")
+
+                    if arg == nil
+                        raise AssertionError.new("Argument not found: Trying to launch command #{cmd.unique_id}, looking for result of command #{command.unique_id}")
+                    end
+
+                    arg
+                end)
+
+                command_translation = build_command_translation_result(
+                    result: "#{array_input_id}[_tid_]",
+                    command: command)
+
+                Log.info("DONE translating ArrayInHostSectionCommand [#{command.unique_id}]")
+
+                return command_translation
+            end
+        end
+    end
+end