BOAST 1.0.7 → 1.0.8

data/lib/BOAST/Language/DataTypes.rb

@@ -1,7 +1,7 @@
 module BOAST
 
   class DataType
-
+    include Intrinsics
     include PrivateStateAccessor
 
     def self.inherited(child)
@@ -55,10 +55,6 @@ module BOAST
 
     def suffix
       s = ""
-#      if [C, CL, CUDA].include?( lang ) then
-#        s += "U" if not @signed
-#        s += "LL" if @size == 8
-#      end
       return s
     end
 
@@ -84,14 +80,8 @@ module BOAST
       else
         @size = 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
@@ -121,16 +111,7 @@ module BOAST
         return "float" if @size == 4
         return "double" if @size == 8
       elsif lang == C and @vector_length > 1 then
-        if get_architecture == X86 then
-          return "__m#{@total_size*8}" if @size == 4
-          return "__m#{@total_size*8}d" if @size == 8
-        elsif get_architecture == 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
+        return get_vector_decl(self)
       elsif [CL, CUDA].include?( lang ) and @vector_length > 1 then
         return "float#{@vector_length}" if @size == 4
         return "double#{@vector_length}" if @size == 8
@@ -177,15 +158,9 @@ module BOAST
       else
         @signed = 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
-#        }
-         raise "Vectors need to have their element size specified!" if not @size
+        raise "Vectors need to have their element size specified!" if not @size
       else
         @vector_length = 1
       end
@@ -220,75 +195,39 @@ module BOAST
           return s+"int#{8*@size}_t" if @size
           return s+"int"
         elsif @vector_length > 1 then
-          if get_architecture == X86 then
-            return "__m#{@total_size*8}#{@total_size*8>64 ? "i" : ""}"
-          elsif get_architecture == 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
+          return get_vector_decl(self)
         end
-      elsif lang == CL then
-        #char="cl_"
-        char=""
-        char += "u" if not @signed
+      else
+        s =""
+        s += "u" if not @signed
+        s += "nsigned " if not @signed and lang == CUDA and @vector_length == 1
         case @size
         when 1
-          char += "char"
+          s += "char"
         when 2
-          char += "short"
+          s += "short"
         when 4
-          char += "int"
+          s += "int"
         when 8
-          char += "long"
+          if lang == CUDA
+            case @vector_length
+            when 1
+              s += "long long"
+            else
+              s += "longlong"
+            end
+          else
+            s += "long"
+          end
         when nil
-          char += "int"
+          s += "int"
         else
           raise "Unsupported integer size!"
         end
         if @vector_length > 1 then
-          char += "#{@vector_length}"
-        end
-        return char
-      elsif 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"
-          when nil
-            char += "int"
-          else
-            raise "Unsupported integer size!"
-          end
-          return char + "#{@vector_length}"
-        else
-          char = ""
-          char += "unsigned " if not @signed
-          case @size
-          when 1
-            char += "char"
-          when 2
-            char += "short"
-          when 4
-            char += "int"
-          when 8
-            char += "longlong"
-          when nil
-            char += "int"
-          else
-            raise "Unsupported integer size!"
-          end
-          return char
+          s += "#{@vector_length}"
         end
+        return s
       end
     end
 

data/lib/BOAST/Language/Index.rb

@@ -19,6 +19,18 @@ module BOAST
       return var
     end
 
+    def set(x)
+      return to_var === Set(x,to_var)
+    end
+
+    def copy(*args)
+      return to_var.copy(*args)
+    end
+
+    def type
+      return to_var.type
+    end
+
     def to_s
       if get_replace_constants then
         begin

data/lib/BOAST/Language/Inspectable.rb

@@ -1,7 +1,7 @@
 module BOAST
 
   boolean_state_accessor :boast_inspect
-  @@boast_inspect = false
+  default_state_getter :boast_inspect, false, nil, :INSPECT
 
   module Inspectable
 

data/lib/BOAST/Language/Intrinsics.rb

