BOAST 1.3.5 → 2.0.0

data/lib/BOAST/Language/For.rb

@@ -11,15 +11,28 @@ module BOAST
     attr_reader :step
     attr_accessor :block
 
+    # returns the Boolean evaluation of the unroll attribute.
     def unroll?
       return !!@unroll
     end
 
+    # Sets the unroll attribute to val.
     def unroll=(val)
       @unroll = val
     end
 
+    # Creates a new instance of the For construct.
+    # @param [Variable] iterator
+    # @param [#to_s] first iteration start
+    # @param [#to_s] last iteration stop (inclusive)
+    # @param [Hash] options contains named options
+    # @param [Proc,nil] block if given, will be evaluated when {pr} is called
+    # @option options [#to_s] :step spcifies the increment in the for loop
+    # @option options [Boolean,Hash] :openmp specifies if an OpenMP For pragma has to be generated. If a Hash is specified it conatins the OpenMP clauses and their values.
+    # @option options [Boolean] :unroll specifies if {pr} must try to unroll the loop
+    # @option options [Array<Object>] :args arguments to be passed to the block. Will be superseded by those provided by {pr}
     def initialize(iterator, first, last, options={}, &block)
+      super()
       default_options = {:step => 1}
       default_options.update( options )
       @options = options
@@ -39,21 +52,20 @@ module BOAST
           @openmp = OpenMP::For({})
         end
       end
-      begin
-        push_env( :replace_constants => true )
-        if @step.kind_of?(Variable) then
-          step = @step.constant
-        elsif @step.kind_of?(Expression) then
-          step = eval "#{@step}"
-        else
-          step = @step.to_i
+      push_env( :replace_constants => true ) {
+        begin
+          if @step.kind_of?(Variable) then
+            step = @step.constant
+          elsif @step.kind_of?(Expression) then
+            step = eval "#{@step}"
+          else
+            step = @step.to_i
+          end
+          @operator = ">=" if step < 0
+        rescue
+          STDERR.puts "Warning could not determine sign of step (#{@step}) assuming positive" if [C, CL, CUDA].include?( lang ) and debug?
         end
-        @operator = ">=" if step < 0
-      rescue
-        STDERR.puts "Warning could not determine sign of step (#{@step}) assuming positive" if [C, CL, CUDA].include?( lang ) and debug?
-      ensure
-        pop_env( :replace_constants )
-      end
+      }
     end
 
     def get_c_strings
@@ -74,19 +86,28 @@ module BOAST
     eval token_string_generator( * %w{for i b e s o})
     eval token_string_generator( * %w{end})
 
+    # Returns a string representation of the For construct.
     def to_s
       s = for_string(@iterator, @first, @last, @step, @operator)
       return s
     end
 
-    def unroll
-      opts = @options.clone
-      opts[:unroll] = true
-      return For::new(@iterator, @first, @last, opts, &block)
+    # Creates a copy of this For construct with the unroll option set and returns it if it is different from the current unroll flag.
+    # @return [For]
+    # @param [Boolean] flag specifying if the For should be unrolled or not
+    def unroll( flag = true )
+      if flag ^ @unroll then
+        opts = @options.clone
+        opts[:unroll] = flag
+        return For::new(@iterator, @first, @last, opts, &block)
+      else
+        return self
+      end
     end
 
-    def pr_unroll(*args)
-      raise "Block not given!" if not @block
+    def pr_unroll(*args, &block)
+      block = @block unless block
+      raise "Block not given!" unless block
       begin
         begin
           push_env( :replace_constants => true )
@@ -115,19 +136,17 @@ module BOAST
         ensure
           pop_env( :replace_constants )
         end
-      rescue Exception => ex
+      rescue Exception
         open
-        if @block then
-          @block.call(*args)
-          close
-        end
+        block.call(*args)
+        close
         return self
       end
       range = first..last
       @iterator.force_replace_constant = true
       range.step(step) { |i|
         @iterator.constant = i
-        @block.call(*args)
+        block.call(*args)
       }
       @iterator.force_replace_constant = false
       @iterator.constant = nil
@@ -135,6 +154,8 @@ module BOAST
 
     private :pr_unroll
 
+    # Opens the For construct (keyword, iterator, bounds, step, opening bracket in C like languages). The result is printed to the BOAST output.
+    # @return [self]
     def open
       @openmp.open if @openmp
       s=""
@@ -145,17 +166,25 @@ module BOAST
       return self
     end 
 
-    def pr(*args)
+    # Prints the For construct to the BOAST output (see {open}).
+    # If a block is provided during initialization, it will be printed and the construct will be closed (see {close}).
+    # @param [Array<Object>] args any number of arguments to pass to the block
+    # @param [Proc] block an optional block to be evaluated. Supersede the one given at initialization
+    # @return [self]
+    def pr(*args, &block)
       args = @args if args.length == 0 and @args
