ikra 0.0.1 → 0.0.2

data/lib/types/inference/clear_types_visitor.rb

@@ -0,0 +1,11 @@
+module Ikra
+    module TypeInference
+        class ClearTypesVisitor < AST::Visitor
+            def visit_node(node)
+                if node.respond_to?(:get_type)
+                    node.get_type.clear!
+                end
+            end
+        end
+    end
+end

data/lib/types/inference/command_inference.rb

@@ -0,0 +1,101 @@
+module Ikra
+    module TypeInference
+        class CommandInference < Symbolic::Visitor
+            def self.process_command(command)
+                return command.accept(CommandInference.new)
+            end
+
+            # Processes a parallel section, i.e., a [BlockDefNode]. Performs the following steps:
+            # 1. Gather parameter types and names in a hash map.
+            # 2. Set lexical variables on [BlockDefNode].
+            # 3. Perform type inference, i.e., annotate [BlockDefNode] AST with types.
+            # 4. Return result type of the block.
+            def process_block(
+                block_def_node:, 
+                lexical_variables: {}, 
+                block_parameters:)
+
+                # Build hash of parameter name -> type mappings
+                block_parameter_types = {}
+                for variable in block_parameters
+                    block_parameter_types[variable.name] = variable.type
+                end
+
+                parameter_types_string = "[" + block_parameter_types.map do |id, type| "#{id}: #{type}" end.join(", ") + "]"
+                Log.info("Type inference for block with input types #{parameter_types_string}")
+
+                # Add information to block_def_node
+                block_def_node.parameters_names_and_types = block_parameter_types
+
+                # Lexical variables
+                lexical_variables.each do |name, value|
+                    block_def_node.lexical_variables_names_and_types[name] = value.ikra_type.to_union_type
+                end
+
+                # Type inference
+                type_inference_visitor = TypeInference::Visitor.new
+                return_type = type_inference_visitor.process_block(block_def_node)
+
+                return return_type
+            end
+
+            # Processes all input commands. This is similar to `translate_entire_input`, but it
+            # performs only type inference and does not generate any source code.
+            def process_entire_input(command)
+                input_parameters = command.input.each_with_index.map do |input, index|
+                    input.get_parameters(
+                        parent_command: command,
+                        # Assuming that every input consumes exactly one parameter
+                        start_eat_params_offset: index)
+                end
+
+                return input_parameters.reduce(:+)
+            end
+
+            # Process block and dependent computations. This method is used for all array
+            # commands that do not have a separate Visitor method.
+            def visit_array_command(command)
+                return process_block(
+                    block_def_node: command.block_def_node,
+                    lexical_variables: command.lexical_externals,
+                    block_parameters: process_entire_input(command))
+            end
+
+            def visit_array_in_host_section_command(command)
+                return command.base_type
+            end
+
+            def visit_array_identity_command(command)
+                return command.base_type
+            end
+
+            def visit_array_index_command(command)
+                num_dims = command.dimensions.size
+
+                if num_dims > 1
+                    # Build Ikra struct type
+                    zipped_type_singleton = Types::ZipStructType.new(
+                        *([Types::UnionType.create_int] * command.dimensions.size))
+                    return zipped_type_singleton.to_union_type
+                else
+                    return Types::UnionType.create_int
+                end
+            end
+
+            def visit_array_zip_command(command)
+                input_types = command.input.each_with_index.map do |input, index|
+                    input.get_parameters(
+                        parent_command: command,
+                        # Assuming that every input consumes exactly one parameter
+                        start_eat_params_offset: index).map do |variable|
+                            variable.type
+                        end
+                end.reduce(:+)
+
+                # Build Ikra struct type
+                zipped_type_singleton = Types::ZipStructType.new(*input_types)
+                return zipped_type_singleton.to_union_type
+            end
+        end
+    end
+end

data/lib/types/inference/input_inference.rb

