ikra 0.0.1 → 0.0.2

data/lib/types/types/array_type.rb

@@ -0,0 +1,137 @@
+# No explicit `require`s. This file should be includes via types.rb
+
+module Ikra
+    module Types
+        class ArrayType
+            include RubyType
+
+            class << self
+                alias_method :new_original, :new
+
+                # Ensure singleton per class
+                def new(inner_type)
+                    if @cache == nil
+                        @cache = {}
+                        @cache.default_proc = proc do |hash, key|
+                            hash[key] = new_original(key)
+                        end
+                    end
+
+                    return @cache[inner_type]
+                end
+            end
+
+            attr_reader :inner_type
+            
+            def ==(other)
+                return other.class == self.class && other.inner_type == self.inner_type
+            end
+
+            def initialize(inner_type)
+                if not inner_type.is_union_type?
+                    raise AssertionError.new("Union type expected")
+                end
+
+                @inner_type = inner_type
+            end
+
+            def to_s
+                return "[#{self.class.to_s}, inner_type = #{inner_type}]"
+            end
+
+            def to_c_type
+                return "#{@inner_type.to_c_type} *"
+            end
+
+            def to_ffi_type
+                return :pointer
+            end
+
+            def to_ruby_type
+                return ::Array
+            end
+        end
+
+        class LocationAwareArrayType < ArrayType
+            # Determines if the array is allocated on the host or on the device
+            attr_reader :location
+
+            def ==(other)
+                return super && self.location == other.location
+            end
+
+            def initialize(inner_type, location)
+                @inner_type = inner_type
+                @location = location
+            end
+
+            def to_c_type
+                return "variable_size_array_t"
+            end
+        end
+
+        class LocationAwareVariableSizeArrayType < LocationAwareArrayType
+            class << self
+                def new(inner_type, location: :device)
+                    if @cache == nil
+                        @cache = {}
+                        @cache.default_proc = Proc.new do |hash, key|
+                            hash[key] = new_original(*key)
+                        end
+                    end
+
+                    return @cache[[inner_type, location]]
+                end
+            end
+
+            def to_command
+                # No fusion possible here. The first parameter (target) is a reference to the
+                # array command struct representing the [ArrayInHostSectionCommand].
+                # TODO: The code depends on the template (variable name `cmd` and `input_0`).
+                return Symbolic::ArrayInHostSectionCommand.new("((#{@inner_type.to_c_type} *) cmd->input_0)", @inner_type)
+            end
+        end
+
+        class LocationAwareFixedSizeArrayType < LocationAwareArrayType
+            class << self
+                def new(inner_type, dimensions, location: :device)
+                    if @cache == nil
+                        @cache = {}
+                        @cache.default_proc = Proc.new do |hash, key|
+                            hash[key] = new_original(*key)
+                        end
+                    end
+
+                    return @cache[[inner_type, location, dimensions]]
+                end
+            end
+
+            attr_reader :dimensions
+
+            def initialize(inner_type, location, dimensions)
+                super(inner_type, location)
+                @dimensions = dimensions
+            end
+
+            def to_command
+                # No fusion possible here. The first parameter (target) is a reference to the
+                # array command struct representing the [ArrayInHostSectionCommand].
+                # TODO: The code depends on the template (variable name `cmd` and `input_0`).
+                return Symbolic::FixedSizeArrayInHostSectionCommand.new(
+                    "((#{@inner_type.to_c_type} *) cmd->input_0)", @inner_type, @dimensions)
+            end
+        end
+    end
+end
+
+class Array
+    def ikra_type
+        inner_type = Ikra::Types::UnionType.new
+
+        self.each do |element|
+            inner_type.add(element.ikra_type)
+        end
+
+        return Ikra::Types::ArrayType.new(inner_type)
+    end
+end

data/lib/types/{class_type.rb → types/class_type.rb}

@@ -1,9 +1,9 @@
+# No explicit `require`s. This file should be includes via types.rb
+
 require "set"
-require_relative "ruby_type"
-require_relative "union_type"
-require_relative "../sourcify/lib/sourcify"
-require_relative "../parsing"
-require_relative "../ast/builder"
+require_relative "../../sourcify/lib/sourcify"
+require_relative "../../parsing"
+require_relative "../../ast/builder"
 
 module Ikra
     module Types
@@ -27,6 +27,10 @@ module Ikra
                 end
             end
 
+            def ==(other)
+                return other.class == self.class && other.cls == self.cls
+            end
+
             def initialize(cls)
                 @cls = cls
                 @inst_vars_read = Set.new
@@ -71,23 +75,36 @@ module Ikra
                 "obj_id_t"
             end
 
+            # Generates a class name for [@cls], which is a valid C++ identifier.
+            #
+            # For example:
+            # A             --> A
+            # #<Class: A>   --> singleton_A
+            def class_name
+                # Handle name generation for singleton classes
+                return ruby_name.gsub("\#<Class:", "singleton_").gsub(">", "")
+            end
+
             def mangled_method_name(selector)
