ikra 0.0.1 → 0.0.2

data/lib/ruby_core/core.rb

@@ -0,0 +1,103 @@
+module Ikra
+    module RubyIntegration
+        # TODO: Handle non-singleton types
+
+        TYPE_INT_COERCE_TO_FLOAT = proc do |recv, other|
+            if other.include?(FLOAT_S) 
+                FLOAT
+            elsif other.include?(INT_S)
+                INT
+            else
+                # At least one of the types INT_S or FLOAT_S are required
+                raise RuntimeError.new("Operation defined numeric values only (found #{other})")
+            end
+        end
+
+        TYPE_INT_RETURN_INT = proc do |recv, other|
+            if !other.include?(INT_S)
+                raise RuntimeError.new("Operation defined Int values only (found #{other})")
+            end
+
+            INT
+        end
+
+        TYPE_NUMERIC_RETURN_BOOL = proc do |recv, other|
+            if !other.include?(INT_S) && !other.include?(FLOAT_S)
+                raise RuntimeError.new("Expected type Int or Float, found #{other}")
+            end
+
+            BOOL
+        end
+
+        TYPE_BOOL_RETURN_BOOL = proc do |recv, other|
+            if !other.include?(BOOL_S)
+                raise RuntimeError.new("Expected type Bool, found #{other}")
+            end
+
+            BOOL
+        end
+
+        # TODO: fix int % float
+        implement INT_S, :%, TYPE_INT_COERCE_TO_FLOAT, 1, "(#0 % #N1)"
+        implement INT_S, :&, TYPE_INT_RETURN_INT, 1, "(#0 & #I1)"
+        implement INT_S, :|, TYPE_INT_RETURN_INT, 1, "(#0 | #I1)"
+        implement INT_S, :*, TYPE_INT_COERCE_TO_FLOAT, 1, "(#0 * #N1)"
+        # TODO: Find better implementation for Int pow
+        implement INT_S, :**, INT, 1, "((int) pow((double) #0, (double) #F1))"
+        implement INT_S, :+, TYPE_INT_COERCE_TO_FLOAT, 1, "(#0 + #N1)"
+        implement INT_S, :-, TYPE_INT_COERCE_TO_FLOAT, 1, "(#0 - #N1)"
+        # TODO: Implement unary -
+        implement INT_S, :/, TYPE_INT_COERCE_TO_FLOAT, 1, "(#0 / #N1)"
+        implement INT_S, :<, TYPE_NUMERIC_RETURN_BOOL, 1, "(#0 < #N1)"
+        implement INT_S, :<<, TYPE_INT_RETURN_INT, 1, "(#0 << #I1)"
+        implement INT_S, :<=, TYPE_NUMERIC_RETURN_BOOL, 1, "(#0 <= #N1)"
+        # TODO: Implement <=>
+        implement INT_S, :==, TYPE_NUMERIC_RETURN_BOOL, 1, "(#0 == #N1)"
+        implement INT_S, :"!=", TYPE_NUMERIC_RETURN_BOOL, 1, "(#0 != #N1)"
+        implement INT_S, :>, TYPE_NUMERIC_RETURN_BOOL, 1, "(#0 > #N1)"
+        implement INT_S, :>=, TYPE_NUMERIC_RETURN_BOOL, 1, "(#0 >= #N1)"
+        implement INT_S, :>>, TYPE_INT_RETURN_INT, 1, "(#0 >> #I1)"
+        implement INT_S, :"^", TYPE_INT_RETURN_INT, 1, "(#0 ^ IN1)"
+
+        implement INT_S, :abs, INT, 0, "({ int value = #0; value < 0 ? -value : value; })"
+        implement INT_S, :bit_length, INT, 1, "({ int value = #0; (int) ceil(log2f(value < 0 ? -value : value + 1)); })"
+        implement INT_S, :div, INT, 1, "((int) (#0 / #I1))"
+        implement INT_S, :even?, BOOL, 0, "(#0 % 2 == 0)"
+        implement INT_S, :fdiv, FLOAT, 1, "(#0 / #F1)"
+        implement INT_S, :magnitude, INT, 0, "({ int value = #0; value < 0 ? -value : value; })"
+        implement INT_S, :modulo, TYPE_INT_COERCE_TO_FLOAT, 1, "(#0 % #N1)"
+        implement INT_S, :odd?, BOOL, 0, "(#0 % 2 != 0)"
+        implement INT_S, :size, INT, 0, "sizeof(int)"
+        implement INT_S, :next, INT, 0, "(#0 + 1)"
+        implement INT_S, :succ, INT, 0, "(#0 + 1)"
+        implement INT_S, :zero?, BOOL, 0, "(#0 == 0)"
+        implement INT_S, :to_f, FLOAT, 1, "((float) #0)"
+        implement INT_S, :to_i, INT, 1, "#0"
+
+        implement FLOAT_S, :%, FLOAT, 1, "fmodf(#0, #F1)"
+        implement FLOAT_S, :*, FLOAT, 1, "(#0 * #N1)"
+        implement FLOAT_S, :**, FLOAT, 1, "powf(#0, #F1)"
+        implement FLOAT_S, :+, FLOAT, 1, "(#0 + #N1)"
+        implement FLOAT_S, :-, FLOAT, 1, "(#0 - #N1)"
+        # TODO: Implement unary -
+        implement FLOAT_S, :/, FLOAT, 1, "(#0 / #N1)"
+        implement FLOAT_S, :<, TYPE_NUMERIC_RETURN_BOOL, 1, "(#0 < #N1)"
+        implement FLOAT_S, :<=, TYPE_NUMERIC_RETURN_BOOL, 1, "(#0 <= #N1)"
+        # TODO: Implement <=>
+        implement FLOAT_S, :==, TYPE_NUMERIC_RETURN_BOOL, 1, "(#0 == #N1)"
+        implement FLOAT_S, :"!=", TYPE_NUMERIC_RETURN_BOOL, 1, "(#0 != #N1)"
+        implement FLOAT_S, :>, TYPE_NUMERIC_RETURN_BOOL, 1, "(#0 > #N1)"
+        implement FLOAT_S, :>=, TYPE_NUMERIC_RETURN_BOOL, 1, "(#0 >= #N1)"
+
+        implement FLOAT_S, :abs, FLOAT, 1, "fabsf(#0)"
+        implement FLOAT_S, :floor, FLOAT, 1, "floorf(#0)"
+        implement FLOAT_S, :to_f, FLOAT, 1, "#0"
+        implement FLOAT_S, :to_i, INT, 1, "((int) #0)"
+
+        implement BOOL_S, :&, TYPE_BOOL_RETURN_BOOL, 1, "(#0 & #B1)"
+        implement BOOL_S, :"&&", TYPE_BOOL_RETURN_BOOL, 1, "(#0 && #B1)"
+        implement BOOL_S, :"^", TYPE_BOOL_RETURN_BOOL, 1, "(#0 ^ #B1)"
+        implement BOOL_S, :|, TYPE_BOOL_RETURN_BOOL, 1, "(#0 | #B1)"
+        implement BOOL_S, :"||", TYPE_BOOL_RETURN_BOOL, 1, "(#0 || #B1)"
+    end
+end