@@ -0,0 +1,62 @@
+module Ikra
+    module Symbolic
+        class Input
+            def get_parameters(**kwargs)
+                raise NotImplementedError.new
+            end
+        end
+
+        class SingleInput < Input
+            def get_parameters(parent_command:, start_eat_params_offset: 0)
+                return [Translator::Variable.new(
+                    name: parent_command.block_parameter_names[start_eat_params_offset],
+                    type: command.result_type)]
+            end
+        end
+
+        class ReduceInput < SingleInput
+            def get_parameters(parent_command:, start_eat_params_offset: 0)
+                # TODO: Fix type inference (sometimes type has to be expanded)
+
+                return [
+                    Translator::Variable.new(
+                        name: parent_command.block_parameter_names[start_eat_params_offset],
+                        type: command.result_type),
+                    Translator::Variable.new(
+                        name: parent_command.block_parameter_names[start_eat_params_offset + 1],
+                        type: command.result_type)]
+            end
+        end
+
+        class StencilArrayInput < Input
+            def get_parameters(parent_command:, start_eat_params_offset: 0)
+                # Parameters are allocated in a constant-sized array
+
+                return [Translator::Variable.new(
+                    name: parent_command.block_parameter_names[start_eat_params_offset],
+                    type: command.result_type.to_array_type)]
+            end
+        end
+
+        class StencilSingleInput < Input
+            def get_parameters(parent_command:, start_eat_params_offset: 0)
+                # Pass separate parameters
+
+                # Count number of parameters
+                num_parameters = parent_command.offsets.size
+
+                # Take return type from previous computation
+                parameters = []
+                for index in start_eat_params_offset...(start_eat_params_offset + num_parameters)
+                    parameters.push(Translator::Variable.new(
+                        name: parent_command.block_parameter_names[index],
+                        type: command.result_type))
+                end
+
+                return parameters
+            end
+        end
+    end
+    
+
+end

data/lib/types/{object_tracer.rb → inference/object_tracer.rb}

@@ -1,9 +1,8 @@
 require "set"
 require "ffi"
-require_relative "../entity"
-require_relative "class_type"
-require_relative "../symbolic/symbolic"
-require_relative "../translator/command_translator"
+require_relative "../../entity"
+require_relative "../../symbolic/symbolic"
+require_relative "../../translator/commands/command_translator"
 
 module Ikra
     module TypeInference
@@ -48,10 +47,10 @@ module Ikra
 
                         object.instance_variables.each do |inst_var_name|
                             value = object.instance_variable_get(inst_var_name)
-                            value_type = value.class.to_ikra_type
+                            value_type = value.ikra_type
 
                             # Gather type information
-                            object.class.to_ikra_type.inst_vars_types[inst_var_name].expand_with_singleton_type(value_type)
+                            object.ikra_type.inst_vars_types[inst_var_name].add(value_type)
 
                             if value.class.include?(Entity)
                                 # Keep tracing this object

data/lib/types/inference/ruby_extension.rb

@@ -0,0 +1,35 @@
+# No explicit `require`s. This file should be includes via types.rb
+
+require "set"
+
+class Fixnum
+    class << self
+        def to_ikra_type
+            Ikra::Types::PrimitiveType::Int
+        end
+    end
+end
+
+class Float
+    class << self
+        def to_ikra_type
+            Ikra::Types::PrimitiveType::Float
+        end
+    end
+end
+
+class TrueClass
+    class << self
+        def to_ikra_type
+            Ikra::Types::PrimitiveType::Bool
+        end
+    end
+end
+
+class FalseClass
+    class << self
+        def to_ikra_type
+            Ikra::Types::PrimitiveType::Bool
+        end
+    end
+end

data/lib/types/inference/symbol_table.rb

@@ -0,0 +1,131 @@
+# No explicit `require`s. This file should be includes via types.rb
+
+module Ikra
+    module TypeInference
+        # This is a symbol table that stores type information about variables. Ruby has a "flat" 
+        # variable scope in method, i.e., variables defined in loop bodies, if statement bodies, 
+        # or begin nodes are also visible outside of them.
+        #
+        # Every method/block has its own symbol table.
+        class SymbolTable
+
+            # Represents a lexical or local variable. Variables have a type and can read and/or
+            # written, all of which is stored in this class.
+            class Variable
+                attr_reader :type
+
+                # Determines the kind of the variables: lexial or local
+                attr_reader :kind
+
+                attr_accessor :read
+                attr_accessor :written
+                
+                def initialize(type: Types::UnionType.new, kind: :local)
+                    @type = type.dup
+                    @kind = kind
+                    @read = false
+                    @written = false
+                end
+            end
+
+            attr_reader :return_type
+
+            # For debug purposes
+            attr_reader :symbols
+
+            def initialize
+                # This is a mapping from variable names to Variable instances.
+                @symbols = {}
+                @return_type = Types::UnionType.new
+            end
+
+            def clear!
+                @symbols = {}
+            end
+
+            def [](variable_name)
+                if !has_variable?(variable_name)
+                    raise AssertionError.new("Variable #{variable_name} not defined")
+                end
+
+                return @symbols[variable_name].type
+            end
+
+            def read!(variable_name)
+                if !has_variable?(variable_name)
+                    raise AssertionError.new(
+                        "Variable #{variable_name} read but not found in symbol table")
+                end
+
+                @symbols[variable_name].read = true
+            end
+
+            def written!(variable_name)
+                if !has_variable?(variable_name)
+                    raise AssertionError.new(
+                        "Variable #{variable_name} written but not found in symbol table")
+                end
+
+                @symbols[variable_name].written = true
+            end
+
+            def read_variables
+                return @symbols.select do |k, v|
+                    v.read
+                end.keys
+            end
+            
+            def written_variables
+                return @symbols.select do |k, v|
+                    v.written
+                end.keys
+            end
+            
+            def read_and_written_variables
+                return read_variables + written_variables
+            end
+
+            def expand_type(variable_name, type)
+                if !has_variable?(variable_name)
+                    raise AssertionError.new(
+                        "Attempt to expand type of variable #{variable_name} but not found in " +
+                        " symbol table")
+                end
+
+                @symbols[variable_name].type.expand(type)
+            end
+
+            def expand_return_type(type)
+                @return_type.expand(type)
+            end
+
+            def return_type
+                return @return_type
+            end
+
+            # Declares a local variable. This method should be used only for regular local
+            # variables (not parameters). Does not shadow lexical variables.
+            def ensure_variable_declared(variable_name, type: Types::UnionType.new, kind: :local)
+                if !has_variable?(variable_name)
+                    declare_variable(variable_name, type: type, kind: kind)
+                else
+                    # Extend type of variable
+                    expand_type(variable_name, type)
+                end
+            end
+
+            # Declares a local variable and overwrites (shadows) existing variables
+            # (lexical variables). Use this method for method/block parameters.
+            def declare_variable(variable_name, type: Types::UnionType.new, kind: :local)
+                @symbols[variable_name] = Variable.new(type: Types::UnionType.new, kind: kind)
+                expand_type(variable_name, type)
+            end
+
+            private
+
+            def has_variable?(variable_name)
+                return @symbols.include?(variable_name)
+            end
+        end
+    end
+end

