BOAST 1.0.9 → 1.1.0

data/lib/BOAST/Language/OpenMP.rb

@@ -11,7 +11,7 @@ module BOAST
         elsif lang == C then
           s += "#pragma omp"
         else
-          raise "Language does not support OpenMP!"
+          raise LanguageError, "Language does not support OpenMP!"
         end
         return s
       end

data/lib/BOAST/Language/Operators.rb

@@ -1,5 +1,8 @@
 module BOAST
 
+  class OperatorError < Error
+  end
+
   class Operator
     extend PrivateStateAccessor
     extend Intrinsics
@@ -11,10 +14,10 @@ module BOAST
     end
 
     def Operator.convert(arg, type)
+      return "#{arg}" if get_vector_name(arg.type) == get_vector_name(type) or lang == CUDA
       return "convert_#{type.decl}( #{arg} )" if lang == CL
 
       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|
@@ -29,10 +32,9 @@ module BOAST
 
   class BasicBinaryOperator < Operator
 
-    def BasicBinaryOperator.to_s(arg1, arg2, return_type)
+    def BasicBinaryOperator.string(arg1, arg2, return_type)
       if lang == C and (arg1.class == Variable and arg2.class == Variable) and (arg1.type.vector_length > 1 or arg2.type.vector_length > 1) then
         instruction = intrinsics(intr_symbol, return_type.type)
-        raise "Unavailable operator #{symbol} for #{get_vector_name(return_type.type)}!" unless instruction
         a1 = convert(arg1, return_type.type)
         a2 = convert(arg2, return_type.type)
         return "#{instruction}( #{a1}, #{a2} )"
@@ -43,9 +45,63 @@ module BOAST
 
   end
 
+  class Minus < Operator
+
+    def Minus.string(arg1, arg2, return_type)
+      return " -(#{arg2})"
+    end
+
+  end
+
+  class Plus < Operator
+
+    def Plus.string(arg1, arg2, return_type)
+      return " +#{arg2}"
+    end
+
+  end
+
+  class Not < Operator
+
+    def Not.string(arg1, arg2, return_type)
+      return " (.not. (#{arg2}))" if lang == FORTRAN
+      return " !(#{arg2})"
+    end
+
+  end
+
+  class Reference < Operator
+
+    def Reference.string(arg1, arg2, return_type)
+      return " #{arg2}" if lang == FORTRAN
+      return " &#{arg2}"
+    end
+
+  end
+
+  class Dereference < Operator
+
+    def Dereference.string(arg1, arg2, return_type)
+      return " *(#{arg2})"
+    end
+
+  end
+
+  class Equal < Operator
+
+    def Equal.string(arg1, arg2, return_type)
+      return basic_usage(arg1, arg2)
+    end
+
+    def Equal.basic_usage(arg1, arg2)
+      return "#{arg1} == #{arg2}"
+    end
+
+  end
+
   class Different < Operator
 
-    def Different.to_s(arg1, arg2, return_type)
+    def Different.string(arg1, arg2, return_type)
       return basic_usage(arg1, arg2)
     end
 
@@ -56,9 +112,83 @@ module BOAST
 
   end
 
+  class Greater < Operator
+
+    def Greater.string(arg1, arg2, return_type)
+      return basic_usage(arg1, arg2)
+    end
+
+    def Greater.basic_usage(arg1, arg2)
+      return "#{arg1} > #{arg2}"
+    end
+
+  end
+
+  class Less < Operator
+
+    def Less.string(arg1, arg2, return_type)
+      return basic_usage(arg1, arg2)
+    end
+
+    def Less.basic_usage(arg1, arg2)
+      return "#{arg1} < #{arg2}"
+    end
+
+  end
+
+  class GreaterOrEqual < Operator
+
+    def GreaterOrEqual.string(arg1, arg2, return_type)
+      return basic_usage(arg1, arg2)
+    end
+
+    def GreaterOrEqual.basic_usage(arg1, arg2)
+      return "#{arg1} >= #{arg2}"
+    end
+
+  end
+
+  class LessOrEqual < Operator
+
+    def LessOrEqual.string(arg1, arg2, return_type)
+      return basic_usage(arg1, arg2)
+    end
+
+    def LessOrEqual.basic_usage(arg1, arg2)
+      return "#{arg1} <= #{arg2}"
+    end
+
+  end
+
+  class And < Operator
+
+    def And.string(arg1, arg2, return_type)
+      return basic_usage(arg1, arg2)
+    end
+
+    def And.basic_usage(arg1, arg2)
+      return "#{arg1} .and. #{arg2}" if lang == FORTRAN
+      return "#{arg1} && #{arg2}"
+    end
+
+  end
+
+  class Or < Operator
+
+    def Or.string(arg1, arg2, return_type)
+      return basic_usage(arg1, arg2)
+    end
+
+    def Or.basic_usage(arg1, arg2)
+      return "#{arg1} .or. #{arg2}" if lang == FORTRAN
+      return "#{arg1} || #{arg2}"
+    end
+
+  end
+
   class Affectation < Operator
 
-    def Affectation.to_s(arg1, arg2, return_type)
+    def Affectation.string(arg1, arg2, return_type)
       if arg1.class == Variable and arg1.type.vector_length > 1 then
         return "#{arg1} = #{Load(arg2, arg1)}"
       elsif arg2.class == Variable and arg2.type.vector_length > 1 then
@@ -73,6 +203,27 @@ module BOAST
 
   end
 
+  class Exponentiation < BasicBinaryOperator
+
+    class << self
+
+      def symbol
+        return "**"
+      end
+
+      def intr_symbol
+        return :POW
+      end
+
+      def basic_usage(arg1, arg2)
+        return "(#{arg1})**(#{arg2})" if lang == FORTRAN
+        return "pow(#{arg1}, #{arg2})"
+      end
+
+    end
+
+  end
+
   class Multiplication < BasicBinaryOperator
 
     class << self