@@ -1,22 +1,114 @@
+require 'os'
+require 'yaml'
+require 'rgl/adjacency'
+require 'rgl/dijkstra'
+
 module BOAST
 
   X86 = 1
   ARM = 2
 
+  native_flags = nil
+
+  if OS.mac? then
+    native_flags = `sysctl -n machdep.cpu.features`.split
+  else
+    native_flags = YAML::load(`cat /proc/cpuinfo`)["flags"].upcase.gsub("_",".").split
+  end
+
+  MODELS={ "native" => native_flags }
+  MODELS.update(X86architectures)
+  INSTRUCTIONS = {}
+  INSTRUCTIONS.update(X86CPUID_by_name)
+
   module Intrinsics
+    extend PrivateStateAccessor
     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 supported(intr_symbol, type, type2=nil)
+      instruction = intrinsics(intr_symbol, type, type2)
+      return false unless instruction
+      INSTRUCTIONS[instruction.to_s].each { |flag|
+        return true if MODELS[get_model].include?(flag)
+      }
+      return false
+    end
+
+    module_function :supported
+
+    def intrinsics_by_vector_name(intr_symbol, type, type2=nil)
+      return INTRINSICS[get_architecture][intr_symbol][type][type2] if type2
+      return INTRINSICS[get_architecture][intr_symbol][type]
+    end
+
+    module_function :intrinsics_by_vector_name
 
-    def intrinsics
-      return INTRINSICS
+    def intrinsics(intr_symbol, type, type2=nil)
+      return INTRINSICS[get_architecture][intr_symbol][get_vector_name(type)][get_vector_name(type2)] if type2
+      return INTRINSICS[get_architecture][intr_symbol][get_vector_name(type)]
     end
 
     module_function :intrinsics
 
+    def get_conversion_path(type_dest, type_orig)
+      return CONVERSIONS[get_architecture][get_vector_name(type_dest)][get_vector_name(type_orig)]
+    end
+
+    module_function :get_conversion_path
+
+    def get_vector_decl_X86( data_type )
+      raise "Unsupported vector size on X86: #{data_type.total_size*8}!" unless [64,128,256].include?( data_type.total_size*8 )
+      s = "__m#{data_type.total_size*8}"
+      case data_type
+      when Int
+        raise "Unsupported data size for int vector on X86: #{data_type.size*8}!" unless [1,2,4,8].include?( data_type.size )
+        return s+= "#{data_type.total_size*8>64 ? "i" : ""}"
+      when Real
+        return s if data_type.size == 4
+        return s += "d" if data_type.size == 8
+        raise "Unsupported data size for real vector on X86: #{data_type.size*8}!"
+      else
+        raise "Unsupported data type #{data_type} for vector!"
+      end
+    end
+
+    module_function :get_vector_decl_X86
+
+    def get_vector_decl_ARM( data_type )
+      raise "Unsupported vector size on ARM: #{data_type.total_size*8}!" unless [64,128].include?( data_type.total_size*8 )
+      case data_type
+      when Int
+        raise "Unsupported data size for int vector on ARM: #{data_type.size*8}!" unless [1,2,4,8].include?( data_type.size )
+        return get_vector_name( data_type ).to_s
+      when Real
+        raise "Unsupported data size for real vector on ARM: #{data_type.size*8}!" if data_type.size != 4
+        return get_vector_name( data_type ).to_s
+      else
+        raise "Unsupported data type #{data_type} for vector on ARM!"
+      end
+    end
+
+    module_function :get_vector_decl_ARM
+
+    def get_vector_decl( data_type )
+      case get_architecture
+      when X86
+        get_vector_decl_X86( data_type )
+      when ARM
+        get_vector_decl_ARM( data_type )
+      else
+        return get_vector_name( data_type )
+      end
+    end
+
+    module_function :get_vector_decl
+
     def get_vector_name( type )
       s = ""
       case type
       when Int
-        s += "u" if type.signed?
+        s += "u" unless type.signed?
         s += "int"
       when Real
         s += "float"
@@ -24,7 +116,7 @@ module BOAST
         raise "Undefined vector type!"
       end
       s += "#{type.size*8}"
