ikra 0.0.1

data/lib/translator/last_returns_visitor.rb

@@ -0,0 +1,57 @@
+require_relative "../ast/nodes"
+require_relative "../ast/visitor"
+
+module Ikra
+    module Translator
+        class LastStatementReturnsVisitor < AST::Visitor
+            def visit_root_node(node)
+                node.child.accept(self)
+            end
+
+            def visit_lvar_read_node(node)
+                node.parent.replace_child(node, AST::ReturnNode.new(value: node))
+            end
+            
+            def visit_lvar_write_node(node)
+                node.parent.replace_child(node, AST::ReturnNode.new(value: node))
+            end
+            
+            def visit_int_node(node)
+                node.parent.replace_child(node, AST::ReturnNode.new(value: node))
+            end
+            
+            def visit_float_node(node)
+                node.parent.replace_child(node, AST::ReturnNode.new(value: node))
+            end
+            
+            def visit_bool_node(node)
+                node.parent.replace_child(node, AST::ReturnNode.new(value: node))
+            end
+            
+            def visit_for_node(node)
+                raise "Cannot handle for loop as return value"
+            end
+            
+            def visit_break_node(node)
+                raise "Break must not be a return value"
+            end
+            
+            def visit_if_node(node)
+                node.true_body_stmts.accept(self)
+                node.false_body_stmts.accept(self)
+            end
+            
+            def visit_begin_node(node)
+                node.body_stmts.last.accept(self)
+            end
+            
+            def visit_send_node(node)
+                node.parent.replace_child(node, AST::ReturnNode.new(value: node))
+            end
+
+            def visit_return_node(node)
+                raise "Function returns already"
+            end
+        end
+    end
+end

data/lib/translator/local_variables_enumerator.rb

@@ -0,0 +1,35 @@
+require_relative "../ast/nodes"
+require_relative "../ast/visitor"
+require_relative "../types/type_inference"
+
+module Ikra
+    module Translator
+        class LocalVariablesEnumerator < AST::Visitor
+            def initialize
+                @vars = {}
+            end
+
+            def add_local_var(var, type)
+                @vars[var] = type
+            end
+
+            def local_variables
+                @vars
+            end
+
+            def visit_lvar_read_node(node)
+                add_local_var(node.identifier, node.get_type)
+            end
+            
+            def visit_lvar_write_node(node)
+                add_local_var(node.identifier, node.get_type)
+                super(node)
+            end
+
+            def visit_for_node(node)
+                add_local_var(node.iterator_identifier, Types::UnionType.create_int)
+                super(node)
+            end
+        end
+    end
+end

data/lib/translator/method_translator.rb

@@ -0,0 +1,24 @@
+module Ikra
+    module AST
+        class MethodDefinition
+            def to_c_source
+                # TODO: merge with BlockTranslator
+                
+                method_params = (["environment_t * #{Translator::Constants::ENV_IDENTIFIER}", "#{type.to_c_type} #{Constants::SELF_IDENTIFIER}"] + parameter_variables.map do |name, type|
+                    "#{name} #{type.singleton_type.to_c_type}"
+                end).join(", ")
+
+                # TODO: load environment variables
+
+                # Declare local variables
+                local_variables_def = ""
+                local_variables.each do |name, types|
+                    local_variables_def += "#{types.singleton_type.to_c_type} #{name};\n"
+                end
+
+                signature = "__device__ #{return_type.singleton_type.to_c_type} #{type.mangled_method_name(selector)}(#{method_params})"
+                signature + "\n" + Translator.wrap_in_c_block(local_variables_def + ast.translate_statement)
+            end
+        end
+    end
+end

data/lib/translator/translator.rb

