BOAST 1.0.9 → 1.1.0

data/lib/BOAST/Language/CodeBlock.rb

@@ -0,0 +1,17 @@
+module BOAST
+
+  class CodeBlock < Proc
+    include PrivateStateAccessor
+    include Inspectable
+    extend Functor
+
+    attr_accessor :options
+
+    def initialize(options = {},&block)
+      @options = options
+      super(&block)
+    end
+
+  end
+
+end

data/lib/BOAST/Language/Comment.rb

@@ -0,0 +1,38 @@
+module BOAST
+
+  class Comment
+    extend Functor
+    include PrivateStateAccessor
+    include Inspectable
+    attr_reader :comment
+
+    def initialize(string)
+      @comment = string
+    end
+
+    def to_s_fortran
+      s = ""
+      @comment.each_line { |l| s += "! #{l}" }
+      return s
+    end
+
+    def to_s_c
+      s = ""
+      @comment.each_line { |l| s += "/* #{l.delete("\n")} */\n" }
+      return s
+    end
+
+    def to_s
+      return to_s_fortran if get_lang == FORTRAN
+      return to_s_c if [C,CL,CUDA].include?(get_lang)
+    end
+
+    def pr
+      s = to_s
+      output.puts s
+      return self
+    end
+
+  end
+
+end

data/lib/BOAST/Language/ControlStructure.rb

@@ -4,6 +4,8 @@ module BOAST
     include PrivateStateAccessor
     include Inspectable
 
+    attr_accessor :args
+
     def self.inherited(child)
       child.extend Functor
     end
@@ -23,6 +25,11 @@ module BOAST
 EOF
     end
 
+    def [](*args)
+      @args = args
+      return self
+    end
+
   end
 
 end

data/lib/BOAST/Language/Error.rb

@@ -0,0 +1,7 @@
+module BOAST
+  class Error < StandardError
+  end
+
+  class LanguageError < Error
+  end
+end

data/lib/BOAST/Language/Expression.rb

@@ -2,16 +2,15 @@ module BOAST
 
   module_function
 
-  def Return(value)
-    return Expression("return",nil, value)
-  end
-
   class Expression
     include PrivateStateAccessor
     include Arithmetic
     include Inspectable
     extend Functor
     include TypeTransition
+    include Annotation
+
+    ANNOTATIONS = [:operator, :operand1, :operand2]
 
     attr_reader :operator
     attr_reader :operand1
@@ -23,7 +22,7 @@ module BOAST
     end
 
     def to_s_base(op1, op2, oper, return_type = nil)
-      return oper.to_s(op1, op2, return_type) if not oper.kind_of?(String)
+      return oper.string(op1, op2, return_type) unless oper.kind_of?(String)
       s = ""
       if op1 then
         s += "(" if (oper == "*" or oper == "/") 

data/lib/BOAST/Language/For.rb

@@ -1,15 +1,27 @@
 module BOAST
 
   class For < ControlStructure
+    include Annotation
+    ANNOTATIONS = [ :iterator, :begin, :end, :step, :operator ]
 
     attr_reader :iterator
     attr_reader :begin
     attr_reader :end
     attr_reader :step
+    attr_accessor :block
+
+    def unroll?
+      return !!@unroll
+    end
+
+    def unroll=(val)
+      @unroll = val
+    end
 
     def initialize(i, b, e, options={}, &block)
       default_options = {:step => 1}
       default_options.update( options )
+      @options = options
       @iterator = i
       @begin = b
       @end = e
@@ -17,6 +29,8 @@ module BOAST
       @operator = "<="
       @block = block
       @openmp = default_options[:openmp]
+      @unroll = default_options[:unroll]
+      @args = default_options[:args]
       if @openmp then
         if @openmp.kind_of?(Hash) then
           @openmp = OpenMP::For(@openmp)
@@ -62,39 +76,55 @@ module BOAST
       return s
     end
 
-    def unroll(*args)
+#    def u(s = 2)
+#      return [For::new(@iterator, @begin, @end - (@step*s - 1), @options.dup.update( { :step => (@step*s) } ), &@block),
+#              For::new(@iterator, @begin.to_var + ((@end - @begin + 1)/(@step*s))*(@step*s), @end, @options, &@block) ]
+#    end
+#
+    def unroll
+      opts = @options.clone
+      opts[:unroll] = true
+      return For::new(@iterator, @begin, @end, opts, &block)
+    end
+
+    def pr_unroll(*args)
       raise "Block not given!" if not @block
