BOAST 1.3.5 → 2.0.0

data/lib/BOAST/Language/Parens.rb

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

data/lib/BOAST/Language/Procedure.rb

@@ -20,7 +20,8 @@ module BOAST
     # @param [Hash] properties set of named properties for the Procedure.
     # @option properties [Array<Variables>] :constants list of constant variables that are used in the Procedure. (see parameter in Fortran).
     # @option properties [Array<#to_s>] :headers list of headers that need to be included in order to compile the Procedure
-    # @option propertirs [Variable] :return a Variable that will be returned. Procedure becomes a function, return type is the same as the returned variable. The variable will be declared at the start of the procedure.
+    # @option properties [Variable] :return a Variable that will be returned. Procedure becomes a function, return type is the same as the returned variable. The variable will be declared at the start of the procedure.
+    # @option properties [Procedure] :functions sub functions used by this Procedure (FORTRAN return type of functions are problematic)
     def initialize(name, parameters=[], properties={}, &block)
       @name = name
       @parameters = parameters
@@ -42,8 +43,8 @@ module BOAST
 
     def call(*parameters)
       prefix = ""
-      prefix += "call " if lang==FORTRAN
-      f = FuncCall::new(@name, *parameters)
+      prefix += "call " if lang==FORTRAN and @properties[:return].nil?
+      f = FuncCall::new(@name, *parameters, :return => @properties[:return] )
       f.prefix = prefix
       return f
     end
@@ -54,9 +55,9 @@ module BOAST
     end
 
     # Returns a {CKernel} with the Procedure as entry point.
-    def ckernel
+    def ckernel(* args)
       old_output = output
-      k = CKernel::new
+      k = CKernel::new(* args)
       k.procedure = self
       self.pr
       set_output( old_output )
@@ -87,6 +88,13 @@ module BOAST
       return to_s_fortran if lang==FORTRAN
     end
 
+    protected
+
+    def fortran_type
+      raise "No return type for procedure!" unless @properties[:return]
+      output.puts indent + "#{@properties[:return].type.decl} :: #{@name}"
+    end
+
     private
 
     def decl_fortran
@@ -209,6 +217,11 @@ module BOAST
         align = p.align
         BOAST::pr align if align
       }
+      if @properties[:functions] then
+        @properties[:functions].each { |f|
+          f.fortran_type
+        }
+      end
       if @properties[:return] then
         BOAST::decl @properties[:return]
       end

data/lib/BOAST/Language/Slice.rb

@@ -1,16 +1,123 @@
 module BOAST
 
-  class Slice
-    include PrivateStateAccessor
-    include Inspectable
+  class Slice < Expression
+    class SliceItem
+      include PrivateStateAccessor
+      include Inspectable
+
+      attr_reader :first
+      attr_reader :last
+      attr_reader :step
+      attr_reader :length
+
+      def all?
+        @first.nil?
+      end
+
+      def scalar?
+        not all? and @last.nil?
+      end
+
+      def initialize(slice)
+        @first = nil
+        @last = nil
+        @step = nil
+        if slice.kind_of?(SliceItem) then
+          copy_slice!(slice)
+        elsif slice.kind_of?(Range) then
+          @first = slice.first
+          @last = slice.last
+          @last = Expression::new(Subtraction, @last, 1) if slice.exclude_end?
+          @length = Expression::new(Subtraction, @last, @first)
+          @length = @length + 1
+        elsif slice.kind_of?(Array) then
+          @first = slice [0] if slice.length > 0
+          @last = slice [1] if slice.length > 1
+          @step = slice [2] if slice.length > 2
+          @length = Expression::new(Subtraction, @last, @first)
+          @length = @length / @step if @step
+          @length = @length + 1
+        elsif slice.kind_of?(Symbol) then
+          raise "Invalid Slice item: #{slice.inspect}!" if slice != :all
+        else
+          @first = slice
+        end
+      end
+
+      def copy_slice!(slice)
+        @first = slice.first
+        @last = slice.last
+        @step = slice.step
+        @length = slice.length
+        self
+      end
+
+      def recurse!(s, d)
+        if all? then
+          copy_slice!(s)
+        else
+          @first = Expression::new(Subtraction, @first, get_array_start)
+          @first = @first * s.step if s.step
+          if s.all? then
+            @first = Expression::new(Addition, d.start, @first )
+          else
+            @first = Expression::new(Addition, s.first, @first )
+          end
+          if not scalar? then
+            if s.step then
+              if @step then
+                @step = Expression::new(Multiplication, @step, s.step)
+              else
+                @step = s.step
+              end
+            end
+            @last = @first + (@length-1)*@step
+          end
+        end
+        return self
+      end
+
+      def to_a
+        a = []
+        a.push @first if @first
+        a.push @last if @last
+        a.push @step if @step
+        return a
+      end
+
+    end
+
     attr_reader :source
     attr_reader :slices
