BOAST 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 939618b7050d9d0298fa5f06b310ac5a881b85ef
-  data.tar.gz: 60b1fc0bc92e9b1dad4003604a30c9f4de634d87
+  metadata.gz: 0bb86d632c7e15c62f42007db65ef307a86ed1eb
+  data.tar.gz: 8b4323362889540f6e731bad43e6765b24f26d2c
 SHA512:
-  metadata.gz: cc1877354a30495b196128bd5e94055808197c14e9e7d6fd9dbb8c1e6c6dc603efbd5a877fd6d64f4d7f12b0fe88a0a8c1801cacb3baf13d206d25740914af4e
-  data.tar.gz: 858093b8d634b8f0ff61f90aa5a2b7a8d67c5b49e9013cdc4093a453095adfaf9ba3490ad8548082b1bd0728cd280184a2ccacf147d94dcdbf541fff124217ec
+  metadata.gz: d4dd1ffe821624820fec06684910ad87f0dd451d81b596fafceda7b41651e0d5810dfe4aa902de69d609387577e4ace87b1ede8dea7ebcc65cc4d11d13cd3dda
+  data.tar.gz: 65d6bc915e2299d38e1bd2f4c52057f42e5c6ada5fd5d26416dacd20a4169f364f3eaec28c9e755a4d3b40c3903cb8f2092c23d55dcf400b5b7dbeac5a3f1787

data/BOAST.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'BOAST'
-  s.version = "1.2.0"
+  s.version = "1.2.1"
   s.author = "Brice Videau"
   s.email = "brice.videau@imag.fr"
   s.homepage = "https://github.com/Nanosim-LIG/boast"
@@ -12,7 +12,7 @@ Gem::Specification.new do |s|
   s.required_ruby_version = '>= 1.9.3'
   s.add_dependency 'narray', '~> 0.6.0', '>=0.6.0.8'
   s.add_dependency 'narray_ffi', '~> 1.2', '>=1.2.0'
-  s.add_dependency 'opencl_ruby_ffi', '~> 1.0', '>=1.0.0'
+  s.add_dependency 'opencl_ruby_ffi', '~> 1.2', '>=1.2.1'
   s.add_dependency 'systemu', '~> 2', '>=2.2.0'
   s.add_dependency 'os', '~> 0.9', '>=0.9.6'
   s.add_dependency 'PAPI', '~> 0', '>=0.101'

data/lib/BOAST/Language/Algorithm.rb

@@ -30,6 +30,7 @@ module BOAST
     private_boolean_state_accessor :decl_module
     private_boolean_state_accessor :annotate
     private_boolean_state_accessor :optimizer_log
+    private_boolean_state_accessor :disable_openmp
 
     private
     def push_env(*args)
@@ -84,6 +85,7 @@ module BOAST
   boolean_state_accessor :decl_module
   boolean_state_accessor :annotate
   boolean_state_accessor :optimizer_log
+  boolean_state_accessor :disable_openmp
 
   default_state_getter :address_size,          OS.bits/8
   default_state_getter :lang,                  FORTRAN, '"const_get(#{envs})"', :BOAST_LANG
@@ -104,6 +106,7 @@ module BOAST
   default_state_getter :annotate_level,        0
   default_state_getter :optimizer_log,         false
   default_state_getter :optimizer_log_file,    nil
+  default_state_getter :disable_openmp,        false
 
   alias use_vla_old? use_vla?
   class << self
@@ -163,17 +166,27 @@ module BOAST
 
   @@env = Hash::new{|h, k| h[k] = []}
 
