BOAST 1.3.5 → 2.0.0

data/lib/BOAST/Language/Index.rb

@@ -37,7 +37,7 @@ module BOAST
     end
 
     def to_s
-      if get_replace_constants then
+      if get_replace_constants and @source.constant? then
         begin
           const = @source.constant
           indxs = @indexes.reverse
@@ -51,7 +51,7 @@ module BOAST
             const = const[ind]
           }
           return "#{const}#{@source.type.suffix}"
-        rescue Exception => e
+        rescue Exception
         end
       end
       return to_s_fortran if lang == FORTRAN
@@ -73,13 +73,13 @@ module BOAST
       indexes_dup = []
       @source.dimension.each_with_index { |d,i|
         if d.size.nil? and get_array_start != 1 then
-           indexes_dup.push( @indexes[i] - d.start + 1 )
+           indexes_dup.push( (@indexes[i] - d.start + 1).to_s )
         else
-           indexes_dup.push( @indexes[i] )
+           indexes_dup.push( (@indexes[i]).to_s )
         end
       }
       s = ""
-      s += "#{@source}(#{indexes_dup.join(", ")})"
+      s += "#{@source}(#{@source.vector? ? ":, " : "" }#{indexes_dup.join(", ")})"
       return s
     end
 

data/lib/BOAST/Language/Intrinsics.rb

@@ -22,8 +22,10 @@ module BOAST
 
   MODELS = { "native" => native_flags }
   MODELS.update(X86architectures)
+  MODELS.update(ARMarchitectures)
   INSTRUCTIONS = {}
-  INSTRUCTIONS.update(X86CPUID_by_name)
+  INSTRUCTIONS[X86] = X86CPUID_by_name
+  INSTRUCTIONS[ARM] = ARMCPUID_by_name
 
   class IntrinsicsError < Error
   end
@@ -39,21 +41,24 @@ module BOAST
     CONVERSIONS = Hash::new { |h, k| h[k] = Hash::new { |h2, k2| h2[k2] = {} } }
 
     def check_coverage