-      s += "x#{type.vector_length}"
+      s += "x#{type.vector_length}_t"
       return s.to_sym
     end
 
@@ -48,7 +140,7 @@ module BOAST
         raise "Invalid type!"
       end
       s += "#{size}"
-      s += "x#{vector_size/size}"
+      s += "x#{vector_size/size}_t"
       return s.to_sym
     end
 
@@ -79,9 +171,9 @@ module BOAST
 
     def type_name_X86( type, size, vector_size, sign = :signed )
       s = ""
-      e = ( vector_size > 64 ? "e" : "" )
       case type
       when :int
+        e = ( vector_size > 64 ? "e" : "" )
         s += "#{e}p"
         case sign
         when :signed
@@ -126,6 +218,7 @@ module BOAST
           }
           if size == 64 and vector_size < 512 then
             INTRINSICS[X86][:SET1][vtype] = "_mm#{vs}_set1_#{type}x".to_sym
+            INTRINSICS[X86][:SET][vtype] = "_mm#{vs}_setr_#{type}x".to_sym
           end
         }
       }
@@ -144,9 +237,9 @@ module BOAST
         [[: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|
+         [:LOAD, "loadu"],    [:LOADA, "load"],        [:MASKLOAD, "maskload"],
+         [:STORE, "storeu"],  [:STOREA, "store"],      [:MASKSTORE, "maskstore"],
+         [:SET, "setr"],      [: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
@@ -170,6 +263,28 @@ module BOAST
           ssize /= 2
         end
       }
+      [64].each { |bsize|
+        ssize = bsize/2
+        svsize = (bvsize/bsize)*ssize
+        stype = type_name_X86( :float, ssize, 128 )
+        btype = type_name_X86( :float, bsize, bvsize )
+        svtype = vector_type_name( :float, ssize, svsize )
+        bvtype = vector_type_name( :float, bsize, bvsize )
+        vs = ( bvsize < 256 ? "" : "#{bvsize}" )
+        INTRINSICS[X86][:CVT][bvtype][svtype] = "_mm#{vs}_cvt#{stype}_#{btype}".to_sym
+        INTRINSICS[X86][:CVT][svtype][bvtype] = "_mm#{vs}_cvt#{btype}_#{stype}".to_sym
+      }
+      [64].each { |fsize|
+        [32].each { |isize|
+          ftype = type_name_X86( :float, fsize, bvsize )
+          itype = type_name_X86( :int, isize, isize*(bvsize/fsize), :signed )
+          fvtype = vector_type_name( :float, fsize, bvsize )
+          ivtype = vector_type_name( :int, isize, isize*(bvsize/fsize), :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
+        }
+      }
     }
 
 
@@ -180,7 +295,7 @@ module BOAST
           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( [:MUL, "mul"], [:FMADD, "mla"], [:FNMADD, "mls"] ) if size < 64
           instructions.push( [:LOAD, "ldl"], [:LOADA, "ldl"] )
           instructions.push( [:STORE, "stl"], [:STOREA, "stl"] )
           instructions.each { |cl, ins|
@@ -236,6 +351,29 @@ module BOAST
       }
     }
 
+    [X86, ARM].each { |arch|
+      cvt_dgraph = RGL::DirectedAdjacencyGraph::new
+      INTRINSICS[arch][:CVT].each { |dest, origs|
+        origs.each { |orig, intrinsic|
+          cvt_dgraph.add_edge(orig, dest)
+        }
+      }
+      cvt_dgraph.vertices.each { |source|
+        paths = cvt_dgraph.dijkstra_shortest_paths(cvt_dgraph.edges.map { |e| [e.to_a,1]}.to_h, source )
+        paths.each { |dest, path|
+          CONVERSIONS[arch][dest][source] = path if path
+        }
+      }
+      types = []
+      INTRINSICS[arch].each { |intrinsic, instructions|
+        types += instructions.keys
+      }
+      types.uniq
+      types.each { |type|
+        CONVERSIONS[arch][type][type] = [type]
+      }
+    }
+
   end
 
 end