-  def push_env(vars = {})
-    vars.each { |key,value|
+  def push_env(vars = {}, &block)
+    keys = []
+    vars.each { |key, value|
       var = nil
       begin
         var = BOAST::class_variable_get("@@"+key.to_s)
       rescue
+        BOAST::pop_env(*keys)
         raise "Unknown module variable #{key}!"
       end
       @@env[key].push(var)
       BOAST::class_variable_set("@@"+key.to_s, value)
+      keys.push(key)
     }
+    if block then
+      begin
+        block.call
+      ensure
+        BOAST::pop_env(*vars.keys)
+      end
+    end
   end
 
   def pop_env(*vars)

data/lib/BOAST/Language/Architectures.rb

@@ -91,6 +91,33 @@ X86architectures ={"pentium2"=>["MMX"],
    "RDSEED",
    "ADCX",
    "PREFETCHW"],
+ "knl"=>
+  ["MOVBE",
+   "MMX",
+   "SSE",
+   "SSE2",
+   "SSE3",
+   "SSSE3",
+   "SSE4.1",
+   "SSE4.2",
+   "POPCNT",
+   "AVX",
+   "AVX2",
+   "AES",
+   "PCLMUL",
+   "FSGSBASE",
+   "RDRND",
+   "FMA",
+   "BMI",
+   "BMI2",
+   "F16C",
+   "RDSEED",
+   "ADCX",
+   "PREFETCHW",
+   "AVX512F",
+   "AVX512PF",
+   "AVX512ER",
+   "AVX512CD"],
  "bonnell"=>["MOVBE", "MMX", "SSE", "SSE2", "SSE3", "SSSE3"],
  "silvermont"=>
   ["MOVBE",

data/lib/BOAST/Language/Index.rb

@@ -14,6 +14,11 @@ module BOAST
       return !!@alignment
     end
 
+    def set_align(align)
+      @alignment = align
+      return self
+    end
+
     def to_var
       var = @source.copy("#{self}", :const => nil, :constant => nil, :dim => nil, :dimension => nil, :direction => nil, :dir => nil, :align => alignment)
       return var

data/lib/BOAST/Language/Intrinsics.rb

@@ -39,16 +39,36 @@ module BOAST
     INTRINSICS = Hash::new { |h, k| h[k] = Hash::new { |h2, k2| h2[k2] = {} } }
     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|
+              ins.push instr.to_s
+            }
+          }
+        else
+          v.each { |type, instr|
+            ins.push instr.to_s
+          }
+        end
+      }
+      return ins - INSTRUCTIONS.keys
+    end
+
+    module_function :check_coverage
+
     def intrinsics_by_vector_name(intr_symbol, type, type2=nil)
       if type2 then
         instruction = INTRINSICS[get_architecture][intr_symbol][type][type2]
       else
         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
-      raise IntrinsicsError, "Unsupported operation #{intr_symbol} for #{type}#{type2 ? "and #{type2}" : ""} on #{get_architecture_name}!" unless instruction
       supported = (INSTRUCTIONS[instruction.to_s] & MODELS[get_model.to_s]).size > 0
-      raise IntrinsicsError, "Unsupported operation #{intr_symbol} for #{type}#{type2 ? "and #{type2}" : ""} on #{get_model}! (requires #{INSTRUCTIONS[instruction.to_s].join(" or ")})" unless supported
+      raise IntrinsicsError, "Unsupported operation #{intr_symbol} for #{type}#{type2 ? " and #{type2}" : ""} on #{get_model}! (requires #{INSTRUCTIONS[instruction.to_s].join(" or ")})" unless supported
       return instruction
     end
 
@@ -213,7 +233,7 @@ module BOAST
 
     module_function :type_name_X86
 
