BOAST 1.0.6 → 1.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c85b9d3cf15ddaa43c8772daa563fc77ffa0e2d8
-  data.tar.gz: 2c3f92c1b64383ef09e28333f882bbeb2f717ee6
+  metadata.gz: f11eacd12c0e6cfa7268db8d77718b8ea7264077
+  data.tar.gz: 2edec679ab6ac265fb66a3190b7693b5cde5fce7
 SHA512:
-  metadata.gz: c48d0c7349a97e7d2ffb7a632e21d01e7af48d69009dbf635d95ba81d22aa76b24321b2d9bf0da83da77d114ccf11dae5272084334bd3aa76a633d339b37fe60
-  data.tar.gz: 12fa72007ca814bff99b9a0e3593113fde333f66a6194b7b853164c8e3e7fa47f9705095e75c37303ee9f60dbaf16eb74a1649be3e46c5889cc9007b5a7f8f1b
+  metadata.gz: 1da1fdca526a8ecc1d82164e4621b271714f82cc210718d6bcd70bb6482c74366ea8e14fdd7f44d7338a8724c68ebb7746ddd2e49d964c978ba94d911cac114c
+  data.tar.gz: 76d2966d546378fa0901656711d76703218649e601534f7da7acfeae2d50e89604737f27924c97888d472ae77f7646596ed474a5fb9c0e87a608237864de0760

data/BOAST.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'BOAST'
-  s.version = "1.0.6"
+  s.version = "1.0.7"
   s.author = "Brice Videau"
   s.email = "brice.videau@imag.fr"
   s.homepage = "https://github.com/Nanosim-LIG/boast"

data/lib/BOAST.rb

@@ -3,6 +3,7 @@ require 'BOAST/Language/Functors.rb'
 require 'BOAST/Language/Inspectable.rb'
 require 'BOAST/Language/Transitions.rb'
 require 'BOAST/Language/Arithmetic.rb'
+require 'BOAST/Language/Intrinsics.rb'
 require 'BOAST/Language/Operators.rb'
 require 'BOAST/Language/DataTypes.rb'
 require 'BOAST/Language/Expression.rb'

data/lib/BOAST/Language/Algorithm.rb

@@ -6,8 +6,8 @@ module BOAST
   C = 2
   CL = 3
   CUDA = 4
-  X86 = 1
-  ARM = 2
+  #X86 = 1
+  #ARM = 2
   MPPA = 3
 
   module PrivateStateAccessor

data/lib/BOAST/Language/DataTypes.rb

@@ -95,7 +95,7 @@ module BOAST
       else
         @vector_length = 1
       end
-      @total_size = @vector_length*@size
+      @total_size = @size*@vector_length
       @signed = true
     end
 
@@ -189,7 +189,7 @@ module BOAST
       else
         @vector_length = 1
       end
-      @total_size = @vector_length*@size
+      @total_size = @size*@vector_length
     end
 
     def to_hash
@@ -351,9 +351,11 @@ module BOAST
       s = indent
       s += decl_c + " {"
       output.puts s
+      increment_indent_level
       @members_array.each { |value|
          value.decl
       }
+      decrement_indent_level
       s = indent
       s += "}"
       s += finalize
@@ -365,9 +367,11 @@ module BOAST
       s = indent
       s += "TYPE :: #{@name}\n"
       output.puts s
+      increment_indent_level
       @members_array.each { |value|
          value.decl
       }
+      decrement_indent_level
       s = indent
       s += "END TYPE #{@name}"
       s += finalize

data/lib/BOAST/Language/Expression.rb

@@ -49,13 +49,13 @@ module BOAST
       if op1 and op2 then
         r_t, oper = transition(op1, op2, @operator)
         res_exp = to_s_base(op1, op2, oper, r_t)
-        return r_t.copy(res_exp, :const => nil, :constant => nil, :direction => nil, :dir => nil)
+        return r_t.copy(res_exp, :const => nil, :constant => nil, :direction => nil, :dir => nil, :align => nil)
       elsif op2
         res_exp = to_s_base(@operand1, op2, @operator)
-        return op2.copy(res_exp, :const => nil, :constant => nil, :direction => nil, :dir => nil)
+        return op2.copy(res_exp, :const => nil, :constant => nil, :direction => nil, :dir => nil, :align => nil)
       elsif op1
         res_exp = to_s_base(op1, @operand2, @operator)
-        return op1.copy(res_exp, :const => nil, :constant => nil, :direction => nil, :dir => nil)
+        return op1.copy(res_exp, :const => nil, :constant => nil, :direction => nil, :dir => nil, :align => nil)
       else
         STDERR.puts "#{@operand1} #{@operand2}"
         raise "Expression on no operand!"

data/lib/BOAST/Language/If.rb

@@ -28,7 +28,7 @@ module BOAST
 
     def get_c_strings
       return { :if => '"if (#{cond}) {"',
-               :else_if => '"} else if (#{cond}) {"',
+               :elsif => '"} else if (#{cond}) {"',
                :else => '"} else {"',
                :end => '"}"' }
     end

data/lib/BOAST/Language/Index.rb

@@ -3,14 +3,19 @@ module BOAST
   class Index < Expression
     attr_reader :source
     attr_reader :indexes
