ikra 0.0.1 → 0.0.2

data/lib/ast/method_definition.rb

@@ -1,37 +0,0 @@
-require "set"
-require_relative "../scope"
-
-module Ikra
-    module AST
-        class MethodDefinition
-            attr_accessor :type                         # receiver type
-            attr_accessor :selector
-            attr_accessor :ast
-            attr_accessor :return_type
-            attr_accessor :callers                      # method definitions calling this method
-            attr_accessor :symbol_table
-            attr_accessor :binding                      # needed for resolving constants
-            attr_accessor :local_variables              # local variables defined in the method (name -> type)
-            attr_accessor :lexical_variables            # lexical variables (defined outside; name -> type)
-            attr_accessor :accessed_lexical_variables   # accessed lexical variables, only these variables are transferred to the GPU. TODO: Do we still need this? This is now determined in symbolic.rb
-            attr_accessor :parameter_variables          # parameters of the method/block (name -> type)
-
-            def initialize(type:, selector:, parameter_variables:, return_type:, ast:)
-                @type = type
-                @selector = selector
-                @parameter_variables = parameter_variables
-                @return_type = return_type
-                @ast = ast
-                @callers = Set.new
-                @symbol_table = Scope.new
-                @local_variables = {}
-                @lexical_variables = {}             # optional
-                @accessed_lexical_variables = {}    # optional
-            end
-
-            def parameter_names
-                type.method_parameters(selector)
-            end
-        end
-    end
-end

data/lib/ast/translator.rb