+    attr_accessor :alignment
 
     def initialize(source, *slices)
       raise "Cannot slice a non array Variable!" if not source.dimension?
       raise "Invalid slice!" if slices.length != source.dimension.length
       @source = source
-      @slices = slices
+      @slices = slices.collect{ |s| SliceItem::new(s) }
+    end
+
+    def dimension?
+      true
+    end
+
+    def dimension
+      dims = []
+      slices.each_with_index { |slice, i|
+        if not slice.scalar? then
+          if slice.all? then
+            if source.dimension[i].size then
+              dims.push Dimension::new( source.dimension[i].size )
+            else
+              dims.push Dimension::new
+            end
+          else
+            dims.push Dimension::new( slice.length )
+          end
+        end
+      }
+      return dims
     end
 
     def to_s
@@ -27,60 +134,85 @@ module BOAST
       return self
     end
 
+    def align?
+      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
+    end
+
+    # Indexes a {Slice}
+    # @param [Array{#to_s, Range, [first, last, step], :all, nil}] args one entry for each {SliceItem} of the {Slice}.
+    #   * Range: if an index is a Range, the result will be a {Slice}. The Range can be exclusive. The first and last item of the Range will be considered first and last index in the corresponding {SliceItem}.
+    #   * [first, last, step]: if an index is an Array, the result will be a {Slice}. The first and last item of the array will be considered first and last index in the corresponding {SliceItem}. If a step is given the range will be iterated by step.
+    #   * :all, nil: The whole corresponding {SliceItem} will be used for the slice.
+    #   * #to_s: If an index is none of the above it will be considered a scalar index. If all indexes are scalar an {Index} will be returned.
+    # @return [Slice, Index]
+    def [](*args)
+      slice = false
+      args.each { |a|
+        slice = true if a.kind_of?(Range) or a.kind_of?(Array) or a.kind_of?(Symbol) or a.nil?
+      }
+      new_args = []
+      slices.each_with_index { |s, i|
+        if not s.scalar?
+          raise "Invalid slice!" if args.length == 0
+          new_arg = SliceItem::new(args.shift)
+          new_arg.recurse!(s, @source.dimension[i])
+          new_args.push new_arg
+        else
+          new_args.push s
+        end
+      }
+      if slice then
+        return Slice::new(@source, *new_args)
+      else
+        return Index::new(@source, *(new_args.collect(&:first)))
+      end
+    end
+
     private
 
     def to_s_c
-      s = "#{@source}["
       dims = @source.dimension.reverse
