BOAST 0.6 → 0.7

data/BOAST.gemspec

@@ -1,12 +1,12 @@
 Gem::Specification.new do |s|
   s.name = 'BOAST'
-  s.version = "0.6"
+  s.version = "0.7"
   s.author = "Brice Videau"
   s.email = "brice.videau@imag.fr"
   s.homepage = "https://forge.imag.fr/projects/boast/"
   s.summary = "BOAST is a computing kernel metaprogramming tool."
   s.description = "BOAST aims at providing a framework to metaprogram, benchmark and validate computing kernels"
-  s.files = %w( BOAST.gemspec LICENSE lib/BOAST.rb lib/BOAST/Algorithm.rb lib/BOAST/CKernel.rb lib/BOAST/BOAST_OpenCL.rb lib/BOAST/Transitions.rb lib/BOAST/Parens.rb)
+  s.files = %w( BOAST.gemspec LICENSE lib/BOAST.rb lib/BOAST/Algorithm.rb lib/BOAST/CKernel.rb lib/BOAST/BOAST_OpenCL.rb lib/BOAST/Transitions.rb lib/BOAST/Parens.rb lib/BOAST/Operators.rb lib/BOAST/DataTypes.rb )
   s.has_rdoc = true
   s.license = 'BSD'
   s.required_ruby_version = '>= 1.9.3'

data/lib/BOAST.rb

@@ -1,4 +1,6 @@
 require 'BOAST/Transitions.rb'
+require 'BOAST/Operators.rb'
+require 'BOAST/DataTypes.rb'
 require 'BOAST/Algorithm.rb'
 require 'BOAST/CKernel.rb'
 require 'BOAST/Parens.rb'

data/lib/BOAST/Algorithm.rb

@@ -6,6 +6,8 @@ module BOAST
   C = 2
   CL = 3
   CUDA = 4
+  X86 = 1
+  ARM = 2
   @@output = STDOUT
   @@lang = FORTRAN
   @@replace_constants = true
@@ -16,6 +18,7 @@ module BOAST
   @@indent_increment = 2
   @@array_start = 1
   @@chain_code = false
+  @@architecture = X86
 
   @@env = Hash.new{|h, k| h[k] = []}
 
@@ -55,6 +58,14 @@ module BOAST
     a.close
   end
 
+  def BOAST::set_architecture(arch)
+    @@architecture = arch
+  end
+
+  def BOAST::get_architecture
+    return @@architecture
+  end
+
   def BOAST::set_indent_level(level)
     @@indent_level = level
   end
@@ -199,7 +210,7 @@ module BOAST
     end
 
     def ===(x)
-      return Expression::new("=",self,x)
+      return Expression::new(BOAST::Affectation,self,x)
     end
 
     def ==(x)
@@ -207,7 +218,7 @@ module BOAST
     end
  
     def +(x)
-      return Expression::new("+",self,x)
+      return Expression::new(BOAST::Addition,self,x)
     end
  
     def >(x)
@@ -223,11 +234,11 @@ module BOAST
     end
  
     def *(x)
-      return Expression::new("*",self,x)
+      return Expression::new(BOAST::Multiplication,self,x)
     end
 
     def /(x)
-      return Expression::new("/",self,x)
+      return Expression::new(BOAST::Division,self,x)
     end
  
     def dereference
@@ -239,18 +250,19 @@ module BOAST
     end
  
     def -(x)
-      return Expression::new("-",self,x)
+      return Expression::new(BOAST::Substraction,self,x)
     end
 
     def !
-      return Expression::new("!",nil,self)
+      return Expression::new(BOAST::Not,nil,self)
     end
  
     def -@
-      return Expression::new("-",nil,self)
+      return Expression::new(BOAST::Minus,nil,self)
     end
 
-    def Expression.to_str_base(op1, op2, oper)
+    def Expression.to_str_base(op1, op2, oper, return_type = nil)
+      return oper.to_s(op1,op2, return_type) if not oper.kind_of?(String)
       s = ""
       if op1 then
         s += "(" if (oper == "*" or oper == "/") 
@@ -275,7 +287,7 @@ module BOAST
       op2 = @operand2.to_var if @operand2.respond_to?(:to_var)
       if op1 and op2 then
         r_t, oper = BOAST::transition(op1, op2, @operator)
