BOAST 1.0.7 → 1.0.8

data/lib/BOAST/Language/Operators.rb

@@ -4,6 +4,8 @@ module BOAST
     extend PrivateStateAccessor
     extend Intrinsics
 
+    DISCARD_OPTIONS = { :const => nil, :constant => nil, :direction => nil, :dir => nil, :align => nil }
+
     def Operator.inspect
       return "#{name}"
     end
@@ -11,9 +13,16 @@ module BOAST
     def Operator.convert(arg, type)
       return "convert_#{type.decl}( #{arg} )" if lang == CL
 
-      instruction = intrinsics[get_architecture][:CVT][get_vector_name(type)][get_vector_name(arg.type)]
-      raise "Unavailable conversion from #{get_vector_name(arg.type)} to #{get_vector_name(type)}!" if not instruction
-      return "#{instruction}( #{arg} )"
+      path = get_conversion_path(type, arg.type)
+      raise "Unavailable conversion from #{get_vector_name(arg.type)} to #{get_vector_name(type)}!" if not path
+      s = "#{arg}"
+      if path.length > 1 then
+        path.each_cons(2) { |slice|
+          instruction = intrinsics_by_vector_name(:CVT, slice[1], slice[0])
+          s = "#{instruction}( #{s} )"
+        }
+      end
+      return s
     end
 
   end
@@ -21,14 +30,11 @@ module BOAST
   class BasicBinaryOperator < Operator
 
     def BasicBinaryOperator.to_s(arg1, arg2, return_type)
-      #puts "#{arg1.class} * #{arg2.class} : #{arg1} * #{arg2}"
       if lang == C and (arg1.class == Variable and arg2.class == Variable) and (arg1.type.vector_length > 1 or arg2.type.vector_length > 1) then
-        raise "Vectors have different length: #{arg1} #{arg1.type.vector_length}, #{arg2} #{arg2.type.vector_length}" if arg1.type.vector_length != arg2.type.vector_length
-        #puts "#{arg1.type.signed} #{arg2.type.signed} #{return_type.type.signed}"
-        instruction = intrinsics[get_architecture][intr_symbol][get_vector_name(return_type.type)]
+        instruction = intrinsics(intr_symbol, return_type.type)
         raise "Unavailable operator #{symbol} for #{get_vector_name(return_type.type)}!" unless instruction
-        a1 = ( arg1.type != return_type.type ? convert(arg1, return_type.type) : "#{arg1}" )
-        a2 = ( arg2.type != return_type.type ? convert(arg2, return_type.type) : "#{arg2}" )
+        a1 = convert(arg1, return_type.type)
+        a2 = convert(arg2, return_type.type)
         return "#{instruction}( #{a1}, #{a2} )"
       else
         return basic_usage( arg1, arg2 )
@@ -37,54 +43,6 @@ module BOAST
 
   end
 
-  class Set < Operator
-
-    def Set.to_s(arg1, arg2, return_type)
-      if lang == C or lang == CL then
-        if arg1.class == Variable and arg1.type.vector_length > 1 then
-          if arg2.kind_of?( Array ) then
-            raise "Invalid array length!" unless arg2.length == arg1.type.vector_length
-            return "#{arg1} = (#{arg1.type.decl})( #{arg2.join(", ")} )" if lang == CL
-
-            instruction = intrinsics[get_architecture][:SET][get_vector_name(arg1.type)]
-            if not instruction then
-              instruction = intrinsics[get_architecture][:SET_LANE][get_vector_name(arg1.type)]
-              raise "Unavailable operator set for #{get_vector_name(arg1.type)}!" unless instruction
-              s = "#{arg1}"
-              arg2.each_with_index { |v,i|
-                s = "#{instruction}(#{v}, #{s}, #{i})"
-              }
-            return "#{arg1} = #{s}"
-            else
-              return "#{arg1} = #{instruction}( #{arg2.join(", ")} )"
-            end
-          elsif arg2.class != Variable or arg2.type.vector_length == 1 then
-            return "#{arg1} = (#{arg1.type.decl})( #{arg2} )" if lang == CL
-
-            instruction = intrinsics[get_architecture][:SET1][get_vector_name(arg1.type)]
-            raise "Unavailable operator set1 for #{get_vector_name(arg1.type)}!" unless instruction
-            return "#{arg1} = #{instruction}( #{arg2} )"
-          elsif arg1.type == arg2.type then
-            return basic_usage(arg1, arg2)
-          elsif arg1.type.vector_length == arg2.type.vector_length then
-            return "#{arg1} = #{convert(arg2, arg1.type)}"
-          else
-            raise "Unknown convertion between vector of different length!"
-          end
-        else
-          return basic_usage(arg1, arg2)
-        end
-      else
-        return basic_usage(arg1, arg2)
-      end
-    end
-
-    def Set.basic_usage(arg1, arg2)
-      return "(#{arg1} = #{arg2})"
-    end
-
-  end
-
   class Different < Operator
 
     def Different.to_s(arg1, arg2, return_type)