@@ -0,0 +1,49 @@
+require_relative "block_translator"
+require_relative "command_translator"
+require_relative "last_returns_visitor"
+require_relative "local_variables_enumerator"
+require_relative "method_translator"
+require_relative "../config/configuration"
+
+module Ikra
+
+    # This module contains functionality for translating Ruby code to CUDA (C++) code.
+    module Translator
+        module Constants
+            ENV_IDENTIFIER = "_env_"
+            ENV_DEVICE_IDENTIFIER = "dev_env"
+            ENV_HOST_IDENTIFIER = "host_env"
+        end
+
+        class << self
+            def wrap_in_c_block(str)
+                "{\n" + str.split("\n").map do |line| "    " + line end.join("\n") + "\n}\n"
+            end
+
+            # Reads a CUDA source code file and replaces identifiers by provided substitutes.
+            # @param [String] file_name name of source code file
+            # @param [Hash{String => String}] replacements replacements
+            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}"
+                end
+
+                contents = File.open(full_name, "rb").read
+
+                replacements.each do |s1, s2|
+                    replacement = "/*{#{s1}}*/"
+                    contents = contents.gsub(replacement, s2)
+                end
+
+                contents
+            end
+        end
+    end
+
+    module AST
+        module Constants
+            SELF_IDENTIFIER = "_self_"
+        end
+    end
+end

data/lib/type_aware_array.rb

@@ -0,0 +1,71 @@
+class Array
+
+    # TODO: probably do not need this anymore
+    def common_superclass
+        class_counter = {}
+        class_counter.default = 0
+        
+        index = 0
+        each do |cls|
+            while (cls != BasicObject) do
+                class_counter[cls] += 1
+                cls = cls.superclass
+            end
+            index += 1
+        end
+        
+        smallest = Object
+        class_counter.each do |cls, counter|
+            if counter == size
+                if cls < smallest
+                    smallest = cls
+                end
+            end
+        end
+        
+        smallest
+    end
+    
+    def all_types
+        type_counter.keys
+    end
+    
+    alias :old_push :push
+    
+    def push(*elements)
+        old_push(*elements)
+
+        for element in elements
+            type_counter[element.class] += 1
+        end
+
+        self
+    end
+    
+    alias :old_set :[]=
+    
+    def []=(index, element)
+        type_counter[self[index].class] -= 1
+        if type_counter[self[index].class] == 0
+            type_counter.delete(self[index].class)
+        end
+        
+        old_set(index, element)
+        type_counter[element.class] += 1
+    end
+    
+    private
+    
+    def type_counter
+        if @type_counter == nil
+            @type_counter = {}
+            @type_counter.default = 0
+            
+            each do |element|
+                @type_counter[element.class] += 1
+            end
+        end
+        
+        @type_counter
+    end
+end

data/lib/types/array_type.rb

@@ -0,0 +1,51 @@
+require_relative "ruby_type"
+
+module Ikra
+    module Types
+        class ArrayType
+            include RubyType
+
+            class << self
+                # Ensure singleton per class
+                def new(inner_type)
+                    if @cache == nil
+                        @cache = {}
+                        @cache.default_proc = Proc.new do |hash, key|
+                            hash[key] = super(key)
+                        end
+                    end
+
+                    @cache[inner_type]
+                end
+            end
+
+            def initialize(inner_type)
+                if not inner_type.is_union_type?
+                    raise "Union type expected"
+                end
+
+                @inner_type = inner_type
+            end
+
+            def to_c_type
+                "#{@inner_type.to_c_type} *"
+            end
+
+            def to_ffi_type
+                :pointer
+            end
+        end
+    end
+end
+
+class Array
+    def self.to_ikra_type_obj(object)
+        inner_type = Ikra::Types::UnionType.new
+
+        object.each do |element|
+            inner_type.expand_with_singleton_type(element.class.to_ikra_type)
+        end
+
+        Ikra::Types::ArrayType.new(inner_type)
+    end
+end

data/lib/types/class_type.rb

