ikra 0.0.1 → 0.0.2

data/lib/translator/program_launcher.rb

@@ -0,0 +1,273 @@
+require "ffi"
+
+module Ikra
+    module Translator
+        class CommandTranslator
+            class ProgramBuilder
+                class Launcher
+                    class CommandNotifier < Symbolic::Visitor
+                        # This visitor executes the post_execute function on every Array Command
+                        # That way the responsible command node will recieve the adress of the computed result that will be kept on GPU
+
+                        attr_reader :environment
+
+                        def initialize(environment)
+                            @environment = environment
+                        end
+
+                        def visit_array_command(command)
+                            super(command)
+                            command.post_execute(environment)
+                        end
+                    end
+
+                    class FixedSizeArrayStruct < FFI::Struct
+                        layout :content, :pointer,
+                            :size, :int32
+                    end
+
+                    class UnionTypeValue < FFI::Union
+                        # There are some values missing here, but we don't need them at the moment
+                        layout :int_, :int32,
+                            :variable_size_array, FixedSizeArrayStruct
+                    end
+
+                    class UnionTypeStruct < FFI::Struct
+                        layout :class_id, :int32,
+                            :value, UnionTypeValue
+                    end
+
+                    class KernelUnionResultStruct < FFI::Struct
+                        layout :result, UnionTypeStruct,
+                            :error_code, :int32,
+                            :time_setup_cuda, :uint64,
+                            :time_prepare_env, :uint64,
+                            :time_kernel, :uint64,
+                            :time_free_memory, :uint64,
+                            :time_transfer_memory, :uint64,
+                            :time_allocate_memory, :uint64
+                    end
+
+                    class KernelResultStruct < FFI::Struct
+                        layout :result, FixedSizeArrayStruct,
+                            :error_code, :int32,
+                            :time_setup_cuda, :uint64,
+                            :time_prepare_env, :uint64,
+                            :time_kernel, :uint64,
+                            :time_free_memory, :uint64,
+                            :time_transfer_memory, :uint64,
+                            :time_allocate_memory, :uint64
+                    end
+
+                    attr_reader :root_command
+                    attr_reader :source
+                    attr_reader :environment_builder
+                    attr_reader :result_type
+
+                    class << self
+                        attr_accessor :last_time_setup_cuda
+                        attr_accessor :last_time_prepare_env
+                        attr_accessor :last_time_kernel
+                        attr_accessor :last_time_free_memory
+                        attr_accessor :last_time_transfer_memory
+                        attr_accessor :last_time_allocate_memory
+                        attr_accessor :last_time_total_external
+                        attr_accessor :last_time_compiler
+                        attr_accessor :last_time_read_result_ffi
+
+                        def reset_time
+                            @last_time_setup_cuda = 0
+                            @last_time_prepare_env = 0
+                            @last_time_kernel = 0
+                            @last_time_free_memory = 0
+                            @last_time_transfer_memory = 0
+                            @last_time_allocate_memory = 0
+                            @last_time_total_external = 0
+                            @last_time_compiler = 0
+                            @last_time_read_result_ffi = 0
+                        end
+                    end
+
+                    def initialize(source:, environment_builder:, result_type:, root_command:)
+                        @source = source
+                        @environment_builder = environment_builder
+                        @result_type = result_type
+                        @root_command = root_command
+                    end
+
+                    def compile
+                        # Generate debug output with line numbers
+                        line_no_digits = Math.log(source.lines.count, 10).ceil
+                        source_with_line_numbers = source.lines.each_with_index.map do |line, num| 
+                            "[#{(num + 1).to_s.rjust(line_no_digits, "0")}] #{line}" 
+                        end.join("")
+
+                        Log.info("Generated source code:\n#{source_with_line_numbers}")
+
+                        # Write source code to temporary file
+                        file = Tempfile.new(["ikra_kernel", ".cu"])
+                        file.write(source)
+                        file.close
+
+                        # Write to codegen_expect
+                        if Configuration.codegen_expect_file_name != nil
+                            expect_file = File.new(Configuration.codegen_expect_file_name, "w+")
+                            expect_file.write(source)
+                            expect_file.close
+                        end
+
+                        # Run compiler
+                        @so_filename = "#{file.path}.#{Configuration.so_suffix}"
+                        nvcc_command = Configuration.nvcc_invocation_string(
+                            file.path, @so_filename)
+                        Log.info("Compiling kernel: #{nvcc_command}")
+                        time_before = Time.now
+                        compile_status = %x(#{nvcc_command})
+                        Log.info("Done, took #{Time.now - time_before} s")
+                        self.class.last_time_compiler = Time.now - time_before
+
+                        if $? != 0
+                            Log.fatal("nvcc failed: #{compile_status}")
+                            raise RuntimeError.new("nvcc failed: #{compile_status}")
+                        else
+                            Log.info("nvcc successful: #{compile_status}")
+                        end
+                    end
+
+                    # Attaches the compiled shared library via Ruby FFI and invokes the kernel.
+                    def execute
+                        if !File.exist?(@so_filename)
+                            compile
+                        end
+
+                        time_before = Time.now
+                        ffi_interface = Module.new
+                        ffi_interface.extend(FFI::Library)
+                        ffi_interface.ffi_lib(@so_filename)
+                        ffi_interface.attach_function(:launch_kernel, [:pointer], :pointer)
+                        environment_object = environment_builder.build_ffi_object
+                        Log.info("FFI transfer time: #{Time.now - time_before} s")
+
+                        time_before = Time.now
+                        kernel_result = ffi_interface.launch_kernel(environment_object)
+                        total_time_external = Time.now - time_before
+                        Log.info("Kernel time: #{total_time_external} s")
+
+                        # Update command
+                        root_command.accept(CommandNotifier.new(environment_builder.ffi_struct))
+
+                        # TODO: Currently, this only works if result_type.is_singleton?
+                        if result_type.is_singleton?
+                            result_t_struct = KernelResultStruct.new(kernel_result)
+                        else
+                            result_t_struct = KernelUnionResultStruct.new(kernel_result)
+                        end
+
+                        # Extract error code and return value
+                        error_code = result_t_struct[:error_code]
+
+                        # Extract time measurements
+                        self.class.last_time_setup_cuda += result_t_struct[:time_setup_cuda] * 0.000001
+                        self.class.last_time_prepare_env += result_t_struct[:time_prepare_env] * 0.000001
+                        self.class.last_time_kernel += result_t_struct[:time_kernel] * 0.000001
+                        self.class.last_time_free_memory += result_t_struct[:time_free_memory] * 0.000001
+                        self.class.last_time_transfer_memory += result_t_struct[:time_transfer_memory] * 0.000001
+                        self.class.last_time_allocate_memory += result_t_struct[:time_allocate_memory] * 0.000001
+                        self.class.last_time_total_external += total_time_external
+
+                        if error_code != 0
+                            # Kernel failed
+                            Errors.raiseCudaError(error_code)
+                        end
+
+                        time_before = Time.now
+
+                        # Check type of result: It should be one of `result_type`
+                        if result_type.is_singleton?
+                           array_type = result_type.singleton_type
+
+                            if !array_type.is_a?(Types::ArrayType)
+                                raise AssertionError.new(
+                                    "ArrayType expected, but #{array_type} found")
+                            end
+
+                            result = result_t_struct[:result][:content]
+                            result_size = result_t_struct[:result][:size]
+                        else
+                            array_type = result_type.find do |sing_type|
+                                sing_type.class_id == result_t_struct[:result][:class_id]
+                            end
+
+                            if array_type == nil
+                                raise AssertionError.new(
+                                    "Unknown class_id: #{result_t_struct[:result][:class_id]}")
+                            end
+
+                            if !array_type.is_a?(Types::ArrayType)
+                                raise AssertionError.new(
+                                    "ArrayType expected, but #{array_type} found")
+                            end
+
+                            result = result_t_struct[:result][:value][:variable_size_array][:content]
+                            result_size = result_t_struct[:result][:value][:variable_size_array][:size]
+                        end
+
+                        inner_type = array_type.inner_type
+
+                        if inner_type.is_singleton?
+                            # Read in entire array
+                            if inner_type.singleton_type == Types::PrimitiveType::Int
+                                computation_result = result.read_array_of_int(result_size)
+                            elsif inner_type.singleton_type == Types::PrimitiveType::Float
+                                computation_result = result.read_array_of_float(result_size)
+                            elsif inner_type.singleton_type == Types::PrimitiveType::Bool
+                                computation_result = result.read_array_of_uint8(result_size).map do |v|
+                                    v == 1
+                                end
+                            elsif inner_type.singleton_type == Types::PrimitiveType::Nil
+                                computation_result = [nil] * result_size
+                            elsif inner_type.singleton_type.is_a?(Types::ZipStructType)
+                                result_struct_type = inner_type.singleton_type.to_ruby_type
+                                computation_result = Array.new(result_size) do |index|
+                                    result_struct_type.new(result + index * result_struct_type.size)
+                                end
+                            else
+                                raise NotImplementedError.new("Type not implemented")
+                            end
+
+                            self.class.last_time_read_result_ffi = Time.now - time_before
+                            return computation_result
+                        else
+                            # Read union type struct
+                            # Have to read one by one and assemble object
+                            result_values = Array.new(result_size)
+
+                            for index in 0...result_size
+                                # TODO: Size of union type (12 bytes) should not be hard-coded here
+                                s = Constants::UNION_TYPE_SIZE
+                                o = Constants::UNION_TYPE_VALUE_OFFSET
+                                next_type = (result + (s * index)).read_int
+
+                                if next_type == Types::PrimitiveType::Int.class_id
+                                    result_values[index] = (result + s * index + o).read_int
+                                elsif next_type == Types::PrimitiveType::Float.class_id
+                                    result_values[index] = (result + s * index + o).read_float
+                                elsif next_type == Types::PrimitiveType::Bool.class_id
+                                    result_values[index] = (result + s * index + o).read_uint8 == 1
+                                elsif next_type == Types::PrimitiveType::Nil.class_id
+                                    result_values[index] = nil
+                                else
+                                    raise NotImplementedError.new("Implement class objs for \##{index}: #{next_type}")
+                                end
+                            end
+
+                            self.class.last_time_read_result_ffi = Time.now - time_before
+                            return result_values
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
+

data/lib/translator/struct_type.rb

@@ -0,0 +1,55 @@
+module Ikra
+    module Types
+        class StructType
+            def generate_definition
+                raise NotImplementedError.new("ZipStructType is the only implementation")
+            end
+        end
+
+        class ZipStructType < StructType
+            # Generates a source code expression that creates and initializes an instance of
+            # this struct.
+            def generate_inline_initialization(*input)
+                field_init = input.join(", ")
+                return "((#{to_c_type}) {#{field_init}})"
+            end
+
+            def generate_definition
+                fields_def = @fields.map do |field_name, type|
+                    "#{type.to_c_type} #{field_name};"
+                end
+
+                all_fields = fields_def.join("\n")
+
+                return Translator.read_file(file_name: "struct_definition.cpp", replacements: {
+                    "name" => to_c_type,
+                    "fields" => all_fields})
+            end
+
+            # Generates a source code expression that reads a fields of this struct by index.
+            def generate_read(receiver, selector, index)
+                # Type inference already ensured that there is exactly one parameter which is
+                # an IntLiteral.
+
+                return "#{receiver}.field_#{index}"
+            end
+
+            def generate_non_constant_read(receiver, selector, index_expression_identifier)
+                expression = ""
+
+                for index in 0...@fields.size
+                    expression = expression + "(#{index_expression_identifier} == #{index} ? #{receiver}.field_#{index} : "
+                end
+
+                # Out of bounds case should throw and exception
+                expression = expression + "NULL"
+
+                for index in 0...@fields.size
+                    expression = expression + ")"
+                end
+
+                return expression
+            end
+        end
+    end
+end

data/lib/translator/translator.rb

@@ -1,18 +1,47 @@
+require_relative "../config/configuration"
+
+require_relative "ast_translator"
 require_relative "block_translator"
-require_relative "command_translator"
+require_relative "cuda_errors"
+require_relative "environment_builder"
+require_relative "commands/command_translator"
 require_relative "last_returns_visitor"
-require_relative "local_variables_enumerator"
-require_relative "method_translator"
-require_relative "../config/configuration"
+require_relative "struct_type"
+require_relative "array_command_struct_builder"
 
 module Ikra
 
     # This module contains functionality for translating Ruby code to CUDA (C++) code.
     module Translator
         module Constants
+            ENV_TYPE = "environment_t"
             ENV_IDENTIFIER = "_env_"
             ENV_DEVICE_IDENTIFIER = "dev_env"
             ENV_HOST_IDENTIFIER = "host_env"
+            LEXICAL_VAR_PREFIX = "lex_"
+            RESULT_IDENTIFIER = "_result_"
+            NUM_THREADS_TYPE = "int"
+            NUM_THREADS_IDENTIFIER = "_num_threads_"
+            TEMP_RESULT_IDENTIFIER = "_temp_result_"
+            ODD_TYPE = "bool"
+            ODD_IDENTIFIER = "_odd_"
+            PROGRAM_RESULT_TYPE = "result_t"
+            PROGRAM_RESULT_IDENTIFIER = "program_result"
+            SELF_IDENTIFIER = "_self_"
+
+            # Make sure that these constants keep in sync with header declaration CPP file
+            UNION_TYPE_SIZE = 24
+            UNION_TYPE_VALUE_OFFSET = 8
+        end
+
+        class Variable
+            attr_reader :type
+            attr_reader :name
+
+            def initialize(name:, type:)
+                @name = name
+                @type = type
+            end
         end
 
         class << self
@@ -26,7 +55,7 @@ module Ikra
             def read_file(file_name:, replacements: {})
                 full_name = Ikra::Configuration.resource_file_name(file_name)
                 if !File.exist?(full_name)
-                    raise "File does not exist: #{full_name}"
+                    raise AssertionError.new("File does not exist: #{full_name}")
                 end
 
                 contents = File.open(full_name, "rb").read
@@ -40,10 +69,4 @@ module Ikra
             end
         end
     end
-
-    module AST
-        module Constants
-            SELF_IDENTIFIER = "_self_"
-        end
-    end
 end

data/lib/translator/variable_classifier_visitor.rb

@@ -0,0 +1,56 @@
+require_relative "../ast/nodes"
+require_relative "../ast/visitor"
+require_relative "../types/types"
+
+module Ikra
+    module AST
+        class LVarReadNode
+            attr_accessor :variable_kind
+
+            def mangled_identifier
+                if variable_kind == :lexical
+                    return Translator::Constants::LEXICAL_VAR_PREFIX + identifier.to_s
+                else
+                    return identifier
+                end
+            end
+        end
+        
+        class LVarWriteNode
+            attr_accessor :variable_kind
+
+            def mangled_identifier
+                if variable_kind == :lexical
+                    return Translator::Constants::LEXICAL_VAR_PREFIX + identifier.to_s
+                else
+                    return identifier
+                end
+            end
+        end
+    end
+
+    module Translator
+        class VariableClassifier < AST::Visitor
+            def initialize(lexical_variable_names:)
+                @lexical_variable_names = lexical_variable_names
+            end
+
+            def visit_lvar_read_node(node)
+                node.variable_kind = var_type(node.identifier)
+            end
+            
+            def visit_lvar_write_node(node)
+                node.variable_kind = var_type(node.identifier)
+                super(node)
+            end
+
+            def var_type(identifier)
+                if @lexical_variable_names.include?(identifier)
+                    return :lexical
+                else
+                    return :local
+                end
+            end
+        end
+    end
+end