@@ -98,90 +56,13 @@ module BOAST
 
   end
 
-  class Load < Operator
-
-    def Load.to_s(arg1, arg2, return_type)
-      if lang == C or lang == CL then
-        if arg1 then
-          if arg1.class == Variable and arg1.type.vector_length > 1 then
-            if arg2.kind_of?( Array ) then
-              return Set.to_s(arg1, arg2, return_type)
-            elsif arg1.type == arg2.type then
-              return Affectation.basic_usage(arg1, arg2)
-            elsif arg1.type.vector_length == arg2.type.vector_length then
-              return "#{arg1} = #{convert(arg2, arg1.type)}"
-            elsif arg2.type.vector_length == 1 then
-              return "#{arg1} = #{Load.to_s(nil, arg2, arg1)}"
-            else
-              raise "Unknown convertion between vectors of different length!"
-            end
-          else
-            Affectation.basic_usage(arg1, arg2)
-          end
-        elsif arg2.class == Variable and arg2.type.vector_length == 1 then
-          a2 = "#{arg2}"
-          if a2[0] != "*" then
-            a2 = "&" + a2
-          else
-            a2 = a2[1..-1]
-          end
-
-          return "vload#{return_type.type.vector_length}(0, #{a2})" if lang == CL
-          return "#{arg1} = _m_from_int64( *((int64_t * ) #{a2} ) )" if get_architecture == X86 and arg2.type.total_size*8 == 64
-
-          if arg2.align == return_type.type.total_size then
-            instruction = intrinsics[get_architecture][:LOADA][get_vector_name(return_type.type)]
-          else
-            instruction = intrinsics[get_architecture][:LOAD][get_vector_name(return_type.type)]
-          end
-          raise "Unavailable operator load for #{get_vector_name(return_type.type)}!" unless instruction
-          return "#{instruction}( #{a2} )"
-        else
-          return "#{arg2}"
-        end
-      end
-      return Affectation.basic_usage(arg1, arg2) if arg1
-      return "#{arg2}"
-    end
-
-  end
-
-  class Store < Operator
-
-    def Store.to_s(arg1, arg2, return_type)
-      if lang == C or lang == CL then
-        a1 = "#{arg1}"
-        if a1[0] != "*" then
-          a1 = "&" + a1
-        else
-          a1 = a1[1..-1]
-        end
-
-        return "vstore#{arg2.type.vector_length}(#{arg2}, 0, #{a1})" if lang == CL
-        return "*((int64_t * ) #{a1}) = _m_to_int64( #{arg2} )" if get_architecture == X86 and arg2.type.total_size*8 == 64
-
-        if arg1.align == arg2.type.total_size then
-          instruction = intrinsics[get_architecture][:STOREA][get_vector_name(arg2.type)]
-        else
-          instruction = intrinsics[get_architecture][:STORE][get_vector_name(arg2.type)]
-        end
-        raise "Unavailable operator store for #{get_vector_name(arg2.type)}!" unless instruction
-        p_type = arg2.type.copy(:vector_length => 1)
-        p_type = arg2.type if get_architecture == X86 and arg2.type.kind_of?(Int)
-        return "#{instruction}( (#{p_type.decl} * ) #{a1}, #{arg2} )"
-      end
-      return Affectation.basic_usage(arg1, arg2)
-    end
-
-  end
-
   class Affectation < Operator
 
     def Affectation.to_s(arg1, arg2, return_type)
       if arg1.class == Variable and arg1.type.vector_length > 1 then
-        return Load.to_s(arg1, arg2, return_type)
+        return "#{arg1} = #{Load(arg2, arg1)}"
       elsif arg2.class == Variable and arg2.type.vector_length > 1 then
-        return Store.to_s(arg1, arg2, return_type)
+        return "#{Store(arg1, arg2, return_type)}"
       end
       return basic_usage(arg1, arg2)
     end