-    [64, 128, 256].each { |vector_size|
+    [64, 128, 256, 512].each { |vector_size|
       vs = ( vector_size < 256 ? "" : "#{vector_size}" )
       sizes = [8, 16, 32]
       sizes.push( 64 ) if vector_size > 64
@@ -222,12 +242,17 @@ module BOAST
           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.push( [:SET, "setr"] ) unless size < 32 and vector_size == 512
+          instructions.push( [:SET1, "set1"] )
+          instructions.push( [:MUL, "mullo"] ) if vector_size > 64 and size >= 16
+          instructions.push( [:MASKLOAD, "maskload"], [:MASKSTORE, "maskstore"] ) if vector_size <= 256 and vector_size >= 128 and size >= 32
+          instructions.push( [:MASK_LOAD,  "mask_load"],   [:MASK_STORE,  "mask_store"],
+                             [:MASK_LOADU, "mask_loadu"],  [:MASK_STOREU, "mask_storeu"],
+                             [:MASKZ_LOAD, "maskz_load"],  [:MASKZ_LOADU, "maskz_loadu"], ) if vector_size >= 128 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
+          if size == 64 and vector_size == 256 then
             INTRINSICS[X86][:SET1][vtype] = "_mm#{vs}_set1_#{type}x".to_sym
             INTRINSICS[X86][:SET][vtype] = "_mm#{vs}_setr_#{type}x".to_sym
           end
@@ -236,8 +261,10 @@ module BOAST
       [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|
+          instructions = [[:LOAD, "loadu"],   [:LOADA, "load"],
+                          [:STORE, "storeu"], [:STOREA, "store"],
+                          [:SETZERO, "setzero"] ]
+          instructions.each { |cl, ins|
             INTRINSICS[X86][cl][vtype] = "_mm#{vs}_#{ins}_si#{vector_size}".to_sym
           }
         }
@@ -245,12 +272,19 @@ module BOAST
       sizes = []
       sizes.push( 32, 64 ) if vector_size > 64
       sizes.each { |size|
-        [[:ADD, "add"],       [:SUB, "sub"],           [:MUL, "mul"],       [:DIV, "div"], [:POW, "pow"],
-         [:FMADD, "fmadd"],   [:FMSUB, "fmsub"],       [:FNMADD, "fnmadd"], [:FNMSUB, "fnmsub"],
-         [:ADDSUB, "addsub"], [:FMADDSUB, "fmaddsub"], [:FMSUBADD, "fmsubadd"],
-         [:LOAD, "loadu"],    [:LOADA, "load"],        [:MASKLOAD, "maskload"],
-         [:STORE, "storeu"],  [:STOREA, "store"],      [:MASKSTORE, "maskstore"],
-         [:SET, "setr"],      [:SET1, "set1"] ].each { |cl, ins|
+        instructions = [[:ADD, "add"],           [:SUB, "sub"], [:MUL, "mul"], [:DIV, "div"], [:POW, "pow"],
+                        [:FMADD, "fmadd"],       [:FMSUB, "fmsub"],
+                        [:FNMADD, "fnmadd"],     [:FNMSUB, "fnmsub"],
+                        [:FMADDSUB, "fmaddsub"], [:FMSUBADD, "fmsubadd"],
+                        [:LOAD, "loadu"],        [:LOADA, "load"],
+                        [:STORE, "storeu"],  [:STOREA, "store"],
+                        [:SET, "setr"],      [:SET1, "set1"], [:SETZERO, "setzero"],
+                        [:MASK_LOAD,  "mask_load"],  [:MASK_STORE,  "mask_store"],
+                        [:MASK_LOADU, "mask_loadu"], [:MASK_STOREU, "mask_storeu"],
+                        [:MASKZ_LOAD, "maskz_load"], [:MASKZ_LOADU, "maskz_loadu"] ]
+        instructions.push( [:MASKLOAD, "maskload"], [:MASKSTORE, "maskstore"] ) if vector_size < 512
+        instructions.push( [:ADDSUB, "addsub"] ) if vector_size < 512
+        instructions.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
@@ -258,7 +292,7 @@ module BOAST
       }
     }
     INTRINSICS[X86][:CVT] = Hash::new { |h,k| h[k] = {} }
-    [128, 256].each { |bvsize|
+    [128, 256, 512].each { |bvsize|
       [16, 32, 64].each { |bsize|
         ssize = bsize/2
         while ssize >= 8
@@ -296,6 +330,15 @@ module BOAST
           INTRINSICS[X86][:CVT][ivtype][fvtype] = "_mm#{vs}_cvt#{ftype}_#{itype}".to_sym
         }
       }
+      [64,32].each { |bsize|
+        ftype = type_name_X86( :float, bsize, bvsize )
+        itype = type_name_X86( :int,   bsize, bvsize, :signed )
+        fvtype = vector_type_name( :float, bsize, bvsize )
+        ivtype = vector_type_name( :int,   bsize, bvsize, :signed )
+        vs = ( bvsize < 256 ? "" : "#{bvsize}" )
+        INTRINSICS[X86][:CVT][fvtype][ivtype] = "_mm#{vs}_cvt#{itype}_#{ftype}".to_sym
+        INTRINSICS[X86][:CVT][ivtype][fvtype] = "_mm#{vs}_cvt#{ftype}_#{itype}".to_sym
+      }
     }
 
 
@@ -324,7 +367,7 @@ module BOAST
         vtype = vector_type_name( :float, size, vector_size )
         type = type_name_ARM( :float, size )
         [[:ADD, "add"], [:SUB, "sub"], [:MUL, "mul"],
-         [:FMADD, "mla"], [:FNMSUB, "mls"],
+         [:FMADD, "mla"], [:FNMADD, "mls"],
          [:LOAD, "ldl"], [:LOADA, "ldl"],
          [:STORE, "stl"], [:STOREA, "stl"]].each { |cl, ins|
           INTRINSICS[ARM][cl][vtype] = "v#{ins}#{q}_#{type}".to_sym
@@ -332,6 +375,9 @@ module BOAST
         [[: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
+        }
       }
     }
     INTRINSICS[ARM][:CVT] = Hash::new { |h,k| h[k] = {} }
@@ -344,8 +390,8 @@ module BOAST
         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
+        INTRINSICS[ARM][:CVT][ivtype][fvtype] = "vcvt#{q}_#{itype}_#{ftype}".to_sym
+        INTRINSICS[ARM][:CVT][fvtype][ivtype] = "vcvt#{q}_#{ftype}_#{itype}".to_sym
       }
     }
     svsize = 64