data/lib/ruby_core/interpreter.rb

@@ -0,0 +1,16 @@
+module Ikra
+    module RubyIntegration
+        # No need to do type inference or code generation, if a method is called on an
+        # on an instance of one of these classes.
+        INTERPRETER_ONLY_CLS_OBJ = [Ikra::Symbolic.singleton_class]
+
+
+        def self.is_interpreter_only?(type)
+            if !type.is_a?(Types::ClassType)
+                return false
+            end
+
+            return INTERPRETER_ONLY_CLS_OBJ.include?(type.cls)
+        end
+    end
+end

data/lib/ruby_core/math.rb

@@ -0,0 +1,32 @@
+module Ikra
+    module RubyIntegration
+        MATH = Math.singleton_class.to_ikra_type
+
+        implement MATH, :acos, FLOAT, 1, "acosf(#F0)", pass_self: false
+        implement MATH, :acosh, FLOAT, 1, "acoshf(#F0)", pass_self: false
+        implement MATH, :asin, FLOAT, 1, "asinf(#F0)", pass_self: false
+        implement MATH, :asinh, FLOAT, 1, "asinhf(#F0)", pass_self: false
+        implement MATH, :atan, FLOAT, 1, "atanf(#F0)", pass_self: false
+        implement MATH, :atan2, FLOAT, 2, "atan2f(#F0, #F1)", pass_self: false
+        implement MATH, :atanh, FLOAT, 1, "atanhf(#F0)", pass_self: false
+        implement MATH, :cbrt, FLOAT, 1, "cbrtf(#F0)", pass_self: false
+        implement MATH, :cos, FLOAT, 1, "cosf(#F0)", pass_self: false
+        implement MATH, :cosh, FLOAT, 1, "coshf(#F0)", pass_self: false
+        implement MATH, :erf, FLOAT, 1, "erff(#F0)", pass_self: false
+        implement MATH, :erfc, FLOAT, 1, "erfcf(#F0)", pass_self: false
+        implement MATH, :exp, FLOAT, 1, "expf(#F0)", pass_self: false
+        implement MATH, :gamma, FLOAT, 1, "tgammaf(#F0)", pass_self: false
+        implement MATH, :hypot, FLOAT, 2, "hypotf(#F0, #F1)", pass_self: false
+        implement MATH, :ldexp, FLOAT, 2, "ldexpf(#F0, #F1)", pass_self: false
+        implement MATH, :lgamma, FLOAT, 1, "lgammaf(#F0)", pass_self: false
+        implement MATH, :log, FLOAT, 1, "logf(#F0)", pass_self: false
+        implement MATH, :log10, FLOAT, 1, "log10f(#F0)", pass_self: false
+        implement MATH, :log2, FLOAT, 1, "log2f(#F0)", pass_self: false
+        implement MATH, :sin, FLOAT, 1, "sinf(#F0)", pass_self: false
+        implement MATH, :sinh, FLOAT, 1, "sinhf(#F0)", pass_self: false
+        implement MATH, :sqrt, FLOAT, 1, "sqrtf(#F0)", pass_self: false
+        implement MATH, :tan, FLOAT, 1, "tanf(#F0)", pass_self: false
+        implement MATH, :tanh, FLOAT, 1, "tanhf(#F0)", pass_self: false
+    end
+end
+