@@ -1,264 +0,0 @@
-require_relative "nodes.rb"
-require_relative "../translator/translator"
-
-# Rule: every statement ends with newline
-
-module Ikra
-    module AST
-        class Node
-            @@next_temp_identifier_id = 0
-
-            def translate_statement
-                translate_expression + ";\n"
-            end
-            
-            protected
-            
-            def statements_as_expression(str)
-                "[&]{ #{str} }()"
-            end
-            
-            def indent_block(str)
-                str.split("\n").map do |line| "    " + line end.join("\n")
-            end
-
-            def wrap_in_c_block(str)
-                "{\n" + indent_block(str) + "\n}\n"
-            end
-
-            def temp_identifier_id
-                @@next_temp_identifier_id += 1
-                @@next_temp_identifier_id
-            end
-
-            # Generates code that assigns the value of a node to a newly-defined variable.
-            def define_assign_variable(name, node)
-                type = node.get_type.to_c_type
-                "#{type} #{name} = #{node.translate_expression};"
-            end
-        end
-        
-        class RootNode
-            def translate_statement
-                child.translate_statement
-            end
-
-            def translate_expression
-                child.translate_expression
-            end
-        end
-
-        class ConstNode
-            def translate_expression
-                raise "Not implemented"
-            end
-        end
-
-        class LVarReadNode
-            def translate_expression
-                identifier.to_s
-            end
-        end
-        
-        class LVarWriteNode
-            def translate_expression
-                "#{identifier.to_s} = #{value.translate_expression}"
-            end
-        end
-        
-        class IVarReadNode
-            def translate_expression
-                array_identifier = class_owner.to_ikra_type.inst_var_array_name(identifier)
-                "#{Translator::Constants::ENV_IDENTIFIER}->#{array_identifier}[#{Constants::SELF_IDENTIFIER}]"
-            end
-        end
-
-        class IntNode
-            def translate_expression
-                value.to_s
-            end
-        end
-        
-        class FloatNode
-            def translate_expression
-                value.to_s
-            end
-        end
-        
-        class BoolNode
-            def translate_expression
-                value.to_s
-            end
-        end
-        
-        class ForNode
-            def translate_statement
-                loop_header = "for (#{iterator_identifier.to_s} = #{range_from.translate_expression}; #{iterator_identifier.to_s} <= #{range_to.translate_expression}; #{iterator_identifier.to_s}++)"
-                loop_header + "\n" + body_stmts.translate_statement + "#{iterator_identifier.to_s}--;\n"
-            end
-            
-            def translate_expression
-                # TODO: return value should be range
-                loop_header = "for (#{iterator_identifier.to_s} = #{range_from.translate_expression}; #{iterator_identifier.to_s} <= #{range_to.translate_expression}; #{iterator_identifier.to_s}++)"
-                full_loop = loop_header + "\n" + body_stmts.translate_statement + "#{iterator_identifier.to_s}--;\nreturn 0;"
-                statements_as_expression(full_loop)
-            end
-        end
-        
-        class BreakNode
-            def translate_expression
-                raise "Not implemented yet"
-            end
-            
-            def translate_statement
-                "break;\n"
-            end
-        end
-        
-        class IfNode
-            def translate_statement
-                header = "if (#{condition.translate_expression})\n"
-                
-                if false_body_stmts == nil
-                    header + true_body_stmts.translate_statement
-                else
-                    header + true_body_stmts.translate_statement + "else\n" + false_body_stmts.translate_statement
-                end
-            end
-            
-            def translate_expression
-                header = "if (#{condition.translate_expression})\n"
-                true_body_translated = nil
-                false_body_translated = nil
-                
-                if true_body_stmts.is_begin_node?
-                    true_body_translated = true_body_stmts.translate_statement_last_returns
-                else
-                    true_body_translated = "return " + true_body_stmts.translate_expression + ";\n"
-                end
-                
-                if false_body_stmts != nil
-                    # Can be begin node or anything else
-                    if false_body_stmts.is_begin_node?
-                        false_body_translated = false_body_stmts.translate_statement_last_returns
-                    else
-                        false_body_translated = "return " + false_body_stmts.translate_expression + ";\n"
-                    end
-                end
-                
-                if false_body_translated == nil
-                    statements_as_expression(header + true_body_translated)
-                else
-                    statements_as_expression(header + true_body_translated + "else\n" + false_body_translated)
-                end
-            end
-        end
-        
-        class BeginNode
-            def translate_statement
-                if body_stmts.size == 0
-                    return ""
-                end
-                
-                body_translated = body_stmts.map do |stmt|
-                    stmt.translate_statement
-                end.join("")
-                
-                wrap_in_c_block(body_translated)
-            end
-            
-            def translate_statement_last_returns
-                if body_stmts.size == 0
-                    raise "Cannot return empty BeginNode"
-                end
-                
-                body_translated = BeginNode.new(body_stmts[0...-1]).translate_statement
-                body_translated + "return #{body_stmts.last.translate_expression};\n"
-                wrap_in_c_block(body_translated)
-            end
-            
-            def translate_expression
-                if body_stmts.size == 0
-                    raise "Empty BeginNode cannot be an expression"
-                elsif body_stmts.size == 1
-                    # Preserve brackets
-                    "(#{body_stmts.first.translate_expression})"
-                else
-                    # Wrap in lambda
-                    # Do not worry about scope of varibles, they will all be declared at the beginning of the function
-                    statements_as_expression(translate_statement_last_returns)
-                end
-            end
-        end
-        
-        class SendNode
-            BinarySelectors = [:+, :-, :*, :/, :%, :<, :<=, :>, :>=, :==, :!=, :&, :'&&', :|, :'||', :^]
-            
-            def translate_expression
-                if BinarySelectors.include?(selector)
-                    if arguments.size != 1
-                        raise "Expected 1 argument for binary selector (#{arguments.size} given)"
-                    end
-                    
-                    "(#{receiver.translate_expression} #{selector.to_s} #{arguments.first.translate_expression})"
-                else
-                    if receiver.get_type.is_singleton? and
-                            receiver.get_type.singleton_type.to_ruby_type.singleton_methods.include?(("_ikra_c_" + selector.to_s).to_sym)
-                        # TODO: support multiple types for receiver
-                        receiver.get_type.singleton_type.to_ruby_type.send(("_ikra_c_" + selector.to_s).to_sym, receiver.translate_expression)
-                    else
-                        # TODO: generate argument code only once
-
-                        if receiver.get_type.is_singleton?
-                            self_argument = []
-                            if receiver.get_type.singleton_type.should_generate_type?
-                                self_argument = [receiver]
-                            end
-
-                            args = ([Translator::Constants::ENV_IDENTIFIER] + (self_argument + arguments).map do |arg|
-                                arg.translate_expression
-                            end).join(", ")
-                            
-                            "#{receiver.get_type.singleton_type.mangled_method_name(selector)}(#{args})"
-                        else
-                            # Polymorphic case
-                            # TODO: This is not an expression anymore!
-                            poly_id = temp_identifier_id
-                            receiver_identifier = "_polytemp_recv_#{poly_id}"
-                            result_identifier = "_polytemp_result_#{poly_id}"
-                            header = "#{define_assign_variable(receiver_identifier, receiver)}\n#{get_type.to_c_type} #{result_identifier};\nswitch (#{receiver_identifier}.class_id)\n"
-                            case_statements = []
-
-                            receiver.get_type.types.each do |type|
-                                self_argument = []
-                                if type.should_generate_type?
-                                    # No need to pass type as subtypes are regarded as entirely new types
-                                    self_argument = ["#{receiver_identifier}.object_id"]
-                                end
-
-                                args = ([Translator::Constants::ENV_IDENTIFIER] + self_argument + arguments.map do |arg|
-                                    arg.translate_expression
-                                end).join(", ")
-                                
-                                case_statements.push("case #{type.class_id}: #{result_identifier} = #{type.mangled_method_name(selector)}(#{args}); break;")
-                            end
-
-                            # TODO: compound statements only work with the GNU C++ compiler
-                            "(" + wrap_in_c_block(header + wrap_in_c_block(case_statements.join("\n")) + result_identifier + ";")[0..-2] + ")"
-                        end
-                    end
-                end
-            end
-        end
-
-        class ReturnNode
-            def translate_expression
-                raise "ReturnNode is never an expression"
-            end
-
-            def translate_statement
-                "return #{value.translate_expression};\n"
-            end
-        end
-    end
-end

data/lib/resources/cuda/kernel_launcher.cpp