+    attr_accessor :align
 
     def initialize(source, indexes)
       @source = source
       @indexes = indexes
     end
 
+    def align?
+      return !!@align
+    end
+
     def to_var
-      var = @source.copy("#{self}", :const => nil, :constant => nil, :dim => nil, :dimension => nil, :direction => nil, :dir => nil)
+      var = @source.copy("#{self}", :const => nil, :constant => nil, :dim => nil, :dimension => nil, :direction => nil, :dir => nil, :align => align)
       return var
     end
 

data/lib/BOAST/Language/Intrinsics.rb

@@ -0,0 +1,241 @@
+module BOAST
+
+  X86 = 1
+  ARM = 2
+
+  module Intrinsics
+    INTRINSICS = Hash::new { |h, k| h[k] = Hash::new { |h2, k2| h2[k2] = {} } }
+
+    def intrinsics
+      return INTRINSICS
+    end
+
+    module_function :intrinsics
+
+    def get_vector_name( type )
+      s = ""
+      case type
+      when Int
+        s += "u" if type.signed?
+        s += "int"
+      when Real
+        s += "float"
+      else
+        raise "Undefined vector type!"
+      end
+      s += "#{type.size*8}"
+      s += "x#{type.vector_length}"
+      return s.to_sym
+    end
+
+    module_function :get_vector_name
+
+    def vector_type_name( type, size, vector_size, sign = :signed )
+      s = ""
+      case type
+      when :int
+        case sign
+        when :signed
+          s += "int"
+        when :unsigned
+          s += "uint"
+        else
+          raise "Invalid sign!"
+        end
+      when :float
+        s += "float"
+      else
+        raise "Invalid type!"
+      end
+      s += "#{size}"
+      s += "x#{vector_size/size}"
+      return s.to_sym
+    end
+
+    module_function :vector_type_name
+
+    def type_name_ARM( type, size, sign = :signed )
+      s = ""
+      case type
+      when :int
+        case sign
+        when :signed
+          s += "s"
+        when :unsigned
+          s += "u"
+        else
+          raise "Invalid sign!"
+        end
+      when :float
+        s += "f"
+      else
+        raise "Invalid type!"
+      end
+      s += "#{size}"
+      return s
+    end
+
+    module_function :type_name_ARM
+
+    def type_name_X86( type, size, vector_size, sign = :signed )
+      s = ""
+      e = ( vector_size > 64 ? "e" : "" )
+      case type
+      when :int
+        s += "#{e}p"
+        case sign
+        when :signed
+          s += "i"
+        when :unsigned
+          s += "u"
+        else
+          raise "Invalid sign!"
+        end
+        s += "#{size}"
+      when :float
+        s += "p"
+        case size
+        when 32
+          s += "s"
+        when 64
+          s += "d"
+        else
+          raise "Invalid size!"
+        end
+      else
+        raise "Invalid type!"
+      end
+      return s
+    end
+
+    module_function :type_name_X86
+
+    [64, 128, 256].each { |vector_size|
+      vs = ( vector_size < 256 ? "" : "#{vector_size}" )
+      sizes = [8, 16, 32]
+      sizes.push( 64 ) if vector_size > 64
+      sizes.each { |size|
+        [:signed, :unsigned].each { |sign|
+          vtype = vector_type_name( :int, size, vector_size, sign )
+          type = type_name_X86( :int, size, vector_size )
+          instructions = [[:ADD, "add"], [:SUB, "sub"]]
+          instructions.push( [:SET, "setr"], [:SET1, "set1"] )
+          instructions.push( [:MUL, "mullo"] ) if vector_size > 64 and size >= 16 and  size <= 32
+          instructions.each { |cl, ins|
+            INTRINSICS[X86][cl][vtype] = "_mm#{vs}_#{ins}_#{type}".to_sym
+          }
+          if size == 64 and vector_size < 512 then
+            INTRINSICS[X86][:SET1][vtype] = "_mm#{vs}_set1_#{type}x".to_sym
+          end
+        }
+      }
+      [8, 16, 32, 64].each { |size|
+        [:signed, :unsigned].each { |sign|
+          vtype = vector_type_name( :int, size, vector_size, sign )
+          [[:LOAD, "loadu"], [:LOADA, "load"],
+           [:STORE, "storeu"], [:STOREA, "store"]].each { |cl, ins|
+            INTRINSICS[X86][cl][vtype] = "_mm#{vs}_#{ins}_si#{vector_size}".to_sym
+          }
+        }
+      } if vector_size > 64
+      sizes = []
+      sizes.push( 32, 64 ) if vector_size > 64
+      sizes.each { |size|
+        [[:ADD, "add"],       [:SUB, "sub"],           [:MUL, "mul"],       [:DIV, "div"],
+         [:FMADD, "fmadd"],   [:FMSUB, "fmsub"],       [:FNMADD, "fnmadd"], [:FNMSUB, "fnmsub"],
+         [:ADDSUB, "addsub"], [:FMADDSUB, "fmaddsub"], [:FMSUBADD, "fmsubadd"],
+         [:LOAD, "loadu"],    [:LOADA, "load"],
+         [:STORE, "storeu"],  [:STOREA, "store"],
+         [:SET, "set"],       [:SET1, "set1"] ].each { |cl, ins|
+          vtype = vector_type_name( :float, size, vector_size)
+          type = type_name_X86( :float, size, vector_size )
+          INTRINSICS[X86][cl][vtype] = "_mm#{vs}_#{ins}_#{type}".to_sym
+        }
+      }
+    }
+    INTRINSICS[X86][:CVT] = Hash::new { |h,k| h[k] = {} }
+    [128, 256].each { |bvsize|
+      [16, 32, 64].each { |bsize|
+        ssize = bsize/2
+        while ssize >= 8
+          svsize = (bvsize/bsize)*ssize
+          [:signed, :unsigned].each { |sign|
+            stype = type_name_X86( :int, ssize, 128,  sign )
+            btype = type_name_X86( :int, bsize, bvsize, :signed )
+            svtype = vector_type_name( :int, ssize, svsize, sign )
+            bvtype = vector_type_name( :int, bsize, bvsize, :signed )
+            vs = ( bvsize < 256 ? "" : "#{bvsize}" )
+            INTRINSICS[X86][:CVT][bvtype][svtype] = "_mm#{vs}_cvt#{stype}_#{btype}".to_sym
+          }
+          ssize /= 2
+        end
+      }
+    }
+
+
+    [64, 128].each { |vector_size|
+      q = (vector_size == 128 ? "q" : "")
+      [8, 16, 32, 64].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"], [:FNMSUB, "mls"] ) if size < 64
+          instructions.push( [:LOAD, "ldl"], [:LOADA, "ldl"] )
+          instructions.push( [:STORE, "stl"], [:STOREA, "stl"] )
+          instructions.each { |cl, ins|
+            INTRINSICS[ARM][cl][vtype] = "v#{ins}#{q}_#{type}".to_sym
+          }
+          [[:SET1, "dup"]].each { |cl, ins|
+            INTRINSICS[ARM][cl][vtype] = "v#{ins}#{q}_n_#{type}".to_sym
+          }
+          [[:SET_LANE, "set"]].each { |cl, ins|
+            INTRINSICS[ARM][cl][vtype] = "v#{ins}#{q}_lane_#{type}".to_sym
+          }
+        }
+      }
+      [32].each { |size|
+        vtype = vector_type_name( :float, size, vector_size )
+        type = type_name_ARM( :float, size )
+        [[:ADD, "add"], [:SUB, "sub"], [:MUL, "mul"],
+         [:FMADD, "mla"], [:FNMSUB, "mls"],
+         [:LOAD, "ldl"], [:LOADA, "ldl"],
+         [:STORE, "stl"], [:STOREA, "stl"]].each { |cl, ins|
+          INTRINSICS[ARM][cl][vtype] = "v#{ins}#{q}_#{type}".to_sym
+        }
+        [[:SET1, "dup"]].each { |cl, ins|
+          INTRINSICS[ARM][cl][vtype] = "v#{ins}#{q}_n_#{type}".to_sym
+        }
+      }
+    }
+    INTRINSICS[ARM][:CVT] = Hash::new { |h,k| h[k] = {} }
+    [64, 128].each { |vector_size|
+      int_size = 32
+      float_size = 32
+      q = (vector_size == 128 ? "q" : "")
+      [:signed, :unsigned].each { |sign|
+        fvtype = vector_type_name( :float, float_size, vector_size )
+        ivtype = vector_type_name( :int, int_size, vector_size, sign )
+        ftype = type_name_ARM( :float, float_size )
+        itype = type_name_ARM( :int, int_size, sign )
+        INTRINSICS[ARM][:CVT][fvtype][ivtype] = "vcvt#{q}_#{itype}_#{ftype}".to_sym
+        INTRINSICS[ARM][:CVT][ivtype][fvtype] = "vcvt#{q}_#{ftype}_#{itype}".to_sym
+      }
+    }
+    svsize = 64
+    bvsize = 128
+    [16, 32, 64].each { |bsize|
+      ssize = bsize/2
+      [:signed, :unsigned].each { |sign|
+        stype = type_name_ARM( :int, ssize, sign )
+        btype = type_name_ARM( :int, bsize, sign )
+        svtype = vector_type_name( :int, ssize, svsize, sign )
+        bvtype = vector_type_name( :int, bsize, bvsize, sign )
+        INTRINSICS[ARM][:CVT][svtype][bvtype] = "vmovl_#{stype}".to_sym
+        INTRINSICS[ARM][:CVT][bvtype][svtype] = "vmovn_#{btype}".to_sym
+      }
+    }
+
+  end
+
+end