data/lib/ruby_core/ruby_integration.rb

@@ -0,0 +1,256 @@
+require_relative "../types/types"
+
+module Ikra
+    module RubyIntegration
+        INT = Types::UnionType.create_int
+        FLOAT = Types::UnionType.create_float
+        BOOL = Types::UnionType.create_bool
+
+        INT_S = INT.singleton_type
+        FLOAT_S = FLOAT.singleton_type
+        BOOL_S = BOOL.singleton_type
+
+        class Implementation
+            attr_reader :num_params
+            attr_reader :implementation
+            attr_reader :pass_self
+            attr_reader :return_type
+
+            # If set to true, all argument should have a singleton type. This is required for
+            # operations on ArrayCommands (e.g., pzip).
+            attr_reader :expect_singleton_args
+
+            def initialize(
+                num_params:, 
+                return_type:, 
+                implementation:, 
+                pass_self: true, 
+                expect_singleton_args: false)
+
+                @num_params = num_params
+                @implementation = implementation
+                @pass_self = pass_self
+                @return_type = return_type
+                @expect_singleton_args = expect_singleton_args
+            end
+        end
+
+        @@impls = {}
+        @@impls.default_proc = proc do |hash, key|
+            hash[key] = {}
+        end
+
+        def self.implement(
+            rcvr_type, 
+            method_name, 
+            return_type, 
+            num_params, 
+            impl, 
+            pass_self: true, 
+            expect_singleton_args: false)
+
+            @@impls[rcvr_type][method_name] = Implementation.new(
+                num_params: num_params,
+                return_type: return_type,
+                implementation: impl,
+                pass_self: pass_self,
+                expect_singleton_args: expect_singleton_args)
+        end
+
+        def self.has_implementation?(rcvr_type, method_name)
+            return find_impl(rcvr_type, method_name) != nil
+        end
+
+        def self.should_pass_self?(rcvr_type, method_name)
+            return find_impl(rcvr_type, method_name).pass_self
+        end
+
+        def self.expect_singleton_args?(rcvr_type, method_name)
+            return find_impl(rcvr_type, method_name).expect_singleton_args
+        end
+
+        # Returns the implementation (CUDA source code snippet) for a method with name 
+        # [method_name] defined on [rcvr_type].
+        #
+        # This method also receives references to the receiver AST node and to AST nodes for
+        # arguments. In most cases, these AST nodes are directly translated to source code
+        # using `translator` (a [Translator::ASTTranslator]). However, if an implementation
+        # is given through a block ([Proc]), the implementation might decide to not use the
+        # translation (e.g., translation of parallel sections in host sections).
+        #
+        # [receiver] must have a singleton type.
+        def self.get_implementation(receiver, method_name, arguments, translator, result_type)
+            impl = find_impl(receiver.get_type.singleton_type, method_name)
+            source = impl.implementation
+
+            if source.is_a?(Proc)
+                source = source.call(receiver, method_name, arguments, translator, result_type)
+            end
+
+            sub_code = arguments.map do |arg| arg.accept(translator.expression_translator) end
+            sub_types = arguments.map do |arg| arg.get_type end
+
+            if impl.pass_self
+                sub_code.insert(0, receiver.accept(translator.expression_translator))
+                sub_types.insert(0, receiver.get_type)
+            end
+
+            sub_indices = (0...source.length).find_all do |index| 
+                source[index] == "#" 
+            end
+            substitutions = {}
+            sub_indices.each do |index|
+                if source[index + 1] == "F"
+                    # Insert float
+                    arg_index = source[index + 2].to_i
+
+                    if arg_index >= sub_code.size
+                        raise ArgumentError.new("Argument missing: Expected at least #{arg_index + 1}, found #{sub_code.size}")
+                    end
+
+                    substitutions["\#F#{arg_index}"] = code_argument(FLOAT_S, sub_types[arg_index], sub_code[arg_index])
+                elsif source[index + 1] == "I"
+                    # Insert integer
+                    arg_index = source[index + 2].to_i
+
+                    if arg_index >= sub_code.size
+                        raise ArgumentError.new("Argument missing: Expected at least #{arg_index + 1}, found #{sub_code.size}")
+                    end
+
+                    substitutions["\#I#{arg_index}"] = code_argument(INT_S, sub_types[arg_index], sub_code[arg_index])
+                elsif source[index + 1] == "B"
+                    # Insert integer
+                    arg_index = source[index + 2].to_i
+
+                    if arg_index >= sub_code.size
+                        raise ArgumentError.new("Argument missing: Expected at least #{arg_index + 1}, found #{sub_code.size}")
+                    end
+
+                    substitutions["\#B#{arg_index}"] = code_argument(BOOL_S, sub_types[arg_index], sub_code[arg_index])
+                elsif source[index + 1] == "N"
+                    # Numeric, coerce integer to float
+                    arg_index = source[index + 2].to_i
+
+                    if arg_index >= sub_code.size
+                        raise ArgumentError.new("Argument missing: Expected at least #{arg_index + 1}, found #{sub_code.size}")
+                    end
+
+                    if sub_types[arg_index].include?(FLOAT_S)
+                        expected_type = FLOAT_S
+                    else
+                        expected_type = INT_S
+                    end
+
+                    substitutions["\#N#{arg_index}"] = code_argument(expected_type, sub_types[arg_index], sub_code[arg_index])
+                else
+                    arg_index = source[index + 1].to_i
+
+                    if arg_index >= sub_code.size
+                        raise ArgumentError.new("Argument missing: Expected at least #{arg_index + 1}, found #{sub_code.size}")
+                    end
+
+                    substitutions["\##{arg_index}"] = sub_code[arg_index]
+                end
+            end
+
+            substitutions.each do |key, value|
+                # Do not use `gsub!` here!
+                source = source.gsub(key, value)
+            end
+            
+            return source
+        end
+
+        # Retrieves the return type of a method invocation for receiver type [rcvr_type],
+        # selector [method_name], and argument types [arg_types].
+        #
+        # In addition, this method accepts an optional parameter [node] containing the send node
+        # (abstract syntax tree node). That node is passed to type inference procs. This is 
+        # required for symbolic execution of array commands inside host sections.
+        def self.get_return_type(rcvr_type, method_name, *arg_types, send_node: nil)
+            return_type = find_impl(rcvr_type, method_name).return_type
+            num_params = find_impl(rcvr_type, method_name).num_params
+
+            if return_type.is_a?(Proc)
+                # Return type depends on argument types
+                if num_params.is_a?(Fixnum) && num_params != arg_types.size
+                    raise ArgumentError.new(
+                        "#{num_params} arguments expected but #{arg_types.size} given")
+                elsif num_params.is_a?(Range) && !num_params.include?(arg_types.size)
+                    raise ArgumentError.new(
+                        "#{num_params} arguments expected but #{arg_types.size} given")
+                else
+                    if send_node == nil
+                        return return_type.call(rcvr_type, *arg_types)
+                    else
+                        return return_type.call(rcvr_type, *arg_types, send_node: send_node)
+                    end
+                end
+            else
+                return return_type
+            end
+        end
+
+        private
+
+        def self.code_argument(expected_type, arg_type, code)
+            if arg_type.is_singleton?
+                if expected_type != arg_type.singleton_type
+                    # Try to cast
+                    return "((#{expected_type.to_c_type}) #{code})"
+                else
+                    return code
+                end
+            else
+                # Extract from union type
+                result = StringIO.new
+
+                result << "({ union_t arg = #{code};\n"
+                result << "    #{expected_type.to_c_type} result;\n"
+                result << "    switch (arg.class_id) {\n"
+
+                for type in arg_type
+                    c_type = expected_type.to_c_type
+                    result << "        case #{type.class_id}:\n"
+                    # TODO: This works only for primitive types
+                    result << "            result = (#{c_type}) arg.value.#{type.to_c_type}_;\n"
+                    result << "            break;\n"
+                end
+
+                result << "        default:\n"
+                result << "            // TODO: throw exception\n"
+                result << "    }\n"
+                result << "    result;\n"
+                result << "})"
+
+                return result.string
+            end
+        end
+
+        def self.find_impl(rcvr_type, method_name)
+            if @@impls.include?(rcvr_type) && @@impls[rcvr_type].include?(method_name)
+                return @@impls[rcvr_type][method_name]
+            else
+                # Evaluate blocks
+                for type_or_block in @@impls.keys
+                    if type_or_block.is_a?(Proc)
+                        if type_or_block.call(rcvr_type)
+                            if @@impls[type_or_block].include?(method_name)
+                                return @@impls[type_or_block][method_name]
+                            end
+                        end
+                    end
+                end
+
+                # No implementation found
+                return nil
+            end
+        end
+    end
+end
+
+require_relative "core"
+require_relative "math"
+require_relative "array"
+require_relative "array_command"
+require_relative "interpreter"