@@ -357,8 +403,8 @@ module BOAST
         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
+        INTRINSICS[ARM][:CVT][bvtype][svtype] = "vmovl_#{stype}".to_sym
+        INTRINSICS[ARM][:CVT][svtype][bvtype] = "vmovn_#{btype}".to_sym
       }
     }
 

data/lib/BOAST/Language/OpenMP.rb

@@ -152,7 +152,7 @@ EOF
       end
 
       def open
-        output.puts to_s
+        output.puts to_s unless disable_openmp
         return self
       end
 
@@ -166,7 +166,7 @@ EOF
       end
 
       def close
-        output.puts end_string(openmp_end_clauses_to_s) 
+        output.puts end_string(openmp_end_clauses_to_s) unless disable_openmp
         return self
       end
      

data/lib/BOAST/Language/Operators.rb

@@ -316,7 +316,7 @@ module BOAST
 
     def initialize(source, return_type)
       @source = source
-      @return_type = return_type
+      @return_type = return_type.to_var
     end
 
     def type
@@ -328,21 +328,29 @@ module BOAST
         if @source.kind_of?( Array ) then
           raise OperatorError,  "Invalid array length!" unless @source.length == @return_type.type.vector_length
           return @return_type.copy("(#{@return_type.type.decl})( #{@source.join(", ")} )", DISCARD_OPTIONS) if lang == CL
-
+	  return Set(@source.first, @return_type).to_var if @source.uniq.size == 1
           begin
             instruction = intrinsics(:SET, @return_type.type)
+            raise IntrinsicsError unless instruction
             return @return_type.copy("#{instruction}( #{@source.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})"
+              s = "#{instruction}( #{v}, #{s}, #{i} )"
             }
             return @return_type.copy(s, DISCARD_OPTIONS)
           end
         elsif @source.class != Variable or @source.type.vector_length == 1 then
           return @return_type.copy("(#{@return_type.type.decl})( #{@source} )", DISCARD_OPTIONS) if lang == CL
-
+          if (@source.is_a?(Numeric) and @source == 0) or (@source.class == Variable and @source.constant == 0) then
+            begin
+              instruction = intrinsics(:SETZERO, @return_type.type)
+              return @return_type.copy("#{instruction}( )", DISCARD_OPTIONS) if instruction
+            rescue IntrinsicsError
+            end
+          end
           instruction = intrinsics(:SET1, @return_type.type)
           return @return_type.copy("#{instruction}( #{@source} )", DISCARD_OPTIONS)
         elsif @return_type.type != @source.type
@@ -379,7 +387,7 @@ module BOAST
 
     def initialize(source, return_type)
       @source = source