data/lib/BOAST/Language/Operators.rb

@@ -2,113 +2,18 @@ module BOAST
 
   class Operator
     extend PrivateStateAccessor
+    extend Intrinsics
 
     def Operator.inspect
       return "#{name}"
     end
 
-    def Operator.get_vector_name(type)
-      case get_architecture
-      when X86
-        case type
-        when Int
-          size = "#{type.size*8}"
-          name = ""
-          if type.total_size*8 > 64
-            name += "e"
-          end
-          if type.vector_length > 1 then
-            name += "p"
-          else
-            name = "s"
-          end
-          if type.signed then
-            name += "i"
-          else
-            name += "u"
-          end
-          return name += size
-        when Real
-          case type.size
-          when 4
-            return "ps" if type.vector_length > 1
-            return "ss"
-          when 8
-            return "pd" if type.vector_length > 1
-            return "sd"
-          end
-        else
-          raise "Undefined vector type!"
-        end
-      when ARM
-        case type
-        when Int
-          name = "#{ type.signed ? "s" : "u" }"
-          name += "#{ type.size * 8}"
-          return name
-        when Real
-          return "f#{type.size*8}"
-        else
-          raise "Undefined vector type!"
-        end
-      else
-        raise "Unsupported architecture!"
-      end
-    end
-
     def Operator.convert(arg, type)