-      return pr_unroll(*args) if unroll?
+      block = @block unless block
+      return pr_unroll(*args, &block) if unroll?
       open
-      if @block then
-        @block.call(*args)
+      if block then
+        block.call(*args)
         close
       end
       return self
     end
 
+    # Closes the For construct (keyword, closing bracket in C like languages). The result is printed to the BOAST output.
+    # @return [self]
     def close
       decrement_indent_level      
       s = ""

data/lib/BOAST/Language/FuncCall.rb

@@ -7,22 +7,25 @@ module BOAST
     include Inspectable
     extend Functor
 
-    @return_type
-    @options
-
     attr_reader :func_name
     attr_reader :args
     attr_accessor :prefix
 
     def initialize(func_name, *args)
+      @prefix = nil
       @func_name = func_name
       if args.last.kind_of?(Hash) then
         @options = args.last
         @args = args[0..-2]
       else
         @args = args
+        @options = {}
       end
-      @return_type = @options[:returns] if @options
+      @return_type = @options[:return] ? @options[:return] : @options[:returns] if @options
+    end
+
+    def type
+      return @return_type.type if @return_type
     end
 
     def to_var
@@ -32,8 +35,9 @@ module BOAST
         else
           return Variable::new("#{self}", @return_type)
         end
+      else
+        return Variable::new("#{self}", get_default_type)
       end
-      return nil
     end
       
     def to_s

data/lib/BOAST/Language/Functors.rb

@@ -49,7 +49,7 @@ EOF
     #   Creates a new Variable of type $1.
     #   @param [#to_s] name name of the Variable
     #   @param [Object] args parameters to use when creating a Variable
-    #   @param [Block] block block of code will be forwarded
+    #   @param [Proc] block block of code will be forwarded
     def var_functorize(klass)
       name = klass.name.split('::').last
       s = <<EOF

data/lib/BOAST/Language/HighLevelOperators.rb

@@ -0,0 +1,172 @@
+module BOAST
+
+  class HighLevelOperator < Operator
+    include Intrinsics
+    include Arithmetic
+    include Inspectable
+  end
+
+  class Sqrt < HighLevelOperator
+    extend Functor
+
+    attr_reader :operand
+    attr_reader :return_type
+
+    def initialize(a)
+      @operand = a
+      @return_type = a.to_var
+      unless @return_type.type.kind_of?(Real) then
+        @return_type = Variable::new(:sqrt_type, Real, :vector_length => @return_type.type.vector_length)
+      end
+    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
+      sqrt_instruction = nil
+      rsqrt_instruction = nil
+      begin
+        sqrt_instruction = intrinsics(:SQRT,@return_type.type)
+      rescue
+      end
+      unless sqrt_instruction then
+        begin
+          rsqrt_instruction = intrinsics(:RSQRT,@return_type.type)
+        rescue
+        end
+      end
+
+      if [FORTRAN, CL].include?(lang) then
+        return @return_type.copy( "sqrt( #{@operand} )", DISCARD_OPTIONS )
+      elsif lang == CUDA or ( sqrt_instruction.nil? and rsqrt_instruction.nil? ) then
+        raise IntrinsicsError, "Vector square root unsupported on ARM architecture!" if architecture == ARM and @return_type.type.vector_length > 1
+        if @return_type.type.size <= 4 then
+          return @return_type.copy( "sqrtf( #{@operand} )", DISCARD_OPTIONS )
+        else
+          return @return_type.copy( "sqrt( #{@operand} )", DISCARD_OPTIONS )
+        end
+      end
+      op = convert_operand(@operand.to_var)
+      if sqrt_instruction then
+        return @return_type.copy( "#{sqrt_instruction}( #{op} )", DISCARD_OPTIONS )
+      else
+        return (op * @return_type.copy("#{rsqrt_instruction}( #{op} )", DISCARD_OPTIONS)).to_var
+      end
+    end
+
+    def to_s
+      return to_var.to_s
+    end
+
+    def pr
+      s=""
+      s += indent
+      s += to_s
+      s += ";" if [C, CL, CUDA].include?( lang )
+      output.puts s
+      return self
+    end
+
+  end
+
+  class TrigonometricOperator < HighLevelOperator
+    attr_reader :operand
+    attr_reader :return_type
+
+    def initialize(a)
+      @operand = a
+      @return_type = a.to_var
+      unless @return_type.type.kind_of?(Real) then
+        @return_type = Variable::new(:trig_type, Real, :vector_length => @return_type.type.vector_length)
+      end
+    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(get_intrinsic_symbol,@return_type.type)
+      rescue
+      end
+
+      if [FORTRAN, CL].include?(lang) then
+        return @return_type.copy( "#{get_name[lang]}( #{@operand} )", DISCARD_OPTIONS )
+      elsif lang == CUDA or instruction.nil? then
+        raise IntrinsicsError, "Vector #{get_name[lang]} root unsupported on ARM architecture!" if architecture == ARM and @return_type.type.vector_length > 1
+        if @return_type.type.size <= 4 then
+          return @return_type.copy( "#{get_name[lang]}f( #{@operand} )", DISCARD_OPTIONS )
+        else
+          return @return_type.copy( "#{get_name[lang]}( #{@operand} )", DISCARD_OPTIONS )
+        end
+      end
+      op = convert_operand(@operand.to_var)
+      return @return_type.copy( "#{instruction}( #{op} )", DISCARD_OPTIONS )
+    end
+
+    def to_s
+      return to_var.to_s
+    end
+
+    def pr
+      s=""
+      s += indent
+      s += to_s
+      s += ";" if [C, CL, CUDA].include?( lang )
+      output.puts s
+      return self
+    end
+
+  end
+
+  def self.generic_trigonometric_operator_generator( name )
+    eval <<EOF
+  class #{name.capitalize} < TrigonometricOperator
+    extend Functor
+
+    def get_intrinsic_symbol
+      return :#{name.upcase}
+    end
+
+    def get_name
+      return { C => "#{name}", CUDA => "#{name}", CL => "#{name}", FORTRAN => "#{name}" }
+    end
+
+  end
+
+EOF
+  end
+
+  generic_trigonometric_operator_generator( "sin" )
+  generic_trigonometric_operator_generator( "cos" )
+  generic_trigonometric_operator_generator( "tan" )
+  generic_trigonometric_operator_generator( "sinh" )
+  generic_trigonometric_operator_generator( "cosh" )
+  generic_trigonometric_operator_generator( "tanh" )
+  generic_trigonometric_operator_generator( "asin" )
+  generic_trigonometric_operator_generator( "acos" )
+  generic_trigonometric_operator_generator( "atan" )
+  generic_trigonometric_operator_generator( "asinh" )
+  generic_trigonometric_operator_generator( "acosh" )
+  generic_trigonometric_operator_generator( "atanh" )
+
+  generic_trigonometric_operator_generator( "exp" )
+  generic_trigonometric_operator_generator( "log" )
+  generic_trigonometric_operator_generator( "log10" )
+end