-        res_exp = BOAST::Expression::to_str_base(op1, op2, oper)
+        res_exp = BOAST::Expression::to_str_base(op1, op2, oper, r_t)
         return r_t.copy(res_exp, :const => nil, :constant => nil)
       elsif op2
         res_exp = BOAST::Expression::to_str_base(@operand1, op2, @operator)
@@ -294,16 +306,17 @@ module BOAST
       op1 = @operand1.to_var if @operand1.respond_to?(:to_var)
       op2 = nil
       op2 = @operand2.to_var if @operand2.respond_to?(:to_var)
+      r_t = nil
       if op1 and op2 then
         r_t, oper = BOAST::transition(op1, op2, @operator)
       else
         oper = @operator
       end
 
-      op1 = @operand1 if not op1
-      op2 = @operand2 if not op2
+      op1 = @operand1 if op1.nil?
+      op2 = @operand2 if op2.nil?
 
-      return BOAST::Expression::to_str_base(op1, op2, oper)
+      return BOAST::Expression::to_str_base(op1, op2, oper, r_t)
     end
 
     def print(final=true)
@@ -316,24 +329,6 @@ module BOAST
     end
   end
 
-  class Mult < Expression
-    def initialize(operand1, operand2)
-      super("*", operand1, operand2)
-    end
-  end
-
-  class Add < Expression
-    def initialize(operand1, operand2)
-      super("+", operand1, operand2)
-    end
-  end
-
-  class Affect < Expression
-    def initialize(operand1, operand2)
-      super("=", operand1, operand2)
-    end
-  end
-
   class Index < Expression
     attr_reader :source
     attr_reader :indexes
@@ -454,94 +449,14 @@ module BOAST
     end
   end
 
-  class CStruct
-    attr_reader :name, :members, :members_array
-    def self.parens(*args,&block)
-      return Variable::new(args[0], self, *args[1..-1], &block)
-    end
-
-    def initialize(hash={})
-      @name = hash[:type_name]
-      @members = {}
-      @members_array = []
-      hash[:members].each { |m|
-        mc = m.copy
-        @members_array.push(mc)
-        @members[mc.name] = mc
-      }
-    end
-
-    def decl
-      return "struct #{@name}" if [C, CL, CUDA].include?( BOAST::get_lang )
-      return "TYPE(#{@name})" if BOAST::get_lang == FORTRAN
-    end
-
-    def finalize
-       s = ""
-       s += ";" if [C, CL, CUDA].include?( BOAST::get_lang )
-       s+="\n"
-       return s
-    end
-
-    def indent
-       return " "*BOAST::get_indent_level
-    end
-
-    def header
-      return header_c if [C, CL, CUDA].include?( BOAST::get_lang )
-      return header_fortran if BOAST::get_lang == FORTRAN
-      raise "Unsupported language!"
-    end
-
-    def header_c(final = true)
-      s = ""
-      s += self.indent if final
-      s += self.decl + " {\n"
-      @members_array.each { |value|
-         s+= self.indent if final
-         s+= " "*BOAST::get_indent_increment + value.decl(false)+";\n"
-      }
-      s += self.indent if final
-      s += "}"
-      s += self.finalize if final
-      BOAST::get_output.print s if final
-      return s
-    end
-    
-    def header_fortran(final = true)
-      s = ""
-      s += self.indent if final
-      s += "TYPE :: #{@name}\n"
-      members_array.each { |value|
-         s+= self.indent if final
-         s+= " "*BOAST::get_indent_increment + value.decl(false)+"\n"
-      }
-      s += self.indent if final
-      s += "END TYPE #{@name}"
-      s += self.finalize if final
-      BOAST::get_output.print s if final
-      return s
-    end
-
-  end
-  class CustomType
-    attr_reader :size, :name, :vector_length
-    def initialize(hash={})
-      @name = hash[:type_name]
-      @size = hash[:size]
-      @vector_length = hash[:vector_length]
-    end
-    def decl
-      return "#{@name}" if [C, CL, CUDA].include?( BOAST::get_lang )
-    end
-  end
-
 
   class Variable
     alias_method :orig_method_missing, :method_missing
 
     def method_missing(m, *a, &b)
       return self.struct_reference(type.members[m.to_s]) if type.members[m.to_s]
+#      return self.get_element(m.to_s) if type.getters[m.to_s]
+#      return self.set_element(m.to_s) if type.setters[m.to_s]
       return self.orig_method_missing(m, *a, &b)
     end
 