-      case get_architecture
-      when X86
-        s1 = arg.type.total_size*8
-        s2 = type.total_size*8
-        n1 = get_vector_name(arg.type)
-        n2 = get_vector_name(type)
-        if s1 <= 128 and s2 <= 128 then
-          return "_mm_cvt#{n1}_#{n2}( #{arg} )"
-        elsif [s1, s2].max <= 256 then
-          return "_mm256_cvt#{n1}_#{n2}( #{arg} )"
-        elsif [s1, s2].max <= 512 then
-          return "_mm512_cvt#{n1}_#{n2}( #{arg} )"
-        end
-      when ARM
-        if type.class != arg.type.class then
-          if type.size == arg.type.size then
-            s = type.total_size*8
-            n1 = get_vector_name(arg.type)
-            n2 = get_vector_name(type)
-            return "vcvt#{ s == 128 ? "q" : "" }_#{n2}_#{n1}( #{arg} )"
-          elsif type.class == Real then
-            intr = convert(arg, arg.type.copy(:size=>type.size))
-            return convert(arg.copy(intr, :size => type.size ), type)
-          else
-            n1 = get_vector_name(arg.type)
-            s = type.total_size*8
-            t2 = type.copy(:size => arg.type.size)
-            n2 = get_vector_name( t2 )
-            intr = "vcvt#{ s == 128 ? "q" : "" }_#{n2}_#{n1}( #{arg} )"
-            return convert(Variable::from_type(intr, t2), type)
-          end
-        elsif type.class != Real then
-          n = get_vector_name(arg.type)
-          if type.size == arg.type.size then
-            if type.signed == arg.type.signed then
-              return "#{arg}"
-            else
-              n2 = get_vector_name(type)
-              return "vreinterpret_#{n2}_#{n}( #{arg} )"
-            end
-          elsif type.size < arg.type.size then
-            intr = "vmovn_#{n}( #{arg} )"
-            s = arg.type.size/2
-          else
-            intr = "vmovl_#{n}( #{arg} )"
-            s = arg.type.size*2
-          end
-          return convert(arg.copy(intr, :size => s), type)
-        end
-      else
-        raise "Unsupported architecture!"
-      end
+      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} )"
     end
 
   end
@@ -120,44 +25,11 @@ module BOAST
       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}"
-	return_name = get_vector_name(return_type.type)
-        size = return_type.type.total_size * 8
-        case get_architecture
-        when X86
-          if arg1.type != return_type.type
-            a1 = convert(arg1, return_type.type)
-          else
-            a1 = "#{arg1}"
-          end
-          if arg2.type != return_type.type
-            a2 = convert(arg2, return_type.type)
-          else
-            a2 = "#{arg2}"
-          end
-          intr_name = "_mm"
-          if size > 128 then
-            intr_name += "#{size}"
-          end
-          intr_name += "_#{intr_name_X86}_#{return_name}"
-          return "#{intr_name}( #{a1}, #{a2} )"
-        when ARM
-          if arg1.type.class != return_type.type.class then
-            a1 = convert(arg1, return_type.type)
-          else
-            a1 = "#{arg1}"
-          end
-          if arg2.type.class != return_type.type.class then
-            a2 = convert(arg2, return_type.type)
-          else
-            a2 = "#{arg2}"
-          end
-          intr_name = "#{intr_name_ARM}"
-          intr_name += "q" if size == 128
-          intr_name += "_" + return_name + "( #{a1}, #{a2} )"
-          return intr_name
-        else
-          raise "Unsupported architecture!"
-        end
+        instruction = intrinsics[get_architecture][intr_symbol][get_vector_name(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}" )
+        return "#{instruction}( #{a1}, #{a2} )"
       else
         return basic_usage( arg1, arg2 )
       end
@@ -168,31 +40,34 @@ module BOAST
   class Set < Operator
 
     def Set.to_s(arg1, arg2, return_type)
-      if lang == C then
+      if lang == C or lang == CL then
         if arg1.class == Variable and arg1.type.vector_length > 1 then
-          if 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)})"
-          elsif arg2.type.vector_length == 1 then
-            size = arg1.type.total_size*8
-            case get_architecture
-            when ARM
-              intr_name = "vmov"
-              intr_name += "q" if size == 128
-              intr_name += "_n_#{get_vector_name(arg1.type)}"
-            when X86
-              return "(#{arg1} = _m_from_int64( #{a2} ))" if arg1.type.class == Int and arg1.type.size == 8 and size == 64
-              intr_name = "_mm"
-              if size > 128 then
-                intr_name += "#{size}"
-              end
-              intr_name += "_set1_#{get_vector_name(arg1.type).gsub("u","")}"
-              intr_name += "x" if arg1.type.class == Int and arg1.type.size == 8
+          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
-              raise "Unsupported architecture!"
+              return "#{arg1} = #{instruction}( #{arg2.join(", ")} )"
             end