data/lib/BOAST/Language/If.rb

@@ -5,7 +5,17 @@ module BOAST
 
     attr_reader :conditions
 
+    # Creates a new instance of the If construct
+    # @overload initialize(condition, &block)
+    #   Creates a simple If construct
+    #   @param [Expression] condition
+    #   @param [Proc,nil] block if given, will be evaluated when {pr} is called
+    # @overload initialize(conditions, &block)
+    #   Creates a multi-condition If construct
+    #   @param [Hash{Expression, :else => Proc}] conditions each condition and its associated block (can be nil)
+    #   @param [Proc,nil] block else block if :else is not specified in the conditions or nil
     def initialize(conditions, &block)
+      super()
       @conditions = []
       @blocks = []
       if conditions.is_a?(Hash) then
@@ -46,6 +56,8 @@ module BOAST
     eval token_string_generator( * %w{else} )
     eval token_string_generator( * %w{end} )
 
+    # Returns a string representation of the If construct.
+    # @param [Fixnum] condition_number condition to print
     def to_s(condition_number = 0)
       s = ""
       if condition_number == 0 then
@@ -60,26 +72,28 @@ module BOAST
       return s
     end
 
-    def open
+    # Opens the If construct. The result is printed on the BOAST output. If a condition number is given, will print the corresponding condition (or else if none exist)
+    # @param [Fixnum] condition_number condition to print
+    # @return [self]
+    def open(condition_number = 0)
+      decrement_indent_level if condition_number > 0
       s = ""
       s += indent
-      s += to_s
+      s += to_s(condition_number)
       output.puts s
       increment_indent_level
       return self
     end
 
+    # Prints the If construct to the BOAST output (see {open}).
+    # If block/blocks is/are provided during initialization, they will be printed and the construct will be closed (see {close}).
+    # @param [Array<Object>] args any number of arguments to pass to the block/blocks
+    # @return [self]
     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 += indent
-          s += to_s(indx)
-          output.puts s
-          increment_indent_level
+          open(indx)
           @blocks[indx].call(*args)
         }
         close
@@ -89,6 +103,8 @@ module BOAST
       return self
     end
 
+    # Closes the If construct (keyword, closing bracket in C like languages). The result is printed to the BOAST output.
+    # @return [self]
     def close
       decrement_indent_level
       s = ""