@@ -288,6 +169,365 @@ module BOAST
 
   end
 
+  class Set < Operator
+    extend Functor
+    include Intrinsics
+    include Arithmetic
+    include Inspectable
+    include PrivateStateAccessor
+
+    attr_reader :source
+    attr_reader :return_type
+
+    def initialize(source, return_type)
+      @source = source
+      @return_type = return_type
+    end
+
+    def type
+      return @return_type.type
+    end
+
+    def to_var
+      if lang == C or lang == CL and @return_type.type.vector_length > 1 then
+        if @source.kind_of?( Array ) then
+          raise "Invalid array length!" unless @source.length == @return_type.type.vector_length
+          return @return_type.copy("(#{@return_type.type.decl})( #{@source.join(", ")} )", DISCARD_OPTIONS) if lang == CL
+
+          instruction = intrinsics(:SET, @return_type.type)
+          return @return_type.copy("#{instruction}( #{@source.join(", ")} )",  DISCARD_OPTIONS) if instruction
+
+          instruction = intrinsics(:SET_LANE, @return_type.type)
+          raise "Unavailable operator set for #{get_vector_name(@return_type.type)}!" unless instruction
+          s = Set(0, @return_type).to_s
+          @source.each_with_index { |v,i|
+            s = "#{instruction}(#{v}, #{s}, #{i})"
+          }
+          return @return_type.copy(s, DISCARD_OPTIONS)
+        elsif @source.class != Variable or @source.type.vector_length == 1 then
+          return @return_type.copy("(#{@return_type.type.decl})( #{@source} )", DISCARD_OPTIONS) if lang == CL
+
+          instruction = intrinsics(:SET1, @return_type.type)
+          raise "Unavailable operator set1 for #{get_vector_name(@return_type.type)}!" unless instruction
+          return @return_type.copy("#{instruction}( #{@source} )", DISCARD_OPTIONS)
+        elsif @return_type.type != @source.type
+          return @return_type.copy("#{Operator.convert(@source, @return_type.type)}", DISCARD_OPTIONS)
+        end
+      end
+      return @return_type.copy("#{@source}", DISCARD_OPTIONS)
+    end
+
+    def to_s
+      return to_var.to_s
+    end
+
+    def pr
+      s=""
+      s += indent
+      s += to_s
+      s += ";" if [C, CL, CUDA].include?( lang )
+      output.puts s
+      return self
+    end
+
+  end
+
+  class Load < Operator
+    extend Functor
+    include Intrinsics
+    include Arithmetic
+    include Inspectable
+    include PrivateStateAccessor
+
+    attr_reader :source
+    attr_reader :return_type
+
+    def initialize(source, return_type)
+      @source = source
+      @return_type = return_type
+    end
+
+    def type
+      return @return_type.type
+    end
+
+    def to_var
+      if lang == C or lang == CL then
+        if @source.kind_of?(Array) then
+          return Set(@source, @return_type).to_var
+        elsif @source.class == Variable or @source.respond_to?(:to_var) then
+          if @source.to_var.type == @return_type.type
+            return @source.to_var
+          elsif @source.to_var.type.vector_length == 1 then
+            a2 = "#{@source}"
+            if a2[0] != "*" then
+              a2 = "&" + a2
+            else
+              a2 = a2[1..-1]
+            end
+            return @return_type.copy("vload#{@return_type.type.vector_length}(0, #{a2})", DISCARD_OPTIONS) if lang == CL
+            return @return_type.copy("_m_from_int64( *((int64_t * ) #{a2} ) )", DISCARD_OPTIONS) if get_architecture == X86 and @return_type.type.total_size*8 == 64
+            if @source.align == @return_type.type.total_size then
+              instruction = intrinsics(:LOADA, @return_type.type)
+            else
+              instruction = intrinsics(:LOAD, @return_type.type)
+            end
+            raise "Unavailable operator load for #{get_vector_name(@return_type.type)}!" unless instruction
+            return @return_type.copy("#{instruction}( #{a2} )", DISCARD_OPTIONS)
+          else
+            return @return_type.copy("#{Operator.convert(@source, @return_type.type)}", DISCARD_OPTIONS)
+          end
+        end
+      end
+      return @return_type.copy("#{@source}", DISCARD_OPTIONS)
+    end
+
+    def to_s
+      return to_var.to_s
+    end
+
+    def pr
+      s=""
+      s += indent
+      s += to_s
+      s += ";" if [C, CL, CUDA].include?( lang )
+      output.puts s
+      return self
+    end
+
+  end
+
+  class MaskLoad < Operator
+    extend Functor
+    include Intrinsics
+    include Arithmetic
+    include Inspectable
+    include PrivateStateAccessor
+
+    attr_reader :source
+    attr_reader :mask
+    attr_reader :return_type
+
+    def initialize(source, mask, return_type)
+      @source = source
+      @mask = mask
+      @return_type = return_type
+    end
+
+    def get_mask
+      raise "Mask size is wrong: #{@mask.length} for #{@return_type.type.vector_length}!" if @mask.length != @return_type.type.vector_length
+      return Load(@mask.collect { |m| ( m and m != 0 )  ? -1 : 0 }, Int("mask", :size => @return_type.type.size, :vector_length => @return_type.type.vector_length ) )
+    end
+
+    private :get_mask
+
+    def type
+      return @return_type.type
+    end
+
+    def to_var
+      raise "Cannot load unknown type!" unless @return_type
+      raise "Unsupported language!" unless lang == C
+      raise "MaskLoad not supported!"unless supported(:MASKLOAD, @return_type.type)
+      s = ""
+      src = "#{@source}"
+      if src[0] != "*" then
+        src = "&" + src
+      else
+        src = src[1..-1]
+      end
+      p_type = @return_type.type.copy(:vector_length => 1)
+      s += "#{intrinsics(:MASKLOAD, @return_type.type)}((#{p_type.decl} * )#{src}, #{get_mask})"
+      return @return_type.copy( s, DISCARD_OPTIONS)
+    end
+
+    def to_s
+      return to_var.to_s
+    end
+
+    def pr
+      s=""
+      s += indent
+      s += to_s
+      s += ";" if [C, CL, CUDA].include?( lang )
+      output.puts s
+      return self
+    end
+
+  end
+
+  class Store < Operator
+    extend Functor
+    include Intrinsics
+    include Arithmetic
+    include Inspectable
+    include PrivateStateAccessor
+
+    attr_reader :dest
+    attr_reader :source
+    attr_reader :store_type
+
+    def initialize(dest, source, mask, store_type = nil)
+      @dest = dest
+      @source = source
+      @store_type = store_type
+      @store_type = source unless @store_type
+    end
+
+    def to_s
+      if lang == C or lang == CL then
+        dst = "#{@dest}"
+        if dst[0] != "*" then
+          dst = "&" + dst
+        else
+          dst = dst[1..-1]
+        end
+
+        return "vstore#{@source.type.vector_length}(#{@source}, 0, #{dst})" if lang == CL
+        return "*((int64_t * ) #{dst}) = _m_to_int64( #{@source} )" if get_architecture == X86 and @source.type.total_size*8 == 64
+
+        if @dest.align == @source.type.total_size then
+          instruction = intrinsics(:STOREA, @source.type)
+        else
+          instruction = intrinsics(:STORE, @source.type)
+        end
+        raise "Unavailable operator store for #{get_vector_name(@source.type)}!" unless instruction
+        p_type = @source.type.copy(:vector_length => 1)
+        p_type = @source.type if get_architecture == X86 and @source.type.kind_of?(Int)
+        return "#{instruction}( (#{p_type.decl} * ) #{dst}, #{@source} )"
+      end
+      return Affectation.basic_usage(@dest, @source)
+    end
+
+    def pr
+      s=""
+      s += indent
+      s += to_s
+      s += ";" if [C, CL, CUDA].include?( lang )
+      output.puts s
+      return self
+    end
+
+  end
+
+  class MaskStore < Operator
+    extend Functor
+    include Intrinsics
+    include Arithmetic
+    include Inspectable
+    include PrivateStateAccessor
+
+    attr_reader :dest
+    attr_reader :source
+    attr_reader :mask
+    attr_reader :store_type
+
+    def initialize(dest, source, mask, store_type = nil)
+      @dest = dest
+      @source = source
+      @mask = mask
+      @store_type = store_type
+      @store_type = source unless @store_type
+    end
+
+    def get_mask
+      raise "Mask size is wrong: #{@mask.length} for #{@store_type.type.vector_length}!" if @mask.length != @store_type.type.vector_length
+      return Load.to_s(@mask.collect { |m| ( m and m != 0 )  ? -1 : 0 }, Int("mask", :size => @store_type.type.size, :vector_length => @store_type.type.vector_length ) )
+    end
+
+    private :get_mask
+
+    def to_s
+      raise "Cannot store unknown type!" unless @store_type
+      raise "Unsupported language!" unless lang == C
+      raise "MaskStore not supported!"unless supported(:MASKSTORE, @store_type.type)
+      s = ""
+      dst = "#{@dest}"
+      if dst[0] != "*" then
+        dst = "&" + dst
+      else
+        dst = dst[1..-1]
+      end
+      p_type = @store_type.type.copy(:vector_length => 1)
+      return s += "#{intrinsics(:MASKSTORE, @store_type.type)}((#{p_type.decl} * )#{dst}, #{get_mask}, #{Operator.convert(@source, @store_type.type)})"
+    end
+
+    def pr
+      s=""
+      s += indent
+      s += to_s
+      s += ";" if [C, CL, CUDA].include?( lang )
+      output.puts s
+      return self
+    end
+
+  end
+
+  class FMA < Operator
+    extend Functor
+    include Intrinsics
+    include Arithmetic
+    include Inspectable
+    include PrivateStateAccessor
+
+    attr_reader :operand1
+    attr_reader :operand2
+    attr_reader :operand3
+    attr_reader :return_type
+
+    def initialize(a,b,c)
+      @operand1 = a
+      @operand2 = b
+      @operand3 = c
+      @return_type = nil
+      @return_type = @operand3.to_var unless @return_type
+    end
+
+    def convert_operand(op)
+      return  "#{Operator.convert(op, @return_type.type)}"
+    end
+
+    private :convert_operand
+
+    def type
+      return @return_type.type
+    end
+
+    def to_var
+      return (@operand3 + @operand1 * @operand2).to_var unless lang != FORTRAN and @return_type and ( supported(:FMADD, @return_type.type) or ( [CL, CUDA].include?(lang) ) )
+      op1 = convert_operand(@operand1)
+      op2 = convert_operand(@operand2)
+      op3 = convert_operand(@operand3)
+      if [CL, CUDA].include?(lang)
+        ret_name = "fma(#{op1},#{op2},#{op3})"
+      else
+        case architecture
+        when X86
+          ret_name = "#{intrinsics(:FMADD,@return_type.type)}(#{op1},#{op2},#{op3})"
+        when ARM
+          ret_name = "#{intrinsics(:FMADD,@return_type.type)}(#{op2},#{op3},#{op1})"
+        else
+          return (@operand1 * @operand2 + @operand3).to_var
+        end
+      end
+      return @return_type.copy( ret_name, DISCARD_OPTIONS)
+    end
+
+    def to_s
+      return to_var.to_s
+    end
+
+    def pr
+      s=""
+      s += indent
+      s += to_s
+      s += ";" if [C, CL, CUDA].include?( lang )
+      output.puts s
+      return self
+    end
+
+  end
+
   class Ternary
     extend Functor
     include Arithmetic