-            return "(#{arg1} = #{intr_name}( #{arg2} ))"
+          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
@@ -223,111 +98,92 @@ module BOAST
 
   end
 
-  class Affectation < Operator
-
-    def Affectation.to_s(arg1, arg2, return_type)
-      if lang == C then
-        if arg1.class == Variable and arg1.type.vector_length > 1 then
-          #puts "#{arg1.type.vector_length} #{arg2.type.vector_length}"
-          if 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)}"
-          elsif arg2.type.vector_length == 1 then
-            size = arg1.type.total_size*8
-            a2 = "#{arg2}"
-            if a2[0] != "*" then
-              a2 = "&" + a2
-            else
-              a2 = a2[1..-1]
-            end
-            case get_architecture
-            when ARM
-              intr_name = "vldl"
-              intr_name += "q" if size == 128
-              intr_name += "_#{get_vector_name(arg1.type)}"
-            when X86
-              if arg1.type.class == Int and size == 64 then
-                return "#{arg1} = _m_from_int64( *((int64_t * ) #{a2} ) )"
-              end
-              intr_name = "_mm"
-              if size > 128 then
-                intr_name += "#{size}"
-              end
-              intr_name += "_load_"
-              if arg1.type.class == Int then
-                intr_name += "si#{size}"
-              else
-                intr_name += "#{get_vector_name(arg1.type)}"
-              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 "Unsupported architecture!"
+              raise "Unknown convertion between vectors of different length!"
             end
-            return "#{arg1} = #{intr_name}( (#{arg1.type.decl} * ) #{a2} )"
           else
-            raise "Unknown convertion between vectors of different length!"
+            Affectation.basic_usage(arg1, arg2)
           end
-        elsif arg2.class == Variable and arg2.type.vector_length > 1 then
-          size = arg2.type.total_size*8
-          a1 = "#{arg1}"
-          if a1[0] != "*" then
-            a1 = "&" + a1
+        elsif arg2.class == Variable and arg2.type.vector_length == 1 then
+          a2 = "#{arg2}"
+          if a2[0] != "*" then
+            a2 = "&" + a2
           else
-            a1 = a1[1..-1]
+            a2 = a2[1..-1]
           end
-          case get_architecture
-          when ARM
-            intr_name = "vstl"
-            intr_name += "q" if size == 128
-            intr_name += "_#{get_vector_name(arg2.type)}"
-          when X86
-            if arg2.type.class == Int and size == 64 then
-              return " *((int64_t * ) #{a1}) = _m_to_int64( #{arg2} )"
-            end
-            intr_name = "_mm"
-            if size > 128 then
-              intr_name += "#{size}"
-            end
-            intr_name += "_store_"
-            if arg2.type.class == Int then
-              intr_name += "si#{size}"
-            else
-              intr_name += "#{get_vector_name(arg2.type)}"
-            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
-            raise "Unsupported architecture!"
+            instruction = intrinsics[get_architecture][:LOAD][get_vector_name(return_type.type)]
           end
-          return "#{intr_name}((#{arg2.type.decl} * ) #{a1}, #{arg2} )"
+          raise "Unavailable operator load for #{get_vector_name(return_type.type)}!" unless instruction
+          return "#{instruction}( #{a2} )"
         else
-          return basic_usage(arg1, arg2)
+          return "#{arg2}"
         end
-      elsif lang == CL then
-        if arg1.class == Variable and arg1.type.vector_length > 1 then
-          if arg2.class == Variable and arg2.type.vector_length == arg1.type.vector_length then
-            return "#{arg1} = convert_#{arg1.type.decl}(#{arg2})"
-          else
-            a2 = "#{arg2}"
-            if a2[0] != "*" then
-              a2 = "&" + a2
-            else
-              a2 = a2[1..-1]
-            end
-            return "#{arg1} = vload#{arg1.type.vector_length}(0, #{a2})"
-          end
-        elsif arg2.class == Variable and arg2.type.vector_length > 1 then
-          a1 = "#{arg1}"
-          if a1[0] != "*" then
-            a1 = "&" + a1
-          else
-            a1 = a1[1..-1]
-          end
-          return "vstore#{arg2.type.vector_length}(#{arg2}, 0, #{a1})"
+      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
-          return basic_usage(arg1, arg2)
+          a1 = a1[1..-1]
         end
-      else
-        return basic_usage(arg1, arg2)
+
+        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)
+      elsif arg2.class == Variable and arg2.type.vector_length > 1 then
+        return Store.to_s(arg1, arg2, return_type)
+      end
+      return basic_usage(arg1, arg2)
     end
 
     def Affectation.basic_usage(arg1, arg2)
@@ -344,12 +200,8 @@ module BOAST
         return "*"
       end
 
-      def intr_name_X86
-        return "mul"
-      end
-
-      def intr_name_ARM
-        return "vmul"
+      def intr_symbol
+        return :MUL
       end
 
       def basic_usage(arg1, arg2)