@@ -558,6 +473,7 @@ module BOAST
     attr_reader :local
     attr_reader :texture
     attr_reader :sampler
+    attr_reader :restrict
     attr_accessor :replace_constant
     attr_accessor :force_replace_constant
 
@@ -569,6 +485,7 @@ module BOAST
       @local = hash[:local] ? hash[:local] : hash[:shared]
       @texture = hash[:texture]
       @allocate = hash[:allocate]
+      @restrict = hash[:restrict]
       @force_replace_constant = false
       if not hash[:replace_constant].nil? then
         @replace_constant = hash[:replace_constant]
@@ -591,6 +508,14 @@ module BOAST
       }
       return Variable::new(name, @type.class, hash)
     end
+
+    def Variable.from_type(name, type, options={})
+      hash = type.to_hash
+      options.each { |k,v|
+        hash[k] = v
+      }
+      return Variable::new(name, type.class, hash)
+    end
   
     def to_s
       self.to_str
@@ -609,8 +534,12 @@ module BOAST
       return self
     end
 
+    def set(x)
+      return Expression::new(BOAST::Set, self, x)
+    end
+
     def ===(x)
-      return Expression::new("=",self,x)
+      return Expression::new(BOAST::Affectation,self,x)
     end
  
     def ==(x)
@@ -630,27 +559,27 @@ module BOAST
     end
  
     def +(x)
-      return Expression::new("+",self,x)
+      return Expression::new(BOAST::Addition,self,x)
     end
  
     def *(x)
-      return Expression::new("*",self,x)
+      return Expression::new(BOAST::Multiplication,self,x)
     end
  
     def /(x)
-      return Expression::new("/",self,x)
+      return Expression::new(BOAST::Division,self,x)
     end
  
     def -(x)
-      return Expression::new("-",self,x)
+      return Expression::new(BOAST::Substraction,self,x)
     end
 
     def !
-      return Expression::new("!",nil,self)
+      return Expression::new(BOAST::Not,nil,self)
     end
  
     def -@
-      return Expression::new("-",nil,self)
+      return Expression::new(BOAST::Minus,nil,self)
     end
 
     def address
@@ -658,7 +587,9 @@ module BOAST
     end
    
     def dereference
-      return Expression::new("*",nil,self)
+      return self.copy("*(#{self.name})", :dimension => false, :dim => false) if [C, CL, CUDA].include?( BOAST::get_lang )
+      return self if BOAST::get_lang == FORTRAN
+      #return Expression::new("*",nil,self)
     end
    
     def struct_reference(x)
@@ -696,6 +627,13 @@ module BOAST
       s += @type.decl
       if(@dimension and not @constant and not @allocate and (not @local or (@local and device))) then
         s += " *"
+        if @restrict then
+          if BOAST::get_lang == CL
+            s += " restrict"
+          else
+            s += " __restrict__"
+          end
+        end
       end
       s += " #{@name}"
       if @dimension and @constant then
@@ -806,38 +744,6 @@ module BOAST
 
   end
 
-
-
-  class Real
-    def self.parens(*args,&block)
-      return Variable::new(args[0], self, *args[1..-1], &block)
-    end
-
-    attr_reader :size
-    def initialize(hash={})
-      if hash[:size] then
-        @size = hash[:size]
-      else
-        @size = BOAST::get_default_real_size
-      end
-      if hash[:vector_length] and hash[:vector_length] > 1 then
-        @vector_length = hash[:vector_length]
-      else
-        @vector_length = 1
-      end
-    end
-    def decl
-      return "real(kind=#{@size})" if BOAST::get_lang == FORTRAN
-      if [C, CL, CUDA].include?( BOAST::get_lang ) and @vector_length == 1 then
-        return "float" if @size == 4
-        return "double" if @size == 8
-      elsif [CL, CUDA].include?(BOAST::get_lang) and @vector_length > 1 then
-        return "float#{@vector_length}" if @size == 4
-        return "double#{@vector_length}" if @size == 8
-      end
-    end
-  end
-
   class CodeBlock
      def initialize(&block)
        @block = block
@@ -968,18 +874,25 @@ module BOAST
       if BOAST::get_lang == CL then
         if not @properties[:local] then
           s += "__kernel "