data/lib/BOAST/Language/Procedure.rb

@@ -218,7 +218,7 @@ module BOAST
     end
 
     def open_c
-      s = decl_c_s + "{"
+      s = indent + decl_c_s + "{"
       output.puts s
       increment_indent_level
       constants.each { |c|

data/lib/BOAST/Language/State.rb

@@ -37,6 +37,20 @@ EOF
     }
   end
 
+  def self.default_state_getter(arg, default, get_env_string=nil, env = arg.upcase)
+    envs = "ENV['#{env}']"
+    s = <<EOF
+  def get_default_#{arg}
+    #{arg} = #{default.inspect}
+    #{arg} = #{get_env_string ? eval( "#{get_env_string}" ) : "YAML::load(#{envs})" } if #{envs}
+    return #{arg}
+  end
+  module_function :get_default_#{arg}
+  @@#{arg} = get_default_#{arg}
+EOF
+    eval s
+  end
+
   module PrivateStateAccessor
 
     def self.private_state_accessor(*args)

data/lib/BOAST/Language/Transitions.rb

@@ -34,7 +34,7 @@ module BOAST
          signed = (signed or var2.type.signed)
          size = [var1.type.size, var2.type.size].max
          vector_length = [var1.type.vector_length, var2.type.vector_length].max
-         [Variable::new("dummy", return_type, :size => size, :signed => signed, :vector_length => vector_length), operator]
+         return [Variable::new("dummy", return_type, :size => size, :signed => signed, :vector_length => vector_length), operator]
        elsif var1.type.class == return_type then
          return [var1, operator]
        else # var2.type.class == return_type then