-      push_env( :replace_constants => true )
       begin
-        if @begin.kind_of?(Variable) then
-          start = @begin.constant
-        elsif @begin.kind_of?(Expression) then
-          start = eval "#{@begin}"
-        else
-          start = @begin.to_i
-        end
-        if @end.kind_of?(Variable) then
-          e = @end.constant
-        elsif @end.kind_of?(Expression) then
-          e = eval "#{@end}"
-        else
-          e = @end.to_i
-        end
-        if @step.kind_of?(Variable) then
-          step = @step.constant
-        elsif @step.kind_of?(Expression) then
-          step = eval "#{@step}"
-        else
-          step = @step.to_i
+        begin
+          push_env( :replace_constants => true )
+          if @begin.kind_of?(Variable) then
+            start = @begin.constant
+          elsif @begin.kind_of?(Expression) then
+            start = eval "#{@begin}"
+          else
+            start = @begin.to_i
+          end
+          if @end.kind_of?(Variable) then
+            e = @end.constant
+          elsif @end.kind_of?(Expression) then
+            e = eval "#{@end}"
+          else
+            e = @end.to_i
+          end
+          if @step.kind_of?(Variable) then
+            step = @step.constant
+          elsif @step.kind_of?(Expression) then
+            step = eval "#{@step}"
+          else
+            step = @step.to_i
+          end
+          raise "Invalid bounds (not constants)!" if not ( start and e and step )
+        ensure
+          pop_env( :replace_constants )
         end
-        raise "Invalid bounds (not constants)!" if not ( start and e and step )
       rescue Exception => ex
-        if not ( start and e and step ) then
-          pop_env( :replace_constants )
-          return pr(*args) if not ( start and e and step )
+        open
+        if @block then
+          @block.call(*args)
+          close
         end
+        return self
       end
-      pop_env( :replace_constants )
       range = start..e
       @iterator.force_replace_constant = true
       range.step(step) { |i|
@@ -116,6 +146,8 @@ module BOAST
     end 
 
     def pr(*args)
+      args = @args if args.length == 0 and @args
+      return pr_unroll(*args) if unroll?
       open
       if @block then
         @block.call(*args)

data/lib/BOAST/Language/If.rb

@@ -5,24 +5,18 @@ module BOAST
     attr_reader :conditions
 
     def initialize(*conditions, &block)
+      raise "Illegal if construct!" if conditions.size == 0
+      conditions.push(block) if block
       @conditions = []
       @blocks = []
-      if conditions.size == 0 then
-        raise "Illegal if construct!"
-      elsif conditions.size == 1 then
-        @conditions.push(conditions[0])
-        @blocks.push(block)
-      elsif conditions.size.even? then
-        (0..conditions.size-1).step(2) { |i|
-          @conditions[i/2] = conditions[i]
-          @blocks[i/2] = conditions[i+1]
-        }
+      if conditions.size == 1 then
+        @conditions.push conditions.shift
       else
-        (0..conditions.size-2).step(2) { |i|
-          @conditions[i/2] = conditions[i]
-          @blocks[i/2] = conditions[i+1]
-        }
-        @blocks.push(conditions.last)
+        while conditions.size >= 2 do
+          @conditions.push conditions.shift
+          @blocks.push conditions.shift
+        end
+        @blocks.push conditions.shift if conditions.size > 0
       end
     end
 
@@ -63,7 +57,7 @@ module BOAST
     end
 
     def open
-      s=""
+      s = ""
       s += indent
       s += to_s
       output.puts s
@@ -72,11 +66,12 @@ module BOAST
     end
 
     def pr(*args)
+      args = @args if args.length == 0 and @args
       if @blocks.size > 0 then
         increment_indent_level
         @blocks.each_index { |indx|
           decrement_indent_level
-          s=""
+          s = ""
           s += indent
           s += to_s(indx)
           output.puts s

data/lib/BOAST/Language/Index.rb

@@ -3,19 +3,19 @@ module BOAST
   class Index < Expression
     attr_reader :source
     attr_reader :indexes
-    attr_accessor :align
+    attr_accessor :alignment
 
-    def initialize(source, indexes)
+    def initialize(source, *indexes)
       @source = source
       @indexes = indexes
     end
 
     def align?
-      return !!@align
+      return !!@alignment
     end
 
     def to_var
-      var = @source.copy("#{self}", :const => nil, :constant => nil, :dim => nil, :dimension => nil, :direction => nil, :dir => nil, :align => align)
+      var = @source.copy("#{self}", :const => nil, :constant => nil, :dim => nil, :dimension => nil, :direction => nil, :dir => nil, :align => alignment)
       return var
     end
 
@@ -60,7 +60,7 @@ module BOAST
     end
 
     def to_s_texture
-      raise "Unsupported language #{lang} for texture!" if not [CL, CUDA].include?( lang )
+      raise LanguageError, "Unsupported language #{lang} for texture!" if not [CL, CUDA].include?( lang )
       raise "Write is unsupported for textures!" if not ( @source.constant or @source.direction == :in )
       dim_number = 1
       if @source.dimension then

data/lib/BOAST/Language/Intrinsics.rb

@@ -21,71 +21,77 @@ module BOAST
   INSTRUCTIONS = {}
   INSTRUCTIONS.update(X86CPUID_by_name)
 
+  class IntrinsicsError < Error
+  end
+
+  class InternalIntrinsicsError < Error
+  end
+
   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
+    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
+      supported = false
       INSTRUCTIONS[instruction.to_s].each { |flag|
-        return true if MODELS[get_model].include?(flag)
+        supported = 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]
+      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
 
     module_function :intrinsics_by_vector_name
 
     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)]