-        end
-        wgs = @properties[:reqd_work_group_size]
-        if wgs then
-          s += "__attribute__((reqd_work_group_size(#{wgs[0]},#{wgs[1]},#{wgs[2]}))) "
+          wgs = @properties[:reqd_work_group_size]
+          if wgs then
+            s += "__attribute__((reqd_work_group_size(#{wgs[0]},#{wgs[1]},#{wgs[2]}))) "
+          end
         end
       elsif BOAST::get_lang == CUDA then
         if @properties[:local] then
-          s += "__device__ "
+          s += "static __device__ "
         else
           s += "__global__ "
+          wgs = @properties[:reqd_work_group_size]
+          if wgs then
+            s += "__launch_bounds__(#{wgs[0]}*#{wgs[1]}*#{wgs[2]}) "
+          end
         end
       end
+      if @properties[:qualifiers] then
+        s += "#{@properties[:qualifiers]} "
+      end
       if @properties[:return] then
         s += "#{@properties[:return].type.decl} "
       else
@@ -1077,67 +990,6 @@ module BOAST
     end
   end
 
-  class Sizet
-    def self.parens(*args,&block)
-      return Variable::new(args[0], self, *args[1..-1], &block)
-    end
-
-    attr_reader :signed
-    def initialize(hash={})
-      if hash[:signed] != nil then
-        @signed = hash[:signed]
-      end
-    end
-    def decl
-      return "integer(kind=#{BOAST::get_default_int_size})" if BOAST::get_lang == FORTRAN
-      if not @signed then
-        return "size_t" if [C, CL, CUDA].include?( BOAST::get_lang )
-      else
-        return "ptrdiff_t" if [C, CL, CUDA].include?( BOAST::get_lang )
-      end
-    end
-  end
- 
-  class Int
-    def self.parens(*args,&block)
-      return Variable::new(args[0], self, *args[1..-1], &block)
-    end
-
-    attr_reader :size
-    attr_reader :signed
-    def initialize(hash={})
-      if hash[:size] then
-        @size = hash[:size]
-      else
-        @size = BOAST::get_default_int_size
-      end
-      if hash[:signed] != nil then
-        @signed = hash[:signed]
-      else
-        @signed = BOAST::get_default_int_signed
-      end
-    end
-    def decl
-      return "integer(kind=#{@size})" if BOAST::get_lang == FORTRAN
-      return "int#{8*@size}_t" if BOAST::get_lang == C
-      if BOAST::get_lang == CL then
-        #char="cl_"
-        char=""
-        char += "u" if not @signed
-        return char += "char" if @size==1
-        return char += "short" if @size==2
-        return char += "int" if @size==4
-        return char += "long" if @size==8
-      elsif BOAST::get_lang == CUDA then
-        char = ""
-        char += "unsigned " if not @signed
-        return char += "char" if @size==1
-        return char += "short" if @size==2
-        return char += "int" if @size==4
-        return char += "long long" if @size==8
-      end
-    end
-  end
 
   class ConstArray < Array
     def initialize(array,type = nil)

data/lib/BOAST/DataTypes.rb