-      @return_type = return_type
+      @return_type = return_type.to_var
     end
 
     def type
@@ -445,12 +453,12 @@ module BOAST
     def initialize(source, mask, return_type)
       @source = source
       @mask = mask
-      @return_type = return_type
+      @return_type = return_type.to_var
     end
 
     def get_mask
-      raise OperatorError,  "Mask size is wrong: #{@mask.length} for #{@return_type.type.vector_length}!" if @mask.length != @return_type.type.vector_length
-      return Load(@mask.collect { |m| ( m and m != 0 )  ? -1 : 0 }, Int("mask", :size => @return_type.type.size, :vector_length => @return_type.type.vector_length ) )
+      type = @return_type.type
+      return Set(@mask.collect { |m| ( m and m != 0 )  ? -1 : 0 }, Int("mask", :size => type.size, :vector_length => type.vector_length ) )
     end
 
     private :get_mask
@@ -461,8 +469,12 @@ module BOAST
 
     def to_var
       raise OperatorError,  "Cannot load unknown type!" unless @return_type
+      type = @return_type.type
       raise LanguageError,  "Unsupported language!" unless lang == C
-      instruction = intrinsics(:MASKLOAD, @return_type.type)
+      raise OperatorError,  "Mask size is wrong: #{@mask.length} for #{type.vector_length}!" if @mask.length != type.vector_length
+      return Load( @source, @return_type ).to_var unless @mask.include?(0)
+      return Set( 0, @return_type ).to_var if @mask.uniq.size == 1 and @mask.uniq.first == 0
+      instruction = intrinsics(:MASKLOAD, type)
       s = ""
       src = "#{@source}"
       if src[0] != "*" then
@@ -470,8 +482,8 @@ module BOAST
       else
         src = src[1..-1]
       end
-      p_type = @return_type.type.copy(:vector_length => 1)
-      s += "#{instruction}((#{p_type.decl} * )#{src}, #{get_mask})"
+      p_type = type.copy(:vector_length => 1)
+      s += "#{instruction}( (#{p_type.decl} * ) #{src}, #{get_mask} )"
       return @return_type.copy( s, DISCARD_OPTIONS)
     end
 
@@ -501,11 +513,11 @@ module BOAST
     attr_reader :source
     attr_reader :store_type
 
-    def initialize(dest, source, mask, store_type = nil)
+    def initialize(dest, source, store_type = nil)
       @dest = dest
       @source = source
       @store_type = store_type
-      @store_type = source unless @store_type
+      @store_type = source.to_var unless @store_type
     end
 
     def to_s
@@ -516,17 +528,17 @@ module BOAST
         else
           dst = dst[1..-1]
         end
+        type = @store_type.type
+        return "vstore#{type.vector_length}( #{@source}, 0, #{dst} )" if lang == CL
+        return "*((int64_t * ) #{dst}) = _m_to_int64( #{@source} )" if get_architecture == X86 and type.total_size*8 == 64
 
-        return "vstore#{@source.type.vector_length}(#{@source}, 0, #{dst})" if lang == CL
-        return "*((int64_t * ) #{dst}) = _m_to_int64( #{@source} )" if get_architecture == X86 and @source.type.total_size*8 == 64
-
-        if @dest.alignment == @source.type.total_size then
-          instruction = intrinsics(:STOREA, @source.type)
+        if @dest.alignment == type.total_size then
+          instruction = intrinsics(:STOREA, type)
         else
-          instruction = intrinsics(:STORE, @source.type)
+          instruction = intrinsics(:STORE, type)
         end
-        p_type = @source.type.copy(:vector_length => 1)
-        p_type = @source.type if get_architecture == X86 and @source.type.kind_of?(Int)
+        p_type = type.copy(:vector_length => 1)
+        p_type = type if get_architecture == X86 and type.kind_of?(Int)
         return "#{instruction}( (#{p_type.decl} * ) #{dst}, #{@source} )"
       end
       return Affectation.basic_usage(@dest, @source)
@@ -560,20 +572,24 @@ module BOAST
       @source = source
       @mask = mask
       @store_type = store_type
-      @store_type = source unless @store_type
+      @store_type = source.to_var unless @store_type
     end
 
     def get_mask