-      slices = @slices.reverse
-      slices_to_c = []
-      slices.each_index { |indx|
-        slice = slices[indx]
-        if slice.kind_of?(Array) then
-          if slice.length == 0 then
-            slices_to_c.push(":")
-          elsif slice.length == 1 then
-            slices_to_c.push("#{Expression::new(Substraction, slice[0], dims[indx].start)}")
-          else
-            start, finish, step = slice
-            start_c = Expression::new(Substraction, start, dims[indx].start)
-            length = Expression::new(Substraction, finish, start) + 1
-            slices_to_c.push("#{start_c}:#{length}")
-          end
-        elsif slice.kind_of?(Range) then
-          start = slice.first
-          finish = slice.last
-          start_c = Expression::new(Substraction, start, dims[indx].start)
-          length = Expression::new(Substraction, finish, start)
-          length = length + 1 unless slice.exclude_end?
-          slices_to_c.push("#{start_c}:#{length}")
-        elsif slice then
-          slices_to_c.push("#{Expression::new(Substraction, slice, dims[indx].start)}")
+      slices_to_c = @slices.reverse.each_with_index.collect { |slice, indx|
+        if slice.all? then
+          ":"
         else
-          slices_to_c.push(":")
+          start = Expression::new(Subtraction, slice.first, dims[indx].start)
+          s = "#{start}"
+          if not slice.scalar? then
+            s += ":#{slice.length}"
+#           s += ":#{slice.step}" if slice.step
+            raise "Slice don't support step in C!" if slice.step
+          end
+          s
         end
       }
-      return s + slices_to_c.join("][") + "]"
+      return "#{@source}[#{slices_to_c.join("][")}]"
     end
 
     def to_s_fortran
       slices_to_fortran = @slices.collect { |slice|
-        if slice then
-          if slice.kind_of?(Range) then
-            "#{slice.first}:#{slice.last}#{slice.exclude_end? ? " - 1" : "" }"
-          else
-            sl = [slice].flatten
-            if sl.length > 0 then
-              sl.join(":")
-            else
-              ":"
-            end
-          end
-        else
+        if slice.all? then
           ":"
+        else
+          s = "#{slice.first}"
+          if not slice.scalar? then
+            s += ":#{slice.last}"
+            s += ":#{slice.step}" if slice.step
+          end
+          s
         end
       }
-      return "#{source}(#{slices_to_fortran.join(",")})"
+      return "#{@source}(#{slices_to_fortran.join(", ")})"
     end
 
   end

data/lib/BOAST/Language/Variable.rb

@@ -26,7 +26,7 @@ module BOAST
           begin
             @size = v2-v1+1
           rescue
-            @size = Expression::new(Substraction, v2, v1) + 1
+            @size = Expression::new(Subtraction, v2, v1) + 1
           end
         else
           @size = v1
@@ -149,21 +149,22 @@ module BOAST
     include Annotation
     ANNOTATIONS = [ :name, :type, :dimension ]
 
-    alias_method :orig_method_missing, :method_missing
-
     def method_missing(m, *a, &b)
       if @type.methods.include?(:members) and @type.members[m.to_s] then
         return struct_reference(type.members[m.to_s])
-      elsif @type.methods.include?(:vector_length) and @type.vector_length > 1 and m.to_s[0] == 's' and lang == CL then
+      elsif __vector? and m.to_s[0] == 's' and lang != CUDA then
         required_set = m.to_s[1..-1].chars.to_a
         existing_set = [*('0'..'9'),*('a'..'z')].first(@type.vector_length)
         if required_set.length == required_set.uniq.length and (required_set - existing_set).empty? then
-          return copy(name+"."+m.to_s, :vector_length => m.to_s[1..-1].length)
+          return copy(name+"."+m.to_s, :vector_length => m.to_s[1..-1].length) if lang == CL
+          return copy("#{name}(#{existing_set.index(required_set[0])+1})", :vector_length => 1) if lang == FORTRAN
+          return copy("#{name}[#{existing_set.index(required_set[0])}]", :vector_length => 1) if lang == C
+          super
         else
-          return orig_method_missing(m, *a, &b)
+          super
         end
       else
-        return orig_method_missing(m, *a, &b)
+        super
       end
     end
 
@@ -180,60 +181,69 @@ module BOAST
     attr_reader :deferred_shape
     attr_reader :optional
     attr_accessor :reference
-    attr_accessor :alignment
+    attr_writer :alignment
     attr_accessor :replace_constant
     attr_accessor :force_replace_constant
 
+    def alignment
+      return @type.total_size if __vector? and lang == FORTRAN and not @alignment
+      return @alignment
+    end
+
     def constant?
-      !!@constant
+      @constant
     end
 
     def allocate?
-      !!@allocate
+      @allocate
     end
 
     def texture?
-      !!@texture
+      @texture
     end
 
     def local?
-      !!@local
+      @local
     end
 
     def restrict?
-      !!@restrict
+      @restrict
     end
 
     def replace_constant?
-      !!@replace_constant
+      @replace_constant
     end
 
     def force_replace_constant?
-      !!@force_replace_constant
+      @force_replace_constant
     end
 
     def dimension?
-      !!@dimension
+      @dimension
     end
 
     def scalar_output?
-      !!@scalar_output
+      @scalar_output
     end
 
     def optional?
-      !!@optional
+      @optional
     end
 
     def align?
-      !!@alignment
+      alignment
     end
 
     def deferred_shape?
-      !!@deferred_shape
+      @deferred_shape
     end
 
     def reference?
-      !!@reference
+      @reference
+    end
+
+    def vector?
+      __vector?
     end
 
     # Creates a new {Variable}
@@ -248,16 +258,24 @@ module BOAST
     # @option properties [Symbol] :allocate specify that the variable is to be allocated and where. Can only be *:heap* or *:stack* for now.
     # @option properties [Boolean] :local indicates that the variable is to be allocated on the __local space of OpenCL devices or __shared__ space of CUDA devices. In C or FORTRAN this has the same effect as *:allocate* => *:stack*.
     # @option properties [Boolean] :texture for OpenCL and CUDA. In OpenCL also specifies that a sampler has to be generated to access the array variable.
-    # @option properties [Integer] :align specifies the alignment the variable will be declared/allocated with if allocated or is supposed to have if it is coming from another context.
+    # @option properties [Integer] :align specifies the alignment the variable will be declared/allocated with if allocated or is supposed to have if it is coming from another context (in bytes).
     # @option properties [Boolean] :replace_constant specifies that for scalar constants this variable should be replaced by its constant value. For constant arrays, the value of the array will be replaced if the index can be determined at evaluation.
     # @option properties [Boolean] :deferred_shape for Fortran interface generation mainly see Fortran documentation
     # @option properties [Boolean] :optional for Fortran interface generation mainly see Fortran documentation
     def initialize(name, type, properties={})
       @name = name.to_s
-      @direction = properties[:direction] ? properties[:direction] : properties[:dir]
-      @constant = properties[:constant] ? properties[:constant]  : properties[:const]
-      @dimension = properties[:dimension] ? properties[:dimension] : properties[:dim]
-      @local = properties[:local] ? properties[:local] : properties[:shared]
+      @direction = properties[:direction]
+      @direction = properties[:dir] unless @direction
+
+      @constant = properties[:constant]
+      @constant = properties[:const] unless @constant
+
+      @dimension = properties[:dimension]
+      @dimension = properties[:dim] unless @dimension
+
+      @local = properties[:local]
+      @local = properties[:shared] unless @local
+
       @texture = properties[:texture]
       @allocate = properties[:allocate]
       @restrict = properties[:restrict]
@@ -266,24 +284,23 @@ module BOAST
       @optional = properties[:optional]
       @reference = properties[:reference]
       @force_replace_constant = false
-      if not properties[:replace_constant].nil? then
-        @replace_constant = properties[:replace_constant]
-      else
-        @replace_constant = true
-      end
+      @replace_constant = properties[:replace_constant]
+
       if @texture and lang == CL then
         @sampler = Variable::new("sampler_#{name}", CustomType,:type_name => "sampler_t" ,:replace_constant => false, :constant => "CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST")
       else
         @sampler = nil
       end
-      @type = type::new(properties)
-      @properties = properties
-      if (@direction == :out or @direction == :inout) and not dimension? then
-        @scalar_output = true
+
+      @scalar_output = false
+      if @dimension then
+        @dimension = [@dimension].flatten
       else
-        @scalar_output = false
+        @scalar_output = true if @direction == :out or @direction == :inout
       end
-      @dimension = [@dimension].flatten if dimension?
+
+      @type = type::new(properties)
+      @properties = properties
     end
 
     def copy(name=nil,properties={})
@@ -343,8 +360,23 @@ module BOAST
       return Expression::new("++",self,nil)
     end
 
+    # Indexes a {Variable} with the :dimension (or :dim) property set
+    # @param [Array{#to_s, Range, [first, last, step], :all, nil}] args one entry for each {Dimension} of the {Variable}.
+    #   * Range: if an index is a Range, the result will be a {Slice}. The Range can be exclusive. The first and last item of the Range will be considered first and last index in the corresponding {Dimension}.
+    #   * [first, last, step]: if an index is an Array, the result will be a {Slice}. The first and last item of the array will be considered first and last index in the corresponding {Dimension}. If a step is given the range will be iterated by step.
+    #   * :all, nil: The whole dimension will be used for the slice. But indexing will start at #get_array_start instead of the original index.
+    #   * #to_s: If an index is none of the above it will be considered a scalar index. If all indexes are scalar an {Index} will be returned.
+    # @return [Slice, Index]
     def [](*args)
-      return Index::new(self,*args)
+      slice = false
+      args.each { |a|
+        slice = true if a.kind_of?(Range) or a.kind_of?(Array) or a.kind_of?(Symbol) or a.nil?
+      }
+      if slice then
+        return Slice::new(self, *args)
+      else
+        return Index::new(self, *args)
+      end
     end
  
     def boast_header(lang=C)
@@ -389,6 +421,8 @@ module BOAST
           return align_c(a) if lang == C
           return align_fortran(a) if lang == FORTRAN
         end
+      elsif vector? then
+        return align_fortran(alignment) if lang == FORTRAN
       end
       return nil
     end
@@ -409,43 +443,47 @@ module BOAST
     private
 
     def __const?
-      return !!( constant? or @direction == :in )
+      return ( constant? or @direction == :in )
     end
 
     def __global?
-      return !!( lang == CL and @direction and dimension? and not (@properties[:register] or @properties[:private] or local?) )
+      return ( lang == CL and @direction and dimension? and not (@properties[:register] or @properties[:private] or local?) )
     end
 
     def __local?
-      return !!( lang == CL and local? )
+      return ( lang == CL and local? )
     end
 
     def __shared?(device = false)
-      return !!( lang == CUDA and local? and not device )
+      return ( lang == CUDA and local? and not device )
     end
 
     def __vla_array?
-      return !!( use_vla? and dimension? and not decl_module? )
+      return ( use_vla? and dimension? and not decl_module? )
     end
 
     def __pointer_array?(device = false)
-      return !!( dimension? and not constant? and not ( allocate? and @allocate != :heap ) and (not local? or (local? and device)) )
+      return ( dimension? and not constant? and not ( allocate? and @allocate != :heap ) and (not local? or (local? and device)) )
     end
 
     def __pointer?(device = false)
-      return !!( ( not dimension? and ( @direction == :out or @direction == :inout or @reference ) ) or __pointer_array?(device) )
+      return ( ( not dimension? and ( @direction == :out or @direction == :inout or @reference ) ) or __pointer_array?(device) )
     end
 
     def __restrict?
-      return !!( restrict? and not decl_module? )
+      return ( restrict? and not decl_module? )
     end
 
     def __dimension?(device = false)
-      return !!( dimension? and ((local? and not device) or ( ( allocate? and @allocate != :heap ) and not constant?)) )
+      return ( dimension? and ((local? and not device) or ( ( allocate? and @allocate != :heap ) and not constant?)) )
     end
 
     def __align?
-      return !!( dimension? and (align? or default_align > 1) and (constant? or (allocate? and @allocate != :heap ) ) )
+      return ( dimension? and (align? or default_align > 1) and (constant? or (allocate? and @allocate != :heap ) ) )
+    end
+
+    def __vector?
+      return ( @type.vector? and @type.vector_length > 1 )
     end
 
     def decl_c_s(device = false)
@@ -531,18 +569,19 @@ module BOAST
       return Pragma::new("DIR", "ASSUME_ALIGNED", "#{@name}: #{a}")
     end
 
-    def alloc_fortran( dims = nil )
+    def alloc_fortran( dims )
+      dims.unshift( @type.vector_length ) if __vector?
       return FuncCall::new(:allocate, FuncCall(name, * dims ) )
     end
 
-    def alloc_c( dims = nil, align = get_address_size)
-      d = dims.collect { |d| d.to_s }.reverse.join(")*(")
+    def alloc_c( dims, align = get_address_size)
+      ds = dims.collect { |d| d.to_s }.reverse.join(")*(")
       if align > (OS.bits/8) then
         # check alignment is a power of 2
         raise "Invalid alignment #{align}!" if align & (align - 1) != 0
-        return FuncCall::new(:posix_memalign, address, align, FuncCall::new(:sizeof, @type.decl) * d)
+        return FuncCall::new(:posix_memalign, address, align, FuncCall::new(:sizeof, @type.decl) * ds)
       else
-        return self === FuncCall::new(:malloc, FuncCall::new(:sizeof, @type.decl) * d).cast(self)
+        return self === FuncCall::new(:malloc, FuncCall::new(:sizeof, @type.decl) * ds).cast(self)
       end
     end
 
@@ -562,15 +601,19 @@ module BOAST
       s += ", optional" if optional?
       s += ", allocatable" if allocate? and @allocate == :heap
       s += ", parameter" if constant?
-      if dimension? then
+      if dimension? or __vector? then
         s += ", dimension("
+        if __vector? then
+          s += "#{@type.vector_length}"
+          s += ", " if dimension?
+        end
         s += @dimension.collect { |d|
           if deferred_shape? or ( allocate? and @allocate == :heap )
             ":"
           else
             d.to_s
           end
-        }.join(", ")
+        }.join(", ") if dimension?
         s += ")"
       end
       s += " :: #{@name}"
@@ -581,7 +624,7 @@ module BOAST
       end
       s += finalize
       output.print s
-      if dimension? and (align? or default_align > 1) and (constant? or ( allocate? and @allocate != :heap ) ) then
+      if ( dimension? and (align? or default_align > 1) and (constant? or ( allocate? and @allocate != :heap ) ) ) or ( vector? and not @direction ) then
         a = ( align? ? alignment : 1 )
         a = ( a >= default_align ? a : default_align )
         s = ""