@@ -0,0 +1,128 @@
+require "set"
+require_relative "ruby_type"
+require_relative "union_type"
+require_relative "../sourcify/lib/sourcify"
+require_relative "../parsing"
+require_relative "../ast/builder"
+
+module Ikra
+    module Types
+        class ClassType
+            include RubyType
+
+            attr_reader :cls
+            attr_reader :inst_vars_types
+
+            class << self
+                # Ensure singleton per class
+                def new(cls)
+                    if @cache == nil
+                        @cache = {}
+                        @cache.default_proc = Proc.new do |hash, key|
+                            hash[key] = super(key)
+                        end
+                    end
+
+                    @cache[cls]
+                end
+            end
+
+            def initialize(cls)
+                @cls = cls
+                @inst_vars_read = Set.new
+                @inst_vars_written = Set.new
+
+                @inst_vars_types = Hash.new
+                @inst_vars_types.default_proc = Proc.new do |hash, key|
+                    hash[key] = UnionType.new
+                end
+            end
+
+            def inst_var_read!(inst_var_name)
+                @inst_vars_read.add(inst_var_name)
+            end
+
+            def inst_var_written!(inst_var_name)
+                @inst_var_written.add(inst_var_name)
+            end
+
+            def inst_var_read?(inst_var_name)
+                @inst_var_read.include?(inst_var_name)
+            end
+
+            def inst_var_written(inst_var_name)
+                @inst_var_written.include?(inst_var_name)
+            end
+
+            def accessed_inst_vars
+                @inst_vars_read + @inst_vars_written
+            end
+
+            def to_ruby_type
+                @cls
+            end
+
+            def ruby_name
+                @cls.to_s
+            end
+
+            def to_c_type
+                # TODO: sometimes this should be a union type struct
+                "obj_id_t"
+            end
+
+            def mangled_method_name(selector)
+                "_method_#{@cls.to_s}_#{selector}_"
+            end
+
+            def inst_var_array_name(inst_var_name)
+                if inst_var_name.to_s[0] != "@"
+                    raise "Expected instance variable identifier"
+                end
+
+                "_iv_#{@cls.to_s}_#{inst_var_name.to_s[1..-1]}_"
+            end
+
+            def method_ast(selector)
+                source = Parsing.parse_method(cls.instance_method(selector))
+                ast = AST::Builder.from_parser_ast(source)
+                ast.class_owner = @cls
+                ast
+            end
+
+            def method_parameters(selector)
+                # returns names
+                # TODO: handle optional params, kwargs, etc.
+                to_ruby_type.instance_method(selector).parameters.map do |param|
+                    param[1]
+                end
+            end
+
+            def should_generate_type?
+                to_ruby_type != Class
+            end
+
+            def to_s
+                "<class: #{@cls.to_s}>"
+            end
+
+            def c_size
+                # IDs are 4 byte integers
+                4
+            end
+        end
+    end
+end
+
+class Object
+    def self.to_ikra_type
+        # TODO: should this method be defined on Class?
+        Ikra::Types::ClassType.new(self)
+    end
+
+    # Returns the [Ikra::Types::RubyType] for this class. This version of the method receives the actual object as a parameter. This is necessary for example to determine the exact type of an array (including inner type).
+    def self.to_ikra_type_obj(object)
+        to_ikra_type
+    end
+end
+

data/lib/types/object_tracer.rb