-      ins = []
-      INTRINSICS[X86].each { |i,v|
-        if i == :CVT then
-          v.each { |type1, h|
-            h.each { |type2, instr|
+      instrs = [X86, ARM].collect { |ar|
+        ins = []
+        INTRINSICS[ar].each { |i,v|
+          if i == :CVT then
+            v.each { |type1, h|
+              h.each { |type2, instr|
+                ins.push instr.to_s
+              }
+            }
+          else
+            v.each { |type, instr|
               ins.push instr.to_s
             }
-          }
-        else
-          v.each { |type, instr|
-            ins.push instr.to_s
-          }
-        end
+          end
+        }
+        ins - INSTRUCTIONS[ar].keys
       }
-      return ins - INSTRUCTIONS.keys
+      return instrs
     end
 
     module_function :check_coverage
@@ -65,9 +70,8 @@ module BOAST
         instruction = INTRINSICS[get_architecture][intr_symbol][type]
       end
       raise IntrinsicsError, "Unsupported operation #{intr_symbol} for #{type}#{type2 ? " and #{type2}" : ""} on #{get_architecture_name}!" unless instruction
-      return instruction if get_architecture == ARM
       supported = false
-      INSTRUCTIONS[instruction.to_s].each { |cpuid|
+      INSTRUCTIONS[get_architecture][instruction.to_s].each { |cpuid|
         if cpuid.kind_of?( Array ) then
           supported = true if (cpuid - MODELS[get_model.to_s]).empty?
         else
@@ -77,7 +81,7 @@ module BOAST
 #      supported = (INSTRUCTIONS[instruction.to_s] & MODELS[get_model.to_s]).size > 0
       if not supported then
         required = ""
-        INSTRUCTIONS[instruction.to_s].each { |cpuid|
+        INSTRUCTIONS[get_architecture][instruction.to_s].each { |cpuid|
           required += " or " if required != ""
           if cpuid.kind_of?( Array ) then
             required += "( #{cpuid.join(" and ")} )"
@@ -301,7 +305,13 @@ module BOAST
                         [:MASK_LOAD,   "mask_loadu"],  [:MASK_STORE,  "mask_storeu"],
                         [:MASK_LOADA,  "mask_load"],   [:MASK_STOREA, "mask_store"],
                         [:MASKZ_LOAD,  "maskz_loadu"],
-                        [:MASKZ_LOADA, "maskz_load"]]
+                        [:MASKZ_LOADA, "maskz_load"],
+                        [:MAX, "max"], [:MIN, "min"],
+                        [:SQRT, "sqrt"], [:EXP, "exp"], [:LOG, "log"], [:LOG10, "log10"],
+                         [:SIN,   "sin"],   [:COS,   "cos"],   [:TAN,   "tan"],
+                         [:SINH,  "sinh"],  [:COSH,  "cosh"],  [:TANH,  "tanh"],
+                        [:ASIN,  "asin"],  [:ACOS,  "acos"],  [:ATAN,  "atan"],
+                        [:ASINH, "asinh"], [:ACOSH, "acosh"], [:ATANH, "atanh"]]
         instructions.push( [:MASKLOAD, "maskload"], [:MASKSTORE, "maskstore"] ) if vector_size < 512
         instructions.push( [:ADDSUB, "addsub"] ) if vector_size < 512
         instructions.each { |cl, ins|
@@ -364,14 +374,16 @@ module BOAST
 
     [64, 128].each { |vector_size|
       q = (vector_size == 128 ? "q" : "")
-      [8, 16, 32, 64].each { |size|
+      scal_sizes = [8, 16, 32]
+      scal_sizes.push 64 if vector_size > 64
+      scal_sizes.each { |size|
         [:signed, :unsigned].each { |sign|
           vtype = vector_type_name( :int, size, vector_size, sign )
           type = type_name_ARM( :int, size, sign )
           instructions = [[:ADD, "add"], [:SUB, "sub"]]
           instructions.push( [:MUL, "mul"], [:FMADD, "mla"], [:FNMADD, "mls"] ) if size < 64
-          instructions.push( [:LOAD, "ldl"], [:LOADA, "ldl"] )
-          instructions.push( [:STORE, "stl"], [:STOREA, "stl"] )
+          instructions.push( [:LOAD, "ld1"], [:LOADA, "ld1"] )
+          instructions.push( [:STORE, "st1"], [:STOREA, "st1"] )
           instructions.each { |cl, ins|
             INTRINSICS[ARM][cl][vtype] = "v#{ins}#{q}_#{type}".to_sym
           }
@@ -383,13 +395,15 @@ module BOAST
           }
         }
       }
-      [32, 64].each { |size|
+      scal_sizes = [32]
+      scal_sizes.push 64 if vector_size > 64
+      scal_sizes.each { |size|
         vtype = vector_type_name( :float, size, vector_size )
         type = type_name_ARM( :float, size )
         [[:ADD, "add"], [:SUB, "sub"], [:MUL, "mul"],
          [:FMADD, "mla"], [:FNMADD, "mls"],
-         [:LOAD, "ldl"], [:LOADA, "ldl"],
-         [:STORE, "stl"], [:STOREA, "stl"]].each { |cl, ins|
+         [:LOAD, "ld1"], [:LOADA, "ld1"],
+         [:STORE, "st1"], [:STOREA, "st1"]].each { |cl, ins|
           INTRINSICS[ARM][cl][vtype] = "v#{ins}#{q}_#{type}".to_sym
         }
         [[:SET1, "dup"]].each { |cl, ins|
@@ -439,10 +453,9 @@ module BOAST
         cvt_dgraph = RGL::DirectedAdjacencyGraph::new
         INTRINSICS[arch][:CVT].each { |dest, origs|
           origs.each { |orig, intrinsic|
-            supported = true
-            if arch == X86
-              supported = false
-              INSTRUCTIONS[intrinsic.to_s].each { |cpuid|
+            supported = false
+            if MODELS[get_model.to_s] then
+              INSTRUCTIONS[arch][intrinsic.to_s].each { |cpuid|
                 if cpuid.kind_of?( Array ) then
                   supported = true if (cpuid - MODELS[get_model.to_s]).empty?
                 else

data/lib/BOAST/Language/OpenMP.rb

@@ -143,6 +143,7 @@ EOF
       end
 
       def initialize(options = {}, &block)
+        super()
         @openmp_clauses = options
         @block = block
       end

data/lib/BOAST/Language/Operators.rb

@@ -15,6 +15,11 @@ module BOAST
 
     def Operator.convert(arg, type)
       return "#{arg}" if get_vector_name(arg.type) == get_vector_name(type) or lang == CUDA
+
+      if arg.type.vector_length == 1 and type.vector_length > 1 then
+        return "#{Set::new( arg, Variable::new(:dummy, type.class, type.to_hash) )}"
+      end
+
       return "convert_#{type.decl}( #{arg} )" if lang == CL
 
       path = get_conversion_path(type, arg.type)
@@ -186,23 +191,6 @@ module BOAST
 
   end
 
-  class Affectation < Operator
-
-    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
-        return "#{Store(arg1, arg2, :store_type => return_type)}"
-      end
-      return basic_usage(arg1, arg2)
-    end
-
-    def Affectation.basic_usage(arg1, arg2)
-      return "#{arg1} = #{arg2}"
-    end
-
-  end
-
   class Exponentiation < BasicBinaryOperator
 
     class << self
@@ -264,7 +252,7 @@ module BOAST
 
   end
 
-  class Substraction < BasicBinaryOperator
+  class Subtraction < BasicBinaryOperator
 
     class << self
 
@@ -304,6 +292,38 @@ module BOAST
 
   end
 
+  class Min < BasicBinaryOperator
+
+    class << self
+
+      def intr_symbol
+        return :MIN
+      end
+
+      def basic_usage(arg1, arg2)
+        return "min( #{arg1}, #{arg2} )"
+      end
+
+    end
+
+  end
+
+  class Max < BasicBinaryOperator
+
+    class << self
+
+      def intr_symbol
+        return :MAX
+      end
+
+      def basic_usage(arg1, arg2)
+        return "max( #{arg1}, #{arg2} )"
+      end
+
+    end
+
+  end
+
   class Mask
     extend Functor
 
@@ -388,18 +408,32 @@ module BOAST
           begin
             instruction = intrinsics(:SET, @return_type.type)
             raise IntrinsicsError unless instruction
-            return @return_type.copy("#{instruction}( #{@source.join(", ")} )",  DISCARD_OPTIONS)
+            eff_srcs = @source.collect { |src|
+              eff_src = nil
+              eff_src = src.to_var if src.respond_to?(:to_var)
+              eff_src = src unless eff_src
+              eff_src
+            }
+            return @return_type.copy("#{instruction}( #{eff_srcs.join(", ")} )",  DISCARD_OPTIONS)
           rescue IntrinsicsError
             instruction = intrinsics(:SET_LANE, @return_type.type)
             raise IntrinsicsError, "Missing instruction for SET_LANE on #{get_architecture_name}!" unless instruction
             s = Set(0, @return_type).to_s
             @source.each_with_index { |v,i|
-              s = "#{instruction}( #{v}, #{s}, #{i} )"
+              eff_src = nil
+              eff_src = v.to_var if v.respond_to?(:to_var)
+              eff_src = v unless eff_src
+              s = "#{instruction}( #{eff_src}, #{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
+          eff_src = nil
+          eff_src = @source.to_var if @source.respond_to?(:to_var)
+          eff_src = @source unless eff_src
+          if lang == CL then
+            return @return_type.copy("(#{@return_type.type.decl})( #{eff_src} )", DISCARD_OPTIONS) if lang == CL
+          end
           if (@source.is_a?(Numeric) and @source == 0) or (@source.class == Variable and @source.constant == 0) then
             begin
               instruction = intrinsics(:SETZERO, @return_type.type)
@@ -408,12 +442,73 @@ module BOAST
             end
           end
           instruction = intrinsics(:SET1, @return_type.type)
-          return @return_type.copy("#{instruction}( #{@source} )", DISCARD_OPTIONS)
+          return @return_type.copy("#{instruction}( #{eff_src} )", DISCARD_OPTIONS)
         elsif @return_type.type != @source.type
           return @return_type.copy("#{Operator.convert(@source, @return_type.type)}", DISCARD_OPTIONS)
         end
+      elsif lang == FORTRAN and @return_type.type.vector_length > 1 then
+        if @source.kind_of?( Array ) then
+          raise OperatorError,  "Invalid array length!" unless @source.length == @return_type.type.vector_length
+          return "(/#{@source.join(", ")}/)"
+        end
       end
-      return @return_type.copy("#{@source}", DISCARD_OPTIONS)
+      eff_src = nil
+      eff_src = @source.to_var if @source.respond_to?(:to_var)
+      eff_src = @source unless eff_src
+      return @return_type.copy("#{eff_src}", 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
+
+  # @!parse module Functors; functorize Affectation; end
+  class Affectation < Operator
+    extend Functor
+    include Intrinsics
+    include Arithmetic
+    include Inspectable
+    include PrivateStateAccessor
+
+    attr_reader :target
+    attr_reader :source
+    attr_reader :options
+
+    def initialize(target, source, options = {})
+      @target = target
+      @source = source
+      @options = options
+    end
+
+    def type
+      return target.to_var.type
+    end
+
+    def to_var
+      tar = @target
+      tar = @target.to_var if @target.respond_to?(:to_var)
+      src = @source
+      src = @source.to_var if @source.respond_to?(:to_var)
+      if tar.class == Variable and tar.type.vector_length > 1 then
+        return @target.copy("#{@target} = #{Load(@source, @target, @options)}", DISCARD_OPTIONS)
+      elsif src.class == Variable and src.type.vector_length > 1 then
+        r_t, _ = transition(tar, src, Affectation)
+        opts = @options.clone
+        opts[:store_type] = r_t
+        return @target.copy("#{Store(@target, @source, opts)}", DISCARD_OPTIONS)
+      end
+      return tar.copy("#{tar ? tar : @target} = #{src ? src : @source}", DISCARD_OPTIONS)
     end
 
     def to_s
@@ -431,6 +526,7 @@ module BOAST
 
   end
 
+
   # @!parse module Functors; functorize Load; end
   class Load < Operator
     extend Functor
@@ -460,10 +556,11 @@ module BOAST
         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}"
+          src_var = source.to_var
+          if src_var.type == @return_type.type then
+            return src_var
+          elsif src_var.type.vector_length == 1 then
+            a2 = "#{src_var}"
             if a2[0] != "*" then
               a2 = "&" + a2
             else
@@ -481,7 +578,7 @@ module BOAST
               sym += "Z" if @zero
               sym += "_"
             end
-            if @source.alignment and @return_type.type.total_size and ( @source.alignment % @return_type.type.total_size ) == 0 then
+            if src_var.alignment and @return_type.type.total_size and ( src_var.alignment % @return_type.type.total_size ) == 0 then
               sym += "LOADA"
             else
               sym += "LOAD"
@@ -493,7 +590,17 @@ module BOAST
             end
             return @return_type.copy("#{instruction}( #{a2} )", DISCARD_OPTIONS)
           else
-            return @return_type.copy("#{Operator.convert(@source, @return_type.type)}", DISCARD_OPTIONS)
+            return @return_type.copy("#{Operator.convert(src_var, @return_type.type)}", DISCARD_OPTIONS)
+          end
+        end
+      elsif lang == FORTRAN 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 then
+            return @source.to_var
+          elsif @source.kind_of?(Index) and @return_type.type.vector_length > 1 then
+            return @return_type.copy("#{Slice::new(@source.source, [@source.indexes[0], @source.indexes[0] + @return_type.type.vector_length - 1], *@source.indexes[1..-1])}", DISCARD_OPTIONS)
           end
         end
       end
@@ -601,6 +708,9 @@ module BOAST
     end
 
     def to_s
+      if @store_type.type == @dest.type then
+        return "#{@dest} = #{@source}"
+      end
       if lang == C or lang == CL then
         dst = "#{@dest}"
         if dst[0] != "*" then
@@ -626,8 +736,12 @@ module BOAST
         p_type = type if get_architecture == X86 and type.kind_of?(Int)
         return "#{instruction}( (#{p_type.decl} * ) #{dst}, (#{mask.value.type.decl})#{mask}, #{@source} )" if mask and not mask.full?
         return "#{instruction}( (#{p_type.decl} * ) #{dst}, #{@source} )"
+      elsif lang == FORTRAN
+        if @store_type.type.vector_length > 1 and @dest.kind_of?(Index) then
+          return "#{Slice::new(@dest.source, [@dest.indexes[0], @dest.indexes[0] + @store_type.type.vector_length - 1], *@dest.indexes[1..-1])} = #{@source}"
+        end
       end
-      return Affectation.basic_usage(@dest, @source)
+      return "#{@dest} = #{@source}"
     end
 
     def pr
@@ -719,8 +833,7 @@ module BOAST
       @operand1 = a
       @operand2 = b
       @operand3 = c
-      @return_type = nil
-      @return_type = @operand3.to_var unless @return_type
+      @return_type = @operand3.to_var
     end
 
     def convert_operand(op)
@@ -790,8 +903,7 @@ module BOAST
       @operand1 = a
       @operand2 = b
       @operand3 = c
-      @return_type = nil
-      @return_type = @operand3.to_var unless @return_type
+      @return_type = @operand3.to_var
     end
 
     def convert_operand(op)
@@ -845,6 +957,81 @@ module BOAST
 
   end
 
+  class Modulo < Operator
+    extend Functor
+    include Arithmetic
+    include Inspectable
+    include PrivateStateAccessor
+    include TypeTransition
+
+    attr_reader :operand1
+    attr_reader :operand2
+    attr_reader :return_type
+
+    def initialize(x,y)
+      @operand1 = x
+      @operand2 = y
+      op1, op2 = op_to_var
+      @return_type, _ = transition(op1, op2, Modulo)
+    end
+
+    def to_s
+      return to_s_fortran if lang == FORTRAN
+      return to_s_c if [C, CL, CUDA].include?( lang )
+    end
+
+    def pr
+      s=""
+      s += indent
+      s += to_s
+      s += ";" if [C, CL, CUDA].include?( lang )
+      output.puts s
+      return self
+    end
+
+    def to_var
+      if @return_type then
+        return @return_type.copy( to_s, DISCARD_OPTIONS )
+      else
+        return Variable::new( to_s, get_default_type )
+      end
+    end
+
+    private
+
+    def to_s_fortran
+      op1, op2 = op_to_var
+      if @return_type and @return_type.type.kind_of?(Real) and ( not op1.type.kind_of?(Real) or not op2.type.kind_of?(Real) ) then
+        return "modulo(real(#{op1}, #{@return_type.type.size}), #{op2})" if not op1.type.kind_of?(Real)
+        return "modulo(#{op1}, real(#{op2}, #{@return_type.type.size}))"
+      else
+        return "modulo(#{op1}, #{op2})"
+      end
+    end
+
+    def to_s_c
+      op1, op2 = op_to_var
+      if @return_type and @return_type.type.kind_of?(Real) then
+        if @return_type.type.size <= 4 then
+          return "((#{op1} < 0) ^ (#{op2} < 0) ? fmodf(#{op1}, #{op2}) + #{op2} : fmodf(#{op1}, #{op2}));"
+        else
+          return "((#{op1} < 0) ^ (#{op2} < 0) ? fmod(#{op1}, #{op2}) + #{op2} : fmod(#{op1}, #{op2}))"
+        end
+      else
+        return "((#{op1} < 0) ^ (#{op2} < 0) ? (#{op1} % #{op2}) + #{op2} : #{op1} % #{op2})"
+      end
+    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
+      return [op1, op2]
+    end
+
+  end
+
   # @!parse module Functors; functorize Ternary; end
   class Ternary
     extend Functor