data/lib/symbolic/host_section.rb

@@ -0,0 +1,115 @@
+require_relative "../ast/host_section_builder"
+
+module Ikra
+    module Symbolic
+        # The return value of a host section. For the moment, every host section can only have
+        # one result.
+        class ArrayHostSectionCommand
+            include ArrayCommand
+
+            attr_reader :block
+            attr_reader :section_input
+
+            def initialize(*section_input, &block)
+                @block = block
+                @section_input = section_input
+            end
+
+            def size
+                execute
+                return @result.size
+            end
+
+            # Returns the abstract syntax tree for this section.
+            def block_def_node
+                if @ast == nil
+                    # Get array of block parameter names
+                    block_params = block.parameters.map do |param|
+                        param[1]
+                    end
+
+                    parser_local_vars = command_binding.local_variables + block_params
+                    source = Parsing.parse_block(block, parser_local_vars)
+                    @ast = AST::BlockDefNode.new(
+                        parameters: block_params,
+                        ruby_block: block,      # necessary to get binding
+                        body: AST::HostSectionBuilder.from_parser_ast(source))
+                end
+
+                return @ast
+            end
+
+            def command_translator_class
+                return Translator::HostSectionCommandTranslator
+            end
+
+            class Binding
+                def local_variables
+
+                end
+            end
+        end
+
+        # An array that that is referenced using C++/CUDA expressions. Such an array does not
+        # necessarily have to be present in the Ruby interpreter. Its size does also not have to
+        # be known at compile time.
+        class ArrayInHostSectionCommand
+            include ArrayCommand
+            
+            attr_accessor :target
+            attr_accessor :base_type
+
+            def initialize(target, base_type, block_size: DEFAULT_BLOCK_SIZE)
+                super(block_size: block_size)
+
+                if base_type == nil
+                    raise AssertionError.new("base_type missing")
+                end
+
+                # One thread per array element
+                @input = [SingleInput.new(command: target, pattern: :tid)]
+                @base_type = base_type
+            end
+            
+            def size
+                # Size is not known at compile time. Return a source code string here.
+                return "#{input.first.command}->size()"
+            end
+
+            # TODO: Support multiple dimensions
+            def dimensions
+                return [size]
+            end
+
+            def ==(other)
+                return super(other) && base_type == other.base_type
+            end
+        end
+
+        class FixedSizeArrayInHostSectionCommand < ArrayInHostSectionCommand
+            include ArrayCommand
+
+            attr_accessor :target
+            attr_accessor :base_type
+            attr_accessor :dimensions
+
+            def initialize(target, base_type, dimensions, block_size: DEFAULT_BLOCK_SIZE)
+                super(target, base_type, block_size: block_size)
+
+                @dimensions = dimensions
+            end
+
+            def size
+                return dimensions.reduce(:*)
+            end
+
+            def ==(other)
+                return super(other) && dimensions == other.dimensions
+            end
+        end
+
+        def self.host_section(*section_input, &block)
+            return ArrayHostSectionCommand.new(*section_input, &block)
+        end
+    end
+end