-                "_method_#{@cls.to_s}_#{selector}_"
+                "_method_#{class_name}_#{selector}_"
             end
 
             def inst_var_array_name(inst_var_name)
                 if inst_var_name.to_s[0] != "@"
-                    raise "Expected instance variable identifier"
+                    raise AssertionError.new("Expected instance variable identifier")
                 end
 
-                "_iv_#{@cls.to_s}_#{inst_var_name.to_s[1..-1]}_"
+                "_iv_#{class_name}_#{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
+                return AST::Builder.from_parser_ast(source)
+            end
+
+            def method_binding(selector)
+                # TODO: Fix binding
+                return cls.instance_method(selector).send(:binding)
             end
 
             def method_parameters(selector)
@@ -98,12 +115,13 @@ module Ikra
                 end
             end
 
-            def should_generate_type?
-                to_ruby_type != Class
+            def should_generate_self_arg?
+                # Do not generate type for singleton classes
+                return !to_ruby_type.is_a?(Module.singleton_class)
             end
 
             def to_s
-                "<class: #{@cls.to_s}>"
+                "<class: #{class_name}>"
             end
 
             def c_size
@@ -117,12 +135,18 @@ end
 class Object
     def self.to_ikra_type
         # TODO: should this method be defined on Class?
-        Ikra::Types::ClassType.new(self)
+        return 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
+    # Returns the [Ikra::Types::RubyType] for this object. Instance of the same Ruby class can
+    # principally have different Ikra types. Thus, this method is defined as an instance method.
+    def ikra_type
+        if self.is_a?(Module)
+            return self.singleton_class.to_ikra_type
+        else
+            # TODO: Double check if we always want to have the singleton class?
+            return self.class.to_ikra_type
+        end
     end
 end
 

data/lib/types/{primitive_type.rb → types/primitive_type.rb}

@@ -1,4 +1,4 @@
-require_relative "ruby_type"
+# No explicit `require`s. This file should be includes via types.rb
 
 module Ikra
     module Types
@@ -6,19 +6,26 @@ module Ikra
             include RubyType
             
             attr_reader :c_size
+            attr_reader :class_id
             
-            def initialize(c_type, ruby_type, c_size, ffi_type)
+            def initialize(c_type, ruby_type, c_size, ffi_type, class_id)
                 @c_type = c_type
                 @ruby_type = ruby_type
                 @c_size = c_size
                 @ffi_type = ffi_type
+                @class_id = class_id
             end
             
-            Int = self.new("int", Fixnum, 4, :int)
-            Float = self.new("float", Float, 4, :float)
-            Bool = self.new("bool", TrueClass, 1, :bool)
-            Void = self.new("void", nil, 0, :void)
+            Int = self.new("int", Fixnum, 4, :int, 1)
+            Float = self.new("float", Float, 4, :float, 2)
+            Bool = self.new("bool", TrueClass, 1, :bool, 3)
+            Void = self.new("void", nil, 0, :void, 4)
+            Nil = self.new("int", NilClass, 4, :int, 5)
             
+            def ==(other)
+                return other.is_a?(PrimitiveType) && other.class_id == class_id
+            end
+
             def to_ruby_type
                 @ruby_type
             end
@@ -30,7 +37,7 @@ module Ikra
             def to_ffi_type
                 @ffi_type
             end
-            
+
             def is_primitive?
                 true
             end
@@ -71,3 +78,9 @@ class FalseClass
         Ikra::Types::PrimitiveType::Bool
     end
 end
+
+class NilClass
+    def self.to_ikra_type
+        Ikra::Types::PrimitiveType::Nil
+    end
+end

data/lib/types/types/ruby_type.rb

@@ -0,0 +1,88 @@
+require "set"
+
+module Ikra
+    module Types
+
+        # Defines the minimal interface for Ikra types. Instances of {UnionType} are expected in most cases.
+        module RubyType
+            @@next_class_id = 10
+
+            def to_str
+                return to_s
+            end
+
+            def inspect
+                return to_s
+            end
+            
+            def to_ruby_type
+                raise NotImplementedError
+            end
+            
+            def to_c_type
+                raise NotImplementedError
+            end
+            
+            def is_primitive?
+                false
+            end
+
+            def is_union_type?
+                false
+            end
+
+            def should_generate_self_arg?
+                return true
+            end
+
+            def to_array_type
+                # TODO: This should probably not return a union type by default
+                return ArrayType.new(self).to_union_type
+            end
+
+            def to_union_type
+                return UnionType.new(self)
+            end
+
+            def class_id
+                if @class_id == nil
+                    @class_id = @@next_class_id
+                    @@next_class_id += 1
+                end
+
+                @class_id
+            end
+
+            def eql?(other)
+                return self == other
+            end
+
+            def hash
+                # TODO: Implement
+                return 0
+            end
+        end
+
+        # This type is marker and denotes that an expression should be executed only in the Ruby
+        # interpreter. No CUDA code should be generated for such expressions.
+        class InterpreterOnlyType
+            include RubyType
+
+            def self.new
+                if @singleton_instance == nil
+                    @singleton_instance = super
+                end
+
+                return @singleton_instance
+            end
+        end
+    end
+end
+
+class Array
+    def to_type_array_string
+        "[" + map do |set|
+            set.to_s
+        end.join(", ") + "]"
+    end
+end