@@ -0,0 +1,162 @@
+require "set"
+require "ffi"
+require_relative "../entity"
+require_relative "class_type"
+require_relative "../symbolic/symbolic"
+require_relative "../translator/command_translator"
+
+module Ikra
+    module TypeInference
+
+        # The object tracer determines a set of objects that are relevant for the execution of a parallel section (grouped by class). Only instances of classes that have {Ikra::Entity} included are such relevant objects.
+        class ObjectTracer
+            def initialize(command)
+                # Hash map: Class -> Set[Object]
+                @roots = RootsFinder.process(command)
+                @num_traced_objects = 0
+
+                @objects = Hash.new
+                @objects.default_proc = Proc.new do |hash, key|
+                    hash[key] = Hash.new
+                end
+
+                @top_object_id = Hash.new
+                @top_object_id.default = -1
+            end
+
+            def trace_all
+                @worklist = Set.new(@roots)
+
+                while @worklist.size > 0
+                    current_obj = @worklist.first
+                    @worklist.delete(current_obj)
+
+                    trace_object(current_obj)
+                end
+
+                Log.info("Traced #{@num_traced_objects} objects with #{@objects.size} distinct types")
+
+                @objects
+            end
+
+            def trace_object(object)
+                if not object.class.to_ikra_type.is_primitive?
+                    if not @objects[object.class].has_key?(object)
+                        # object was not traced yet
+                        @objects[object.class][object] = (@top_object_id[object.class] += 1)
+                        @num_traced_objects += 1
+
+                        object.instance_variables.each do |inst_var_name|
+                            value = object.instance_variable_get(inst_var_name)
+                            value_type = value.class.to_ikra_type
+
+                            # Gather type information
+                            object.class.to_ikra_type.inst_vars_types[inst_var_name].expand_with_singleton_type(value_type)
+
+                            if value.class.include?(Entity)
+                                # Keep tracing this object
+                                @worklist.add(value)
+                            end
+                        end
+                    end
+                end
+            end
+
+            # Generates arrays for the Structure of Arrays (SoA) object layout
+            def register_soa_arrays(environment_builder)
+                # arrays: class x inst var name -> Array
+                arrays = Hash.new
+                arrays.default_proc = proc do |hash, cls|
+                    inner_hash = Hash.new
+                    inner_hash.default_proc = proc do |inner, inst_var|
+                        inner[inst_var] = Array.new(@top_object_id[cls] + 1)
+                    end
+                    hash[cls] = inner_hash
+                end
+
+                @objects.each do |cls, objs|
+                    cls.to_ikra_type.accessed_inst_vars.each do |inst_var|
+                        objs.each do |obj, id|
+                            inst_var_value = obj.instance_variable_get(inst_var)
+
+                            if inst_var_value.class.to_ikra_type.is_primitive?
+                                # Use object value directly
+                                arrays[cls][inst_var][id] = inst_var_value
+                            else
+                                if !inst_var_value.class.include?(Entity)
+                                    Log.warn("Attempting to transfer an object of class #{inst_var_value.class} that is not an Ikra::Entity. Could be a false positive. Skipping.")
+                                else
+                                    # Use object ID
+                                    arrays[cls][inst_var][id] = @objects[inst_var_value.class][inst_var_value]
+                                end
+                            end
+                        end
+                    end
+                end
+                
+                arrays.each do |cls, inner_hash|
+                    inner_hash.each do |inst_var, array|
+                        environment_builder.add_soa_array(cls.to_ikra_type.inst_var_array_name(inst_var), array)
+                    end
+                end
+            end
+
+            # Returns an array of IDs for the base array or the base array itself if all values are primitive. 
+            # TODO: This should be done in the environment builder, but I want to avoid copying over arrays...
+            def convert_base_array(base_array, need_union_type)
+                if base_array.first.class.to_ikra_type.is_primitive? && !need_union_type
+                    base_array
+                else
+                    if !need_union_type
+                        base_array.map do |obj|
+                            @objects[obj.class][obj]
+                        end
+                    else
+                        mem_block = FFI::MemoryPointer.new(Translator::EnvironmentBuilder::UnionTypeStruct, base_array.size)
+                        array = base_array.size.times.collect do |index|
+                            Translator::EnvironmentBuilder::UnionTypeStruct.new(mem_block + index * Translator::EnvironmentBuilder::UnionTypeStruct.size)
+                        end
+
+                        base_array.each_with_index do |obj, index|
+                            obj_type = obj.class.to_ikra_type
+                            array[index][:class_id] = obj_type.class_id
+
+                            if obj_type.is_primitive?
+                                # TODO: what if the primitive value is not an integer?
+                                array[index][:object_id] = obj
+                            else
+                                array[index][:object_id] = @objects[obj.class][obj]
+                            end
+                        end
+
+                        mem_block
+                    end
+                end
+            end
+
+            # Finds all roots (including dependent commands) of a command.
+            class RootsFinder < Symbolic::Visitor
+                attr_reader :roots
+
+                def self.process(command)
+                    instance = self.new
+                    command.accept(instance)
+                    instance.roots
+                end
+
+                def initialize
+                    @roots = Set.new
+                end
+
+                def visit_array_command(command)
+                    @roots.merge(command.lexical_externals.values)
+                end
+
+                def visit_array_identity_command(command)
+                    super
+                    @roots.merge(command.target)
+                end
+            end
+        end
+    end
+end