+      return intrinsics_by_vector_name(intr_symbol, get_vector_name(type), type2 ? get_vector_name(type2) : nil)
     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)]
+      conversion_path = CONVERSIONS[get_architecture][get_vector_name(type_dest)][get_vector_name(type_orig)]
+      raise IntrinsicsError, "Unavailable conversion from #{get_vector_name(type_orig)} to #{get_vector_name(type_dest)} on #{get_architecture_name}!" unless conversion_path
+      return conversion_path
     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 )
+      raise IntrinsicsError, "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 )
+        raise IntrinsicsError, "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}!"
+        raise IntrinsicsError, "Unsupported data size for real vector on X86: #{data_type.size*8}!"
       else
-        raise "Unsupported data type #{data_type} for vector!"
+        raise IntrinsicsError, "Unsupported data type #{data_type} for vector on X86!"
       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 )
+      raise IntrinsicsError, "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 )
+        raise IntrinsicsError, "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
+        raise IntrinsicsError, "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!"
+        raise IntrinsicsError, "Unsupported data type #{data_type} for vector on ARM!"
       end
     end
 
@@ -113,7 +119,7 @@ module BOAST
       when Real
         s += "float"
       else
-        raise "Undefined vector type!"
+        raise InternalIntrinsicsError, "Undefined vector type!"
       end
       s += "#{type.size*8}"
       s += "x#{type.vector_length}_t"
@@ -132,12 +138,12 @@ module BOAST
         when :unsigned
           s += "uint"
         else
-          raise "Invalid sign!"
+          raise InternalIntrinsicsError, "Invalid sign!"
         end
       when :float
         s += "float"
       else
-        raise "Invalid type!"
+        raise InternalIntrinsicsError, "Invalid type!"
       end
       s += "#{size}"
       s += "x#{vector_size/size}_t"
@@ -156,12 +162,12 @@ module BOAST
         when :unsigned
           s += "u"
         else
-          raise "Invalid sign!"
+          raise InternalIntrinsicsError, "Invalid sign!"
         end
       when :float
         s += "f"
       else
-        raise "Invalid type!"
+        raise InternalIntrinsicsError, "Invalid type!"
       end
       s += "#{size}"
       return s
@@ -181,7 +187,7 @@ module BOAST
         when :unsigned
           s += "u"
         else
-          raise "Invalid sign!"
+          raise InternalIntrinsicsError, "Invalid sign!"
         end
         s += "#{size}"
       when :float
@@ -192,10 +198,10 @@ module BOAST
         when 64
           s += "d"
         else
-          raise "Invalid size!"
+          raise InternalIntrinsicsError, "Invalid size!"
         end
       else
-        raise "Invalid type!"
+        raise InternalIntrinsicsError, "Invalid type!"
       end
       return s
     end
@@ -234,7 +240,7 @@ module BOAST
       sizes = []
       sizes.push( 32, 64 ) if vector_size > 64
       sizes.each { |size|
-        [[:ADD, "add"],       [:SUB, "sub"],           [:MUL, "mul"],       [:DIV, "div"],
+        [[: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"],