data/lib/types/types/struct_type.rb

@@ -0,0 +1,179 @@
+# No explicit `require`s. This file should be includes via types.rb
+
+require "ffi"
+
+module Ikra
+    module Types
+        # This type represents a C++ struct. It has fields, each of which has
+        # a type.
+        class StructType
+            include RubyType
+
+            attr_reader :fields
+
+            class << self
+                # Ensure singleton per class
+                def new(fields)
+                    if @cache == nil
+                        @cache = {} 
+                    end
+
+                    if not @cache.include?(identifier_from_hash(fields))
+                        @cache[identifier_from_hash(fields)] = super(fields)
+                    end
+
+                    @cache[identifier_from_hash(fields)]
+                end
+
+                # Generates a unique type identifier based on the types of the struct fields.
+                def identifier_from_hash(fields)
+                    identifier = "indexed_struct_#{fields.size}_lt_"
+
+                    type_parts = fields.map do |key, value|
+                        value.to_c_type
+                    end
+
+                    identifier = identifier + type_parts.join("_")
+
+                    return identifier + "_gt_t"
+                end
+            end
+
+            def ==(other)
+                return other.class == self.class && other.fields == self.fields
+            end
+
+            def initialize(fields)
+                fields.each do |key, value|
+                    if not value.is_union_type?
+                        raise AssertionError.new("Union type expected for field #{key}")
+                    end
+                end
+
+                @fields = fields
+            end
+
+            def to_c_type
+                return StructType.identifier_from_hash(@fields)
+            end
+
+            def to_ffi_type
+                # TODO: Support transfering zipped data back from GPU
+                return to_ruby_type
+            end
+
+            def to_ruby_type
+                # TODO: general structs
+                raise NotImplementedError.new
+            end
+        end
+
+        # This type represents the type of an array that is the result of 
+        # zipping two arrays. [ZipStructType] is similar to [StructType] but
+        # can be accessed via indices.
+        class ZipStructType < StructType
+            class << self
+                def new(*types)
+                    identifiers = Array.new(types.size) do |index|
+                        :"field_#{index}"
+                    end
+
+                    super(Hash[identifiers.zip(types)])
+                end
+            end
+
+            # Performs type inference for the result of accessing this Zip "Array" by index.
+            def get_return_type(selector, *arg_nodes)
+                # TODO: Can only handle single cases at the moment. This should eventually forward
+                # to Array integration code.
+
+                if selector != :"[]"
+                    raise AssertionError.new(
+                        "Selector not supported for ZipStructType: #{selector}")
+                end
+
+                if arg_nodes.size != 1
+                    raise AssertionError.new("Expected exactly one argument")
+                end
+
+                if arg_nodes.first.class == AST::IntLiteralNode
+                    if arg_nodes.first.value >= @fields.size
+                        raise AssertionError.new(
+                            "ZipStruct index out of bounds: #{arg_nodes.first.value}")
+                    end
+
+                    return self[arg_nodes.first.value]
+                else
+                    return get_return_type_non_constant(selector)
+                end
+            end
+
+            # Performs type inference for the result of accessing this Zip "Array" by index.
+            def get_return_type_non_constant(selector)
+                # TODO: Can only handle single cases at the moment. This should eventually forward
+                # to Array integration code.
+
+                # TODO: This code assumes that the all struct elements have the same type
+                return self[0]
+            end
+
+            # Returns the type of the element at [index].
+            def [](index)
+                return @fields[:"field_#{index}"]
+            end
+
+            # A module that provides array-like functionality for FFI Struct types.
+            module ZipStruct
+                def self.included(base)
+                    base.include(Enumerable)
+                end
+
+                def [](index)
+                    # Out of bounds: returns nil
+                    return super(:"field_#{index}")
+                end
+
+                def []=(index, value)
+                    # TODO: What should we do if the type of a field changes?
+
+                    # Fill up missing slots with `nil`
+                    for id in (@fields.size)..index
+                        super(:"field_{id}", nil)
+                    end
+
+                    super(:"field_{index}", value)
+                    return value
+                end
+
+                def each(&block)
+                    for index in 0...(@fields.size)
+                        yield(self[index])
+                    end
+                end
+            end
+
+            def to_ruby_type
+                # Cache struct types
+                if @struct_type == nil
+                    # Create class
+                    @struct_type = Class.new(FFI::Struct)
+                    @struct_type.include(ZipStruct)
+
+                    # Define layout of struct
+                    var_names = Array.new(@fields.size) do |index|
+                        :"field_#{index}"
+                    end
+
+                    var_types = var_names.map do |name|
+                        @fields[name].to_ffi_type
+                    end
+
+                    layout = var_names.zip(var_types).flatten
+                    @struct_type.layout(*layout)
+                end
+
+                return @struct_type
+            end
+        end
+    end
+end