-      raise OperatorError,  "Mask size is wrong: #{@mask.length} for #{@store_type.type.vector_length}!" if @mask.length != @store_type.type.vector_length
-      return Load.to_s(@mask.collect { |m| ( m and m != 0 )  ? -1 : 0 }, Int("mask", :size => @store_type.type.size, :vector_length => @store_type.type.vector_length ) )
+      type = @store_type.type
+      return Set(@mask.collect { |m| ( m and m != 0 )  ? -1 : 0 }, Int("mask", :size => type.size, :vector_length => type.vector_length ) )
     end
 
     private :get_mask
 
     def to_s
       raise OperatorError,  "Cannot store unknown type!" unless @store_type
+      type = @store_type.type
       raise LanguageError,  "Unsupported language!" unless lang == C
-      instruction = intrinsics(:MASKSTORE, @store_type.type)
+      raise OperatorError,  "Mask size is wrong: #{@mask.length} for #{type.vector_length}!" if @mask.length != type.vector_length
+      return Store( @dest, @source, @store_type ).to_s unless @mask.include?(0)
+      return nil if @mask.uniq.size == 1 and @mask.uniq.first == 0
+      instruction = intrinsics(:MASKSTORE, type)
       s = ""
       dst = "#{@dest}"
       if dst[0] != "*" then
@@ -581,8 +597,81 @@ module BOAST
       else
         dst = dst[1..-1]
       end
-      p_type = @store_type.type.copy(:vector_length => 1)
-      return s += "#{instruction}((#{p_type.decl} * )#{dst}, #{get_mask}, #{Operator.convert(@source, @store_type.type)})"
+      p_type = type.copy(:vector_length => 1)
+      return s += "#{instruction}( (#{p_type.decl} * ) #{dst}, #{get_mask}, #{Operator.convert(@source, type)} )"
+    end
+
+    def pr
+      ss = to_s
+      if ss then
+        s=""
+        s += indent
+        s += ss
+        s += ";" if [C, CL, CUDA].include?( lang )
+        output.puts s
+      end
+      return self
+    end
+
+  end
+
+  class FMA < Operator
+    extend Functor
+    include Intrinsics
+    include Arithmetic
+    include Inspectable
+    include PrivateStateAccessor
+
+    attr_reader :operand1
+    attr_reader :operand2
+    attr_reader :operand3
+    attr_reader :return_type
+
+    def initialize(a,b,c)
+      @operand1 = a
+      @operand2 = b
+      @operand3 = c
+      @return_type = nil
+      @return_type = @operand3.to_var unless @return_type
+    end
+
+    def convert_operand(op)
+      return  "#{Operator.convert(op, @return_type.type)}"
+    end
+
+    private :convert_operand
+
+    def type
+      return @return_type.type
+    end
+
+    def to_var
+      instruction = nil
+      begin
+        instruction = intrinsics(:FMADD,@return_type.type)
+      rescue
+      end
+      return (@operand3 + @operand1 * @operand2).to_var unless lang != FORTRAN and @return_type and ( instruction or ( [CL, CUDA].include?(lang) ) )
+      op1 = convert_operand(@operand1.to_var)
+      op2 = convert_operand(@operand2.to_var)
+      op3 = convert_operand(@operand3.to_var)
+      if [CL, CUDA].include?(lang)
+        ret_name = "fma( #{op1}, #{op2}, #{op3} )"
+      else
+        case architecture
+        when X86
+          ret_name = "#{instruction}( #{op1}, #{op2}, #{op3} )"
+        when ARM
+          ret_name = "#{instruction}( #{op3}, #{op1}, #{op2} )"
+        else
+          return (@operand3 + @operand1 * @operand2).to_var
+        end
+      end
+      return @return_type.copy( ret_name, DISCARD_OPTIONS)
+    end
+
+    def to_s
+      return to_var.to_s
     end
 
     def pr
@@ -596,7 +685,7 @@ module BOAST
 
   end
 
-  class FMA < Operator
+  class FMS < Operator
     extend Functor
     include Intrinsics
     include Arithmetic