@@ -0,0 +1,318 @@
+module BOAST
+
+  class Sizet
+    def self.parens(*args,&block)
+      return Variable::new(args[0], self, *args[1..-1], &block)
+    end
+
+    attr_reader :signed
+    attr_reader :size
+    attr_reader :vector_length
+    def initialize(hash={})
+      if hash[:signed] != nil then
+        @signed = hash[:signed]
+      end
+      @size = nil
+      @vector_length = 1
+    end
+
+    def to_hash
+      return { :signed => @signed }
+    end
+
+    def copy(options={})
+      hash = self.to_hash
+      options.each { |k,v|
+        hash[k] = v
+      }
+      return Sizet::new(hash)
+    end
+
+    def decl
+      return "integer(kind=#{BOAST::get_default_int_size})" if BOAST::get_lang == FORTRAN
+      if not @signed then
+        return "size_t" if [C, CL, CUDA].include?( BOAST::get_lang )
+      else
+        return "ptrdiff_t" if [C, CL, CUDA].include?( BOAST::get_lang )
+      end
+    end
+  end
+ 
+  class Real
+    def self.parens(*args,&block)
+      return Variable::new(args[0], self, *args[1..-1], &block)
+    end
+
+    attr_reader :size
+    attr_reader :signed
+    attr_reader :vector_length
+    attr_reader :total_size
+    attr_reader :getters
+    attr_reader :setters
+
+    def ==(t)
+      return true if t.class == self.class and t.size == self.size and t.vector_length == self.vector_length
+      return false
+    end
+
+    def initialize(hash={})
+      if hash[:size] then
+        @size = hash[:size]
+      else
+        @size = BOAST::get_default_real_size
+      end
+#      @getters = {}
+#      @setters = {}
+      if hash[:vector_length] and hash[:vector_length] > 1 then
+        @vector_length = hash[:vector_length]
+#        @vector_length.times{ |indx|
+#          @getters["s#{indx}"] = indx
+#          @setters["s#{indx}="] = indx
+#        }
+      else
+        @vector_length = 1
+      end
+      @total_size = @vector_length*@size
+      @signed = true
+    end
+
+    def to_hash
+      return { :size => @size, :vector_length => @vector_length }
+    end
+
+    def copy(options={})
+      hash = to_hash
+      options.each { |k,v|
+        hash[k] = v
+      }
+      return Real::new(hash)
+    end
+
+    def decl
+      return "real(kind=#{@size})" if BOAST::get_lang == FORTRAN
+      if [C, CL, CUDA].include?( BOAST::get_lang ) and @vector_length == 1 then
+        return "float" if @size == 4
+        return "double" if @size == 8
+      elsif BOAST::get_lang == C and @vector_length > 1 then
+        if BOAST::get_architecture == BOAST::X86 then
+          return "__m#{@total_size*8}" if @size == 4
+          return "__m#{@total_size*8}d" if @size == 8
+        elsif BOAST::get_architecture == BOAST::ARM then
+          raise "Unsupported data type in NEON: double!" if @size == 8
+          raise "Unsupported vector length in NEON: #{@total_size} (#{@size} x 8 x #{@vector_length})!" if @total_size * 8 != 64 or @total_size * 8 != 128
+          return "float#{@size*8}x#{@vector_length}_t"
+        else
+          raise "Unsupported architecture!"
+        end
+      elsif [CL, CUDA].include?( BOAST::get_lang ) and @vector_length > 1 then
+        return "float#{@vector_length}" if @size == 4
+        return "double#{@vector_length}" if @size == 8
+      end
+    end
+  end
+
+  class Int
+    def self.parens(*args,&block)
+      return Variable::new(args[0], self, *args[1..-1], &block)
+    end
+
+    attr_reader :size
+    attr_reader :signed
+    attr_reader :vector_length
+    attr_reader :total_size
+
+    def ==(t)
+      return true if t.class == self.class and t.signed == self.signed and t.size == self.size and t.vector_length == self.vector_length
+      return false
+    end
+
+    def initialize(hash={})
+      if hash[:size] then
+        @size = hash[:size]
+      else
+        @size = BOAST::get_default_int_size
+      end
+      if hash[:signed] != nil then
+        @signed = hash[:signed]
+      else
+        @signed = BOAST::get_default_int_signed
+      end
+#      @getters = {}
+#      @setters = {}
+      if hash[:vector_length] and hash[:vector_length] > 1 then
+        @vector_length = hash[:vector_length]
+#        @vector_length.times{ |indx|
+#          @getters["s#{indx}"] = indx
+#          @setters["s#{indx}="] = indx
+#        }
+      else
+        @vector_length = 1
+      end
+      @total_size = @vector_length*@size
+    end
+
+    def to_hash
+      return { :size => @size, :vector_length => @vector_length, :signed => @signed }
+    end
+
+    def copy(options={})
+      hash = self.to_hash
+      options.each { |k,v|
+        hash[k] = v
+      }
+      return Int::new(hash)
+    end
+
+    def decl
+      return "integer(kind=#{@size})" if BOAST::get_lang == FORTRAN
+      if BOAST::get_lang == C then
+        if @vector_length == 1 then
+          s = ""
+          s += "u" if not @signed
+          return s+"int#{8*@size}_t"
+        elsif @vector_length > 1 then
+          if BOAST::get_architecture == BOAST::X86 then
+            return "__m#{@total_size*8}#{@total_size*8>64 ? "i" : ""}"
+          elsif BOAST::get_architecture == BOAST::ARM then
+            raise "Unsupported vector length in NEON: #{@total_size*8} (#{@size} x 8 x #{@vector_length})!" if @total_size * 8 != 64 and @total_size * 8 != 128
+            return "#{ @signed ? "" : "u"}int#{@size*8}x#{@vector_length}_t"
+          else
+            raise "Unsupported architecture!"
+          end
+        end
+      elsif BOAST::get_lang == CL then
+        #char="cl_"
+        char=""
+        char += "u" if not @signed
+        case @size
+        when 1
+          char += "char"
+        when 2
+          char += "short"
+        when 4
+          char += "int"
+        when 8
+          char += "long"
+        else
+          raise "Unsupported integer size!"
+        end
+        if @vector_length > 1 then
+          char += "#{@vector_length}"
+        end
+        return char
+      elsif BOAST::get_lang == CUDA then
+        if @vector_length > 1 then
+          char=""
+          char += "u" if not @signed
+          case @size
+          when 1
+            char += "char"
+          when 2
+            char += "short"
+          when 4
+            char += "int"
+          when 8
+            char += "longlong"
+          else
+            raise "Unsupported integer size!"
+          end
+          return char + "#{@vector_length}"
+        else
+          char = ""
+          char += "unsigned " if not @signed
+          return char += "char" if @size==1
+          return char += "short" if @size==2
+          return char += "int" if @size==4
+          return char += "long long" if @size==8
+        end
+      end
+    end
+  end
+
+  class CStruct
+    attr_reader :name, :members, :members_array
+    def self.parens(*args,&block)
+      return Variable::new(args[0], self, *args[1..-1], &block)
+    end
+
+    def initialize(hash={})
+      @name = hash[:type_name]
+      @members = {}
+      @members_array = []
+      hash[:members].each { |m|
+        mc = m.copy
+        @members_array.push(mc)
+        @members[mc.name] = mc
+      }
+    end
+
+    def decl
+      return "struct #{@name}" if [C, CL, CUDA].include?( BOAST::get_lang )
+      return "TYPE(#{@name})" if BOAST::get_lang == FORTRAN
+    end
+
+    def finalize
+       s = ""
+       s += ";" if [C, CL, CUDA].include?( BOAST::get_lang )
+       s+="\n"
+       return s
+    end
+
+    def indent
+       return " "*BOAST::get_indent_level
+    end
+
+    def header
+      return header_c if [C, CL, CUDA].include?( BOAST::get_lang )
+      return header_fortran if BOAST::get_lang == FORTRAN
+      raise "Unsupported language!"
+    end
+
+    def header_c(final = true)
+      s = ""
+      s += self.indent if final
+      s += self.decl + " {\n"
+      @members_array.each { |value|
+         s+= self.indent if final
+         s+= " "*BOAST::get_indent_increment + value.decl(false)+";\n"
+      }
+      s += self.indent if final
+      s += "}"
+      s += self.finalize if final
+      BOAST::get_output.print s if final
+      return s
+    end
+    
+    def header_fortran(final = true)
+      s = ""
+      s += self.indent if final
+      s += "TYPE :: #{@name}\n"
+      members_array.each { |value|
+         s+= self.indent if final
+         s+= " "*BOAST::get_indent_increment + value.decl(false)+"\n"
+      }
+      s += self.indent if final
+      s += "END TYPE #{@name}"
+      s += self.finalize if final
+      BOAST::get_output.print s if final
+      return s
+    end
+
+  end
+
+  class CustomType
+    attr_reader :size, :name, :vector_length
+    def initialize(hash={})
+      @name = hash[:type_name]
+      @size = hash[:size]
+      @size = 0 if @size.nil?
+      @vector_length = hash[:vector_length]
+      @vector_length = 1 if @vector_length.nil?
+      @total_size = @vector_length*@size
+    end
+    def decl
+      return "#{@name}" if [C, CL, CUDA].include?( BOAST::get_lang )
+    end
+  end
+
+end