@@ -368,14 +220,10 @@ module BOAST
         return "+"
       end
 
-      def intr_name_X86
-        return "add"
+      def intr_symbol
+        return :ADD
       end
   
-      def intr_name_ARM
-        return "vadd"
-      end
-
       def basic_usage(arg1, arg2)
         return "#{arg1} + #{arg2}" 
       end
@@ -392,14 +240,10 @@ module BOAST
         return "-"
       end
 
-      def intr_name_X86
-        return "sub"
+      def intr_symbol
+        return :SUB
       end
   
-      def intr_name_ARM
-        return "vsub"
-      end
-
       def basic_usage(arg1, arg2)
         return "#{arg1} - (#{arg2})" 
       end
@@ -416,14 +260,10 @@ module BOAST
         return "/"
       end
 
-      def intr_name_X86
-        return "div"
+      def intr_symbol
+        return :DIV
       end
   
-      def intr_name_ARM
-        raise "Neon doesn't support division!"
-      end
-
       def basic_usage(arg1, arg2)
         return "(#{arg1}) / (#{arg2})" 
       end

data/lib/BOAST/Language/Procedure.rb

@@ -89,22 +89,23 @@ module BOAST
     end
 
     def close_c
-      decrement_indent_level
       s = ""
-      s += "  return #{@properties[:return]};\n" if @properties[:return]
-      s += "}"
+      s += indent + "return #{@properties[:return]};\n" if @properties[:return]
+      decrement_indent_level
+      s += indent + "}"
       output.puts s
       return self
     end
 
     def close_fortran
-      decrement_indent_level
       s = ""
       if @properties[:return] then
-        s += "  #{@name} = #{@properties[:return]}\n"
-        s += "END FUNCTION #{@name}"
+        s += indent + "#{@name} = #{@properties[:return]}\n"
+        decrement_indent_level
+        s += indent + "END FUNCTION #{@name}"
       else
-        s += "END SUBROUTINE #{@name}"
+        decrement_indent_level
+        s += indent + "END SUBROUTINE #{@name}"
       end
       output.puts s
       return self
@@ -125,7 +126,13 @@ module BOAST
     end
 
     def decl_fortran
-      raise "Interfaces are not implemented in FORTRAN yet!"
+      output.puts indent + "INTERFACE"
+      increment_indent_level
+      open_fortran
+      close_fortran
+      decrement_indent_level
+      output.puts indent + "END INTERFACE"
+      return self
     end
 
     def decl_c_s
@@ -152,6 +159,13 @@ module BOAST
             s += "__launch_bounds__(#{wgs[0]}*#{wgs[1]}*#{wgs[2]}) "
           end
         end
+      elsif lang == C then
+        if @properties[:local] then
+          s += "static "
+        end
+        if @properties[:inline] then
+          s+= "inline "
+        end
       end
       if @properties[:qualifiers] then
         s += "#{@properties[:qualifiers]} "
@@ -173,7 +187,7 @@ module BOAST
     end
 
     def decl_c
-      s = decl_c_s + ";"
+      s = indent + decl_c_s + ";"
       output.puts s
       return self
     end
@@ -196,10 +210,13 @@ module BOAST
         s += "SUBROUTINE "
       end
       s += "#{@name}("
-      s += parameters.join(", ")
+      s += parameters.collect(&:name).join(", ")
       s += ")"
     end
 
+    def pr_align
+    end
+
     def open_c
       s = decl_c_s + "{"
       output.puts s
@@ -209,14 +226,14 @@ module BOAST
       }
       if lang == C then
         parameters.each { |p|
-          p.align
+          p.pr_align
         }
       end
       return self
     end
 
     def open_fortran
-      s = to_s_fortran
+      s = indent + to_s_fortran
       s += "\n"
       increment_indent_level
       s += indent + "integer, parameter :: wp=kind(1.0d0)"
@@ -226,7 +243,7 @@ module BOAST
       }
       parameters.each { |p|
         p.decl
-        p.align
+        p.pr_align
       }
       return self
     end

data/lib/BOAST/Language/Variable.rb

@@ -137,7 +137,9 @@ module BOAST
     attr_reader :texture
     attr_reader :sampler
     attr_reader :restrict
-    attr_reader :align
+    attr_reader :deferred_shape
+    attr_reader :optional
+    attr_accessor :align
     attr_accessor :replace_constant
     attr_accessor :force_replace_constant
 
@@ -177,10 +179,18 @@ module BOAST
       !!@scalar_output
     end
 
+    def optional?
+      !!@optional
+    end
+
     def align?
       !!@align
     end
 
+    def deferred_shape?
+      !!@deferred_shape
+    end
+
     def initialize(name,type,hash={})
       @name = name.to_s
       @direction = hash[:direction] ? hash[:direction] : hash[:dir]
@@ -191,6 +201,8 @@ module BOAST
       @allocate = hash[:allocate]
       @restrict = hash[:restrict]
       @align = hash[:align]
+      @deferred_shape = hash[:deferred_shape]
+      @optional = hash[:optional]
       @force_replace_constant = false
       if not hash[:replace_constant].nil? then
         @replace_constant = hash[:replace_constant]
@@ -303,7 +315,7 @@ module BOAST
       return s
     end
 