data/lib/types/types.rb

@@ -0,0 +1,14 @@
+require_relative "types/ruby_type"
+require_relative "types/array_type"
+require_relative "types/class_type"
+require_relative "types/primitive_type"
+require_relative "types/union_type"
+require_relative "types/struct_type"
+require_relative "types/array_command_type"
+
+require_relative "inference/object_tracer"
+require_relative "inference/ruby_extension"
+require_relative "inference/symbol_table"
+require_relative "inference/ast_inference"
+require_relative "inference/input_inference"
+require_relative "inference/command_inference"

data/lib/types/types/array_command_type.rb

@@ -0,0 +1,123 @@
+require "weakref"
+
+module Ikra
+    module Symbolic
+        module ArrayCommand
+            include Types::RubyType
+
+            def self.included(base)
+                base.extend(ClassMethods)
+            end
+
+            module ClassMethods
+                # TODO: Check what was wrong with the subclassed Hash...
+                class WeakCache
+                    def initialize
+                        @values = []
+                    end
+
+                    def get_value(value)
+                        @values.delete_if do |obj|
+                            begin
+                                if obj == value
+                                    return obj.__getobj__
+                                end
+                            rescue WeakRef::RefError
+                                true
+                            end
+                        end
+
+                        raise RuntimeError.new("Value not found")
+                    end
+
+                    def add_value(value)
+                        @values.push(WeakRef.new(value))
+                    end
+
+                    def include?(value)
+                        @values.delete_if do |obj|
+                            begin
+                                if obj == value
+                                    return true
+                                end
+                            rescue WeakRef::RefError
+                                true
+                            end
+                        end
+
+                        return false
+                    end
+                end
+
+                class NormalCache
+                    def initialize
+                        @values = []
+                    end
+
+                    def get_value(value)
+                        for el in @values
+                            if el == value
+                                return el
+                            end
+                        end
+
+                        raise RuntimeError.new("Value not found")
+                    end
+
+                    def add_value(value)
+                        @values.push(value)
+                    end
+
+                    def include?(value)
+                        return @values.include?(value)
+                    end
+                end
+
+                # Ensure that ArrayCommands are singletons. Otherwise, we have a problem, because
+                # two equal commands can have different class IDs.
+                def new(*args, **kwargs, &block)
+                    if @cache == nil
+                        @cache = WeakCache.new
+                    end
+
+                    new_command = super
+
+                    if @cache.include?(new_command)
+                        return @cache.get_value(new_command)
+                    else
+                        @cache.add_value(new_command)
+                        return new_command
+                    end
+                end
+            end
+
+            def to_c_type
+                return "#{Translator::ArrayCommandStructBuilder.struct_name(self)} *"
+            end
+
+            def to_ffi_type
+                # TODO: This method is probably not required?
+                return :pointer
+            end
+
+            def to_ruby_type
+                return ArrayCommand
+            end
+
+            # Every [ArrayCommand] has itself as an Ikra type. This integrates well with the
+            # current type inference approach and `ruby_core`.
+            def ikra_type
+                return self
+            end
+
+            def result_type
+                # Result cache should be cached, just like the result itself
+                if @result_type == nil
+                    @result_type = TypeInference::CommandInference.process_command(self)
+                end
+
+                return @result_type
+            end
+        end
+    end
+end