@@ -629,23 +718,24 @@ module BOAST
     def to_var
       instruction = nil
       begin
-        instruction = intrinsics(:FMADD,@return_type.type)
+        instruction = intrinsics(:FNMADD,@return_type.type)
       rescue
       end
-      return (@operand3 + @operand1 * @operand2).to_var unless lang != FORTRAN and @return_type and ( instruction or ( [CL, CUDA].include?(lang) ) )
-      op1 = convert_operand(@operand1)
-      op2 = convert_operand(@operand2)
-      op3 = convert_operand(@operand3)
+      return (@operand3 - @operand1 * @operand2).to_var unless lang != FORTRAN and @return_type and ( instruction or ( [CL, CUDA].include?(lang) ) )
+      op1 = convert_operand(@operand1.to_var)
+      op2 = convert_operand(@operand2.to_var)
+      op3 = convert_operand(@operand3.to_var)
       if [CL, CUDA].include?(lang)
-        ret_name = "fma(#{op1},#{op2},#{op3})"
+        op1 = convert_operand((-@operand1).to_var)
+        ret_name = "fma( #{op1}, #{op2}, #{op3} )"
       else
         case architecture
         when X86
-          ret_name = "#{instruction}(#{op1},#{op2},#{op3})"
+          ret_name = "#{instruction}( #{op1}, #{op2}, #{op3} )"
         when ARM
-          ret_name = "#{instruction}(#{op2},#{op3},#{op1})"
+          ret_name = "#{instruction}( #{op3}, #{op1}, #{op2} )"
         else
-          return (@operand1 * @operand2 + @operand3).to_var
+          return (@operand3 - @operand1 * @operand2).to_var
         end
       end
       return @return_type.copy( ret_name, DISCARD_OPTIONS)

data/lib/BOAST/Language/Parens.rb

@@ -2,10 +2,16 @@ module BOAST
 
   module_function
 
-  def register_funccall(name)
+  FUNCCALLS = {}
+
+  def register_funccall(name, options = {})
+    sym = name.to_sym
+    FUNCCALLS[sym] = {}
+    FUNCCALLS[sym][:parameters] = options[:parameters]
+    FUNCCALLS[sym][:returns] = options[:returns]
     s =<<EOF
     def self.#{name}(*args)