-    def decl_ffi(alloc = false)
+    def decl_ffi(alloc, lang)
       return :pointer if lang == FORTRAN and not alloc
       return :pointer if dimension?
       return :pointer if @direction == :out or @direction == :inout and not alloc
@@ -335,7 +347,7 @@ module BOAST
         }.join("][")
         s += "]"
       else
-        if dimension? and not constant? and not allocate? and (not local? or (local? and device)) then
+        if dimension? and not constant? and not ( allocate? and @allocate != :heap ) and (not local? or (local? and device)) then
           s += " *"
           if restrict? and not decl_module? then
             if lang == CL
@@ -352,13 +364,13 @@ module BOAST
         if dimension? and constant? then
           s += "[]"
         end
-        if dimension? and ((local? and not device) or (allocate? and not constant?)) then
+        if dimension? and ((local? and not device) or ( ( allocate? and @allocate != :heap ) and not constant?)) then
           s +="[("
           s += @dimension.collect{ |d| d.to_s }.reverse.join(")*(")
           s +=")]"
         end 
       end
-      if dimension? and (align? or default_align > 1) and (constant? or allocate?) then
+      if dimension? and (align? or default_align > 1) and (constant? or (allocate? and @allocate != :heap ) ) then
         a = ( align? ? align : 1 )
         a = ( a >= default_align ? a : default_align )
         s+= " __attribute((aligned(#{a})))"
@@ -399,54 +411,111 @@ module BOAST
       return self
     end
 
-    def align_c_s(a)
+    def pr_align_c_s(a)
       return "__assume_aligned(#{@name}, #{a})"
     end
 
-    def align_c(a)
+    def pr_align_c(a)
       s = ""
       s += indent
-      s += align_c_s(a)
+      s += pr_align_c_s(a)
       s += finalize
       output.print s
       return self
     end
 
-    def align_fortran_s(a)
+    def pr_align_fortran_s(a)
       return "!DIR$ ASSUME_ALIGNED #{@name}: #{a}"
     end
 
-    def align_fortran(a)
+    def pr_align_fortran(a)
       s = ""
       s += indent
-      s += align_fortran_s(a)
+      s += pr_align_fortran_s(a)
       s += finalize
       output.print s
       return self
     end
 
-    def align
+    def pr_align
       if dimension? then
         if align? or default_align > 1 then
           a = ( align? ? align : 1 )
           a = ( a >= default_align ? a : default_align )
-          return align_c(a) if lang == C
-          return align_fortran(a) if lang == FORTRAN
+          return pr_align_c(a) if lang == C
+          return pr_align_fortran(a) if lang == FORTRAN
         end
       end
     end
 
+    def alloc_fortran( dims = nil )
+      s = ""
+      s += indent
+      s += "allocate( #{name}("
+      s += dims.collect { |d| d.to_s }.join(", ")
+      s += ") )"
+      s += finalize
+      output.print s
+      return self
+    end
+
+    def alloc_c( dims = nil )
+      s = ""
+      s += indent
+      s += "#{name} = (#{@type.decl} *)malloc( sizeof(#{@type.decl})*("
+      s += dims.collect { |d| d.to_s }.reverse.join(")*(")
+      s += ") )"
+      s += finalize
+      output.print s
+      return self
+    end
+
+    def alloc( dims = nil )
+      @dimension = [dims].flatten if dims
+      dims = @dimension
+      raise "Cannot allocate array with unknown dimension!" unless dims
+      return alloc_fortran(dims) if lang == FORTRAN
+      return alloc_c(dims) if lang == C
+    end
+
+    def dealloc_fortran
+      s = ""
+      s += indent
+      s += "deallocate( #{name} )"
+      s += finalize
+      output.print s
+      return self
+    end
+
+    def dealloc_c
+      s = ""
+      s += indent
+      s += "free( #{name} )"
+      s += finalize
+      output.print s
+      return self
+    end
+
+    def dealloc
+      return dealloc_fortran if lang == FORTRAN
+      return dealloc_c if lang == C
+    end
+
     def decl_fortran
       s = ""
       s += indent
       s += @type.decl
-      s += ", intent(#{@direction})" if @direction 
+      s += ", intent(#{@direction})" if @direction
+      s += ", optional" if optional?
+      s += ", allocatable" if allocate? and @allocate == :heap
       s += ", parameter" if constant?
       if dimension? then
         s += ", dimension("
         s += @dimension.collect { |d|
           dim = d.to_s
-          if dim then
+          if deferred_shape? or ( allocate? and @allocate == :heap )
+            ":"
+          elsif dim then
             dim.to_s
           else
             "*"
@@ -461,7 +530,7 @@ module BOAST
       end
       s += finalize
       output.print s
-      if dimension? and (align? or default_align > 1) and (constant? or allocate?) then
+      if dimension? and (align? or default_align > 1) and (constant? or ( allocate? and @allocate != :heap ) ) then
         a = ( align? ? align : 1 )
         a = ( a >= default_align ? a : default_align )
         s = ""

data/lib/BOAST/Language/Vector.rb

@@ -0,0 +1,6 @@
+module BOAST
+
+  module Vector
+  end
+
+end

data/lib/BOAST/Runtime/CKernel.rb

@@ -6,6 +6,7 @@ require 'systemu'
 require 'yaml'
 require 'pathname'
 require 'os'
+require 'narray_ffi'
 
 module BOAST
 

data/lib/BOAST/Runtime/CRuntime.rb

@@ -10,6 +10,9 @@ module BOAST
 
     def fill_library_source
       fill_library_header
+      @kernels.each { |k|
+        k.procedure.boast_header
+      }
       @code.rewind
       get_output.write @code.read
     end

data/lib/BOAST/Runtime/Config.rb

@@ -18,6 +18,7 @@ module BOAST
     :CLDEVICE => nil,
     :CLDEVICETYPE => nil,
     :MAQAO => 'maqao',
+    :MAQAO_FLAGS => '',
     :openmp => false
   }
   