@@ -1,28 +0,0 @@
-extern "C" EXPORT /*{result_type}*/ *launch_kernel(environment_t */*{host_env}*/)
-{
-    printf("kernel launched\n");
-    
-    /* Modify host environment to contain device pointers addresses */
-    /*{copy_env}*/
-
-    /* Allocate device environment and copy over struct */
-    environment_t */*{dev_env}*/;
-    checkCudaErrors(cudaMalloc(&/*{dev_env}*/, sizeof(environment_t)));
-    checkCudaErrors(cudaMemcpy(/*{dev_env}*/, /*{host_env}*/, sizeof(environment_t), cudaMemcpyHostToDevice));
-
-    /*{result_type}*/ *host_result = (/*{result_type}*/ *) malloc(sizeof(/*{result_type}*/) * /*{result_size}*/);
-    /*{result_type}*/ *device_result;
-    checkCudaErrors(cudaMalloc(&device_result, sizeof(/*{result_type}*/) * /*{result_size}*/));
-    
-    dim3 dim_grid(/*{grid_dim[0]}*/, /*{grid_dim[1]}*/, /*{grid_dim[2]}*/);
-    dim3 dim_block(/*{block_dim[0]}*/, /*{block_dim[1]}*/, /*{block_dim[2]}*/);
-    
-    kernel<<<dim_grid, dim_block>>>(/*{dev_env}*/, device_result);
-
-    checkCudaErrors(cudaThreadSynchronize());
-
-    checkCudaErrors(cudaMemcpy(host_result, device_result, sizeof(/*{result_type}*/) * /*{result_size}*/, cudaMemcpyDeviceToHost));
-    checkCudaErrors(cudaFree(/*{dev_env}*/));
-
-    return host_result;
-}

data/lib/scope.rb

@@ -1,166 +0,0 @@
-require "set"
-require_relative "types/union_type"
-
-class Frame < Hash
-    def function_frame!
-        @is_function_frame = true
-    end
-
-    def is_function_frame?
-        @is_function_frame ||= false
-        @is_function_frame
-    end
-
-    def add_return_type(type)
-        if not is_function_frame?
-            raise "Return type allowed only for function frames"
-        end
-
-        if not type.is_union_type?
-            raise "Expected union type"
-        end
-
-        @return_type ||= Ikra::Types::UnionType.new
-        @return_type.expand(type)
-    end
-
-    def return_type
-        if not is_function_frame?
-            raise "Return type allowed only for function frames"
-        end
-
-        @return_type ||= Ikra::Types::UnionType.new
-        @return_type
-    end
-
-    def variable_names
-        keys
-    end
-end
-
-class Scope < Array
-    class Variable
-        attr_reader :type
-        attr_accessor :read
-        attr_accessor :written
-        
-        def initialize(type = Ikra::Types::UnionType.new)
-            @type = type
-            @read = false
-            @written = false
-        end
-    end
-    
-    def top_frame
-        last
-    end
-    
-    def previous_frame
-        self[-2]
-    end
-
-    def push_frame
-        frame = Frame.new
-        frame.default_proc = Proc.new do |hash, key|
-            hash[key] = Variable.new
-        end
-        push(frame)
-    end
-
-    def push_function_frame
-        push_frame
-        top_frame.function_frame!
-    end
-    
-    def pop_frame
-        pop
-    end
-    
-    # TODO: maybe remove?
-    def define_shadowed(name, type)
-        if top_frame.has_key?(name)
-            raise "#{name} already defined"
-        end
-        
-        top_frame[name] = Variable.new(type)
-    end
-    
-    def is_defined?(name)
-        any? do |frame|
-            frame.has_key?(name)
-        end
-    end
-    
-    def get_type(name)
-        reverse_each do |frame|
-            if frame.has_key?(name)
-                return frame[name].type
-            end
-        end
-        
-        raise "#{name} not found in symbol table"
-    end
-    
-    def declare_expand_type(name, type)
-        if not type.is_union_type?
-            raise "Expected union type"
-        end
-
-        top_frame[name].type.expand(type)
-    end
-    
-    def add_return_type(type)
-        reverse_each.detect do |fr|
-            fr.add_return_type(type)
-            return self
-        end
-
-        raise "Function frame not found"
-    end
-
-    def read!(name)
-        frame = reverse_each.detect do |fr|
-            fr.has_key?(name)
-        end
-        
-        frame[name].read = true
-    end
-    
-    def written!(name)
-        frame = reverse_each.detect do |fr|
-            fr.has_key?(name)
-        end
-        
-        frame[name].written = true
-    end
-    
-    def read_variables(frame_position)
-        frame = self[frame_position]
-        frame.select do |name, var|
-            var.read
-        end.keys
-    end
-    
-    def written_variables(frame_position)
-        frame = self[frame_position]
-        frame.select do |name, var|
-            var.written
-        end.keys
-    end
-    
-    def read_and_written_variables(frame_position = -1)
-        read_variables(frame_position) + written_variables(frame_position)
-    end
-    
-    def new_frame(&block)
-        push_frame
-        yield
-        pop_frame
-    end
-
-    def new_function_frame(&block)
-        push_function_frame
-        yield
-        pop_frame
-    end
-end