@@ -153,22 +304,6 @@ module BOAST
 
   end
 
-  class Minus < Operator
-
-    def Minus.to_s(arg1, arg2, return_type)
-      return " -(#{arg2})"
-    end
-
-  end
-
-  class Not < Operator
-
-    def Not.to_s(arg1, arg2, return_type)
-      return " ! #{arg2}"
-    end
-
-  end
-
   class Set < Operator
     extend Functor
     include Intrinsics
@@ -191,24 +326,24 @@ module BOAST
     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
+          raise OperatorError,  "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)
+          begin
+            instruction = intrinsics(:SET, @return_type.type)
+            return @return_type.copy("#{instruction}( #{@source.join(", ")} )",  DISCARD_OPTIONS)
+          rescue IntrinsicsError
+            instruction = intrinsics(:SET_LANE, @return_type.type)
+            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)
+          end
         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)
@@ -267,12 +402,11 @@ module BOAST
             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
+            if @source.alignment == @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)
@@ -315,7 +449,7 @@ module BOAST
     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
+      raise OperatorError,  "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
 
@@ -326,9 +460,9 @@ module BOAST
     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)
+      raise OperatorError,  "Cannot load unknown type!" unless @return_type
+      raise LanguageError,  "Unsupported language!" unless lang == C
+      instruction = intrinsics(:MASKLOAD, @return_type.type)
       s = ""
       src = "#{@source}"
       if src[0] != "*" then
@@ -337,7 +471,7 @@ module BOAST
         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})"
+      s += "#{instruction}((#{p_type.decl} * )#{src}, #{get_mask})"
       return @return_type.copy( s, DISCARD_OPTIONS)
     end
 
@@ -386,12 +520,11 @@ module BOAST
         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
+        if @dest.alignment == @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} )"
@@ -431,16 +564,16 @@ module BOAST
     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
+      raise OperatorError,  "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)
+      raise OperatorError,  "Cannot store unknown type!" unless @store_type
+      raise LanguageError,  "Unsupported language!" unless lang == C
+      instruction = intrinsics(:MASKSTORE, @store_type.type)
       s = ""
       dst = "#{@dest}"
       if dst[0] != "*" then
@@ -449,7 +582,7 @@ module BOAST
         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)})"
+      return s += "#{instruction}((#{p_type.decl} * )#{dst}, #{get_mask}, #{Operator.convert(@source, @store_type.type)})"
     end
 
     def pr
@@ -494,7 +627,12 @@ module BOAST
     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) ) )
+      instruction = nil
+      begin
+        instruction = intrinsics(:FMADD,@return_type.type)
+      rescue
+      end
+      return (@operand3 + @operand1 * @operand2).to_var unless lang != FORTRAN and @return_type and ( instruction or ( [CL, CUDA].include?(lang) ) )
       op1 = convert_operand(@operand1)
       op2 = convert_operand(@operand2)
       op3 = convert_operand(@operand3)
@@ -503,9 +641,9 @@ module BOAST
       else
         case architecture
         when X86
-          ret_name = "#{intrinsics(:FMADD,@return_type.type)}(#{op1},#{op2},#{op3})"
+          ret_name = "#{instruction}(#{op1},#{op2},#{op3})"
         when ARM
-          ret_name = "#{intrinsics(:FMADD,@return_type.type)}(#{op2},#{op3},#{op1})"
+          ret_name = "#{instruction}(#{op2},#{op3},#{op1})"
         else
           return (@operand1 * @operand2 + @operand3).to_var
         end
@@ -544,14 +682,31 @@ module BOAST
       @operand3 = z
     end
 
+    def op_to_var
+      op1 = @operand1.respond_to?(:to_var) ? @operand1.to_var : @operand1
+      op1 = @operand1 unless op1
+      op2 = @operand2.respond_to?(:to_var) ? @operand2.to_var : @operand2
+      op2 = @operand2 unless op2
+      op3 = @operand3.respond_to?(:to_var) ? @operand3.to_var : @operand3
+      op3 = @operand3 unless op3
+      return [op1, op2, op3]
+    end
+
+    private :op_to_var
+
     def to_s
-      raise "Ternary operator unsupported in FORTRAN!" if lang == FORTRAN
+      return to_s_fortran if lang == FORTRAN
       return to_s_c if [C, CL, CUDA].include?( lang )
     end
 
+    def to_s_fortran
+      op1, op2, op3 = op_to_var
+      "merge(#{op2}, #{op3}, #{op1})"
+    end
+
     def to_s_c
-      s = ""
-      s += "(#{@operand1} ? #{@operand2} : #{@operand3})"
+      op1, op2, op3 = op_to_var
+      "(#{op1} ? #{op2} : #{op3})"
     end
 
     def pr

data/lib/BOAST/Language/Pragma.rb

@@ -8,7 +8,7 @@ module BOAST
     attr_reader :name
     attr_reader :options
 
-    def initialize(name, options)
+    def initialize(name, *options)
       @name = name
       @options = options
     end
@@ -16,9 +16,9 @@ module BOAST
     def to_s
       s = ""
       if lang == FORTRAN then
-        s += "$!"
+        s += "!#{@name}$"
       else
-        s += "#pragma"
+        s += "#pragma #{name}"
       end
       @options.each{ |opt|
         s += " #{opt}"

data/lib/BOAST/Language/Print.rb

@@ -1,11 +1,11 @@
 module BOAST
 
-   def self.print(a)
-     a.pr
+   def self.print(a, *args)
+     pr(a, *args)
    end
 
    def self.open(a)
-     a.open
+     opn(a)
    end
 
 end