data/lib/BOAST/Operators.rb

@@ -0,0 +1,391 @@
+module BOAST
+
+  class Operator
+    def Operator.get_vector_name(type)
+      case BOAST::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 BOAST::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
+    end
+  end
+
+  class BasicBinaryOperator < Operator
+
+    def BasicBinaryOperator.to_s(arg1, arg2, return_type)
+      #puts "#{arg1.class} * #{arg2.class} : #{arg1} * #{arg2}"
+      if BOAST::get_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 BOAST::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
+      else
+        return basic_usage( arg1, arg2 )
+      end
+    end
+  end
+
+  class Set < Operator
+
+    def Set.to_s(arg1, arg2, return_type)
+      if BOAST::get_lang == C 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 BOAST::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
+            else
+              raise "Unsupported architecture!"
+            end
+            return "(#{arg1} = #{intr_name}( #{arg2} ))"
+          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 Affectation < Operator
+    def Affectation.to_s(arg1, arg2, return_type)
+      if BOAST::get_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 BOAST::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
+            else
+              raise "Unsupported architecture!"
+            end
+            return "#{arg1} = #{intr_name}( (#{arg1.type.decl} * ) #{a2} )"
+          else
+            raise "Unknown convertion between vectors of different length!"
+          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
+          else
+            a1 = a1[1..-1]
+          end
+          case BOAST::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
+          else
+            raise "Unsupported architecture!"
+          end
+          return "#{intr_name}((#{arg2.type.decl} * ) #{a1}, #{arg2} )"
+        else
+          return basic_usage(arg1, arg2)
+        end
+      else
+        return basic_usage(arg1, arg2)
+      end
+    end
+
+    def Affectation.basic_usage(arg1, arg2)
+      return "#{arg1} = #{arg2}"
+    end
+  end
+
+  class Multiplication < BasicBinaryOperator
+    class << self
+
+      def symbol
+        return "*"
+      end
+
+      def intr_name_X86
+        return "mul"
+      end
+
+      def intr_name_ARM
+        return "vmul"
+      end
+
+      def basic_usage(arg1, arg2)
+        return "(#{arg1}) * (#{arg2})" 
+      end
+  
+    end
+  end
+
+  class Addition < BasicBinaryOperator
+    class << self
+
+      def symbol
+        return "+"
+      end
+
+      def intr_name_X86
+        return "add"
+      end
+  
+      def intr_name_ARM
+        return "vadd"
+      end
+
+      def basic_usage(arg1, arg2)
+        return "#{arg1} + #{arg2}" 
+      end
+  
+    end
+  end
+
+  class Substraction < BasicBinaryOperator
+    class << self
+
+      def symbol
+        return "-"
+      end
+
+      def intr_name_X86
+        return "sub"
+      end
+  
+      def intr_name_ARM
+        return "vsub"
+      end
+
+      def basic_usage(arg1, arg2)
+        return "#{arg1} - (#{arg2})" 
+      end
+  
+    end
+  end
+
+  class Division < BasicBinaryOperator
+    class << self
+
+      def symbol
+        return "/"
+      end
+
+      def intr_name_X86
+        return "div"
+      end
+  
+      def intr_name_ARM
+        raise "Neon doesn't support division!"
+      end
+
+      def basic_usage(arg1, arg2)
+        return "(#{arg1}) / (#{arg2})" 
+      end
+  
+    end
+  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
+
+end