-      return FuncCall("#{name}", *args)
+      return FuncCall(#{sym.inspect}, *args#{options[:returns] ? ", returns: FUNCCALLS[#{sym.inspect}][:returns]" : ""})
     end
 EOF
     eval s

data/lib/BOAST/Language/Variable.rb

@@ -252,6 +252,11 @@ module BOAST
       return Variable::new(name, @type.class, h)
     end
 
+    def set_align(align)
+      @alignment = align
+      return self
+    end
+
     def self.from_type(name, type, options={})
       hash = type.to_hash
       options.each { |k,v|

data/lib/BOAST/Runtime/CompiledRuntime.rb

@@ -396,7 +396,7 @@ EOF
 
       load_module
 
-      cleanup(kernel_files)
+      cleanup(kernel_files) unless keep_temp
 
       eval "self.extend(#{module_name})"
 

data/lib/BOAST/Runtime/Compilers.rb

@@ -51,7 +51,7 @@ module BOAST
       cflags += " -DHAVE_NARRAY_H" if narray_path
       cflags += " -I/usr/local/k1tools/include" if @architecture == MPPA
       objext = RbConfig::CONFIG["OBJEXT"]
-      if options[:openmp] and @lang == C then
+      if options[:openmp] and @lang == C and not disable_openmp then
           openmp_cflags = get_openmp_flags(c_compiler)
           raise "unkwown openmp flags for: #{c_compiler}" if not openmp_cflags
           cflags += " #{openmp_cflags}"
@@ -79,7 +79,7 @@ module BOAST
       cxx_compiler = options[:CXX]
       cxxflags = options[:CXXFLAGS]
       cxxflags += " -fPIC #{includes}"
-      if options[:openmp] and @lang == C then
+      if options[:openmp] and @lang == C and not disable_openmp then
           openmp_cxxflags = get_openmp_flags(cxx_compiler)
           raise "unkwown openmp flags for: #{cxx_compiler}" if not openmp_cxxflags
           cxxflags += " #{openmp_cxxflags}"
@@ -97,7 +97,7 @@ module BOAST
       fcflags += " -march=#{get_model}"
       fcflags += " -fPIC"
       fcflags += " -fno-second-underscore" if f_compiler == 'g95'
-      if options[:openmp] and @lang == FORTRAN then
+      if options[:openmp] and @lang == FORTRAN and not disable_openmp then
           openmp_fcflags = get_openmp_flags(f_compiler)
           raise "unkwown openmp flags for: #{f_compiler}" if not openmp_fcflags
           fcflags += " #{openmp_fcflags}"
@@ -152,7 +152,7 @@ module BOAST
       c_compiler = "cc" if not c_compiler
       linker = options[:LD]
       linker = c_compiler if not linker
-      if options[:openmp] then
+      if options[:openmp] and not disable_openmp then
         openmp_ldflags = get_openmp_flags(linker)
         raise "unknown openmp flags for: #{linker}" if not openmp_ldflags
         ldflags += " #{openmp_ldflags}"

data/lib/BOAST/Runtime/Config.rb

@@ -35,16 +35,19 @@ module BOAST
     private_boolean_state_accessor :verbose
     private_boolean_state_accessor :debug_source
     private_boolean_state_accessor :ffi
+    private_boolean_state_accessor :keep_temp
     private_state_accessor :fortran_line_length
   end
 
   boolean_state_accessor :verbose
   boolean_state_accessor :debug_source
   boolean_state_accessor :ffi
+  boolean_state_accessor :keep_temp
   state_accessor         :fortran_line_length
-  default_state_getter :ffi,                 false
   default_state_getter :verbose,             false
   default_state_getter :debug_source,        false
+  default_state_getter :ffi,                 false
+  default_state_getter :keep_temp,           false
   default_state_getter :fortran_line_length, 72
 
   module_function

data/lib/BOAST/Runtime/MAQAO.rb

@@ -26,8 +26,8 @@ module BOAST
         puts "#{compiler_options[:MAQAO]} cqa #{maqao_model ? "--uarch=#{maqao_model} " : ""}#{f1.path} --fct=#{@procedure.name} #{compiler_options[:MAQAO_FLAGS]}"
       end
       result = `#{compiler_options[:MAQAO]} cqa #{maqao_model ? "--uarch=#{maqao_model} " : ""}#{f1.path} --fct=#{@procedure.name} #{compiler_options[:MAQAO_FLAGS]}`
-      File::unlink(library_object)
-      File::unlink(library_source)
+      File::unlink(library_object) unless keep_temp
+      File::unlink(library_source) unless keep_temp
       return result
     end
   end

data/lib/BOAST/Runtime/OpenCLRuntime.rb

@@ -38,23 +38,23 @@ module BOAST
 
     def init_opencl_types
       @@opencl_real_types = {
-        2 => OpenCL::Half,
-        4 => OpenCL::Float,
-        8 => OpenCL::Double
+        2 => OpenCL::Half1,
+        4 => OpenCL::Float1,
+        8 => OpenCL::Double1
       }
 
       @@opencl_int_types = {
         true => {
-          1 => OpenCL::Char,
-          2 => OpenCL::Short,
-          4 => OpenCL::Int,
-          8 => OpenCL::Long
+          1 => OpenCL::Char1,
+          2 => OpenCL::Short1,
+          4 => OpenCL::Int1,
+          8 => OpenCL::Long1
         },
         false => {
-          1 => OpenCL::UChar,
-          2 => OpenCL::UShort,
-          4 => OpenCL::UInt,
-          8 => OpenCL::ULong
+          1 => OpenCL::UChar1,
+          2 => OpenCL::UShort1,
+          4 => OpenCL::UInt1,
+          8 => OpenCL::ULong1
         }
       }
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: BOAST
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Brice Videau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-08 00:00:00.000000000 Z
+date: 2016-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: narray
@@ -56,20 +56,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.2.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.2.1
 - !ruby/object:Gem::Dependency
   name: systemu
   requirement: !ruby/object:Gem::Requirement