data/lib/BOAST/Runtime/FFIRuntime.rb

@@ -29,7 +29,7 @@ module BOAST
       module #{module_name}
         extend FFI::Library
         ffi_lib "#{library_path}"
-        attach_function :#{method_name}, [ #{@procedure.parameters.collect{ |p| ":"+p.decl_ffi.to_s }.join(", ")} ], :#{@procedure.properties[:return] ? @procedure.properties[:return].type.decl_ffi : "void" }
+        attach_function :#{method_name}, [ #{@procedure.parameters.collect{ |p| ":"+p.decl_ffi(false,@lang).to_s }.join(", ")} ], :#{@procedure.properties[:return] ? @procedure.properties[:return].type.decl_ffi(false,@lang) : "void" }
         def run(*args)
           if args.length < @procedure.parameters.length or args.length > @procedure.parameters.length + 1 then
             raise "Wrong number of arguments for \#{@procedure.name} (\#{args.length} for \#{@procedure.parameters.length})"
@@ -47,9 +47,9 @@ module BOAST
             r_args = {}
             if @lang == FORTRAN then
               @procedure.parameters.each_with_index { |p, i|
-                if p.decl_ffi(true) != :pointer then
-                  arg_p = FFI::MemoryPointer::new(p.decl_ffi(true))
-                  arg_p.send("write_\#{p.decl_ffi(true)}",args[i])
+                if p.decl_ffi(true,@lang) != :pointer then
+                  arg_p = FFI::MemoryPointer::new(p.decl_ffi(true, @lang))
+                  arg_p.send("write_\#{p.decl_ffi(true, @lang)}",args[i])
                   t_args.push(arg_p)
                   r_args[p] = arg_p if p.scalar_output?
                 else
@@ -59,8 +59,8 @@ module BOAST
             else
               @procedure.parameters.each_with_index { |p, i|
                 if p.scalar_output? then
-                  arg_p = FFI::MemoryPointer::new(p.decl_ffi(true))
-                  arg_p.send("write_\#{p.decl_ffi(true)}",args[i])
+                  arg_p = FFI::MemoryPointer::new(p.decl_ffi(true, @lang))
+                  arg_p.send("write_\#{p.decl_ffi(true,@lang)}",args[i])
                   t_args.push(arg_p)
                   r_args[p] = arg_p
                 else
@@ -87,7 +87,7 @@ module BOAST
             if r_args.length > 0 then
               ref_return = {}
               r_args.each { |p, p_arg|
-                ref_return[p.name.to_sym] = p_arg.send("read_\#{p.decl_ffi(true)}")
+                ref_return[p.name.to_sym] = p_arg.send("read_\#{p.decl_ffi(true, @lang)}")
               }
               results[:reference_return] = ref_return
             end

data/lib/BOAST/Runtime/MAQAO.rb

@@ -16,9 +16,9 @@ module BOAST
       f2.close
 
       if verbose? then
-        puts "#{compiler_options[:MAQAO]} cqa #{f1.path} --fct=#{@procedure.name}"
+        puts "#{compiler_options[:MAQAO]} cqa #{f1.path} --fct=#{@procedure.name} #{compiler_options[:MAQAO_FLAGS]}"
       end
-      result = `#{compiler_options[:MAQAO]} cqa #{f1.path} --fct=#{@procedure.name}`
+      result = `#{compiler_options[:MAQAO]} cqa #{f1.path} --fct=#{@procedure.name} #{compiler_options[:MAQAO_FLAGS]}`
       File::unlink(library_object)
       File::unlink(library_source)
       return result

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: BOAST
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.0.7
 platform: ruby
 authors:
 - Brice Videau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-24 00:00:00.000000000 Z
+date: 2015-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: narray
@@ -188,6 +188,7 @@ files:
 - lib/BOAST/Language/If.rb
 - lib/BOAST/Language/Index.rb
 - lib/BOAST/Language/Inspectable.rb
+- lib/BOAST/Language/Intrinsics.rb
 - lib/BOAST/Language/OpenMP.rb
 - lib/BOAST/Language/Operators.rb
 - lib/BOAST/Language/Optimization.rb
@@ -199,6 +200,7 @@ files:
 - lib/BOAST/Language/State.rb
 - lib/BOAST/Language/Transitions.rb
 - lib/BOAST/Language/Variable.rb
+- lib/BOAST/Language/Vector.rb
 - lib/BOAST/Language/While.rb
 - lib/BOAST/Runtime/CKernel.rb
 - lib/BOAST/Runtime/CRuntime.rb