data/lib/BOAST/Transitions.rb

@@ -20,15 +20,15 @@ module BOAST
      def transition(var1, var2, operator)
        signed = false
        size = nil
+       vector_length = 1
        return_type, operator = get_transition(var1.type.class, var2.type.class, operator)
        #STDERR.puts "#{return_type} : #{var1.type.class} #{operator} #{var2.type.class}"
        if var1.type.class == return_type and var2.type.class == return_type then
-         signed = signed or var1.type.signed if var1.type.respond_to?(:signed)
-         signed = signed or var2.type.signed if var2.type.respond_to?(:signed)
-         if var1.type.respond_to?(:size) and var2.type.respond_to?(:size) then
-           size = [var1.type.size, var2.type.size].max
-         end
-         [BOAST::Variable::new("dummy", return_type, :size => size, :signed => signed), operator]
+         signed = (signed or var1.type.signed)
+         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
+         [BOAST::Variable::new("dummy", return_type, :size => size, :signed => signed, :vector_length => vector_length), operator]
        elsif var1.type.class == return_type then
          return [var1, operator]
        elsif var2.type.class == return_type then

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: BOAST
 version: !ruby/object:Gem::Version
-  version: '0.6'
+  version: '0.7'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-14 00:00:00.000000000 Z
+date: 2014-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: narray
@@ -74,6 +74,8 @@ files:
 - lib/BOAST/BOAST_OpenCL.rb
 - lib/BOAST/Transitions.rb
 - lib/BOAST/Parens.rb
+- lib/BOAST/Operators.rb
+- lib/BOAST/DataTypes.rb
 homepage: https://forge.imag.fr/projects/